From 1bf6bcb2a06b5c0774b6111d86ee1d18f73d7a00 Mon Sep 17 00:00:00 2001
From: Hillary Mutisya <150286414+hillary-mutisya@users.noreply.github.com>
Date: Tue, 27 Oct 2026 14:51:45 -0700
Subject: [PATCH 1/4] Improve Memory Hub loading, navigation, and question
 readers

Add compact inventory projections and reliable RPC callback ownership, simplify graph payloads, and unify Inbox, Views, Questions, and source layouts. Add dedicated question routes, responsive cards, synopsis sidecards, and consistent accessible icon actions.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ts/packages/agentRpc/README.md                |   9 +
 ts/packages/agentRpc/src/client.ts            |  62 ++-
 .../agentRpc/test/actionContext.spec.ts       |  98 ++++
 ts/packages/agents/browser/README.md          |  77 ++-
 .../browser/src/agent/memoryHubGraph.mts      |  13 +-
 .../src/views/client/library/memoryHub.css    | 229 +++++---
 .../src/views/client/library/memoryHub.html   |  68 +--
 .../views/client/library/memoryHub.test.ts    |  90 ++++
 .../src/views/client/library/memoryHub.ts     | 107 +++-
 .../client/library/memoryHubEditorial.test.ts |   3 +
 .../client/library/memoryHubExplore.test.ts   |   1 +
 .../views/client/library/memoryHubExplore.ts  |  24 +-
 .../views/client/library/memoryHubGraph.css   |  22 +-
 .../client/library/memoryHubGraph.test.ts     | 349 +++++++------
 .../views/client/library/memoryHubGraph.ts    | 191 ++-----
 .../client/library/memoryHubInbox.test.ts     | 192 +++++++
 .../views/client/library/memoryHubInbox.ts    | 256 +++++++++
 .../library/memoryHubMaintenance.test.ts      |  10 +
 .../client/library/memoryHubMaintenance.ts    |  99 ++--
 .../client/library/memoryHubModel.test.ts     |   7 +
 .../views/client/library/memoryHubModel.ts    |   7 +
 .../library/memoryHubProjectBrief.test.ts     |  98 +++-
 .../client/library/memoryHubQuestions.test.ts | 209 +++++++-
 .../client/library/memoryHubQuestions.ts      | 368 +++++++++----
 .../client/library/memoryHubQuestionsModel.ts |   6 +-
 .../client/library/memoryHubTimeline.test.ts  |   4 +-
 .../views/client/library/memoryHubUi.test.ts  |  15 +
 .../src/views/client/library/memoryHubUi.ts   |  10 +
 .../client/library/memoryHubUsability.test.ts |   2 +-
 .../library/memoryHubViewActivity.test.ts     |  60 ++-
 .../client/library/memoryHubViewActivity.ts   |  66 ++-
 .../client/library/memoryHubViews.test.ts     | 448 ++++++++++++++--
 .../views/client/library/memoryHubViews.ts    | 490 ++++++++++++------
 .../browser/test/memoryHubGraph.test.mjs      |  43 ++
 .../src/memoryGraphViewTypes.ts               |   5 +-
 .../memory/client/src/inventoryProtocol.ts    |   3 +
 .../client/test/schemaViewProtocol.spec.mjs   |  36 ++
 ts/packages/memory/service/README.md          |  13 +
 .../memory/service/src/fileMemoryService.ts   |  14 +-
 .../memory/service/src/inventoryTypes.ts      |   2 +
 .../memory/service/src/viewReadProjection.ts  |  10 +
 ts/packages/memory/service/src/viewStore.ts   |   3 +-
 .../memory/service/test/schemaViews.spec.ts   |  78 +++
 .../service/test/viewIndexConcurrency.spec.ts | 143 +++--
 44 files changed, 3172 insertions(+), 868 deletions(-)
 create mode 100644 ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
 create mode 100644 ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts

diff --git a/ts/packages/agentRpc/README.md b/ts/packages/agentRpc/README.md
index 192f6f2144..47d747bc61 100644
--- a/ts/packages/agentRpc/README.md
+++ b/ts/packages/agentRpc/README.md
@@ -2,6 +2,15 @@
 
 This package contains code to support remoting TypeAgent SDK interfaces via an abstract RpcChannel interface.
 
+## Initialization option callbacks
+
+An agent process can serve multiple conversation contexts. Initialization options
+containing functions use a shared options RPC channel, with references retained
+per initialized context (including initializations still in flight). Closing one
+context releases only its options reference; the channel remains available to
+other contexts. The last release closes the channel, and subsequent initialization
+can create it again. Failed initialization also releases its reference.
+
 ## Connection convention: prefer `rpc.rebind` over recreate
 
 **Decision (adopted):** rpc connection clients should be built as a **durable
diff --git a/ts/packages/agentRpc/src/client.ts b/ts/packages/agentRpc/src/client.ts
index fe5e056fa4..77ae9eb132 100644
--- a/ts/packages/agentRpc/src/client.ts
+++ b/ts/packages/agentRpc/src/client.ts
@@ -262,6 +262,8 @@ export async function createAgentRpcClient(
 
     const actionContextMap = createObjectMap<ActionContext<ShimContext>>();
     let optionsRpc: ReturnType<typeof createOptionsRpc> | undefined;
+    const optionsReferences = new Map<unknown, number>();
+    const contextOptions = new Map<number, unknown>();
     function getOptionsCallBack(initOptions?: any) {
         const functions = getOptionsFunctions(initOptions);
         if (functions === undefined) {
@@ -270,11 +272,28 @@ export async function createAgentRpcClient(
         if (optionsRpc === undefined) {
             optionsRpc = createOptionsRpc(channelProvider, name, options);
         }
+        optionsReferences.set(
+            initOptions,
+            (optionsReferences.get(initOptions) ?? 0) + 1,
+        );
         return {
             id: optionsRpc.optionsMap.getId(initOptions),
             functions,
         };
     }
+    function releaseOptions(initOptions: unknown) {
+        const remaining = (optionsReferences.get(initOptions) ?? 0) - 1;
+        if (remaining > 0) {
+            optionsReferences.set(initOptions, remaining);
+            return;
+        }
+        optionsReferences.delete(initOptions);
+        optionsRpc?.optionsMap.close(initOptions);
+        if (!optionsReferences.size && optionsRpc) {
+            channelProvider.deleteChannel(getOptionsChannelName(name, options));
+            optionsRpc = undefined;
+        }
+    }
     function withActionContext<T>(
         actionContext: ActionContext<ShimContext>,
         fn: (contextParams: ActionContextParams) => T,
@@ -674,11 +693,30 @@ export async function createAgentRpcClient(
     }
 
     const agent: Required<AppAgent> = {
-        initializeAgentContext(settings?: AppAgentInitSettings) {
-            return rpc.invoke("initializeAgentContext", {
-                settings,
-                optionsCallBack: getOptionsCallBack(settings?.options),
-            });
+        async initializeAgentContext(settings?: AppAgentInitSettings) {
+            const optionsCallBack = getOptionsCallBack(settings?.options);
+            try {
+                const context = await rpc.invoke("initializeAgentContext", {
+                    settings,
+                    optionsCallBack,
+                });
+                if (optionsCallBack) {
+                    if (
+                        typeof context !== "object" ||
+                        context === null ||
+                        !("contextId" in context) ||
+                        typeof context.contextId !== "number"
+                    )
+                        throw new Error(
+                            "Agent initialization did not return a context ID",
+                        );
+                    contextOptions.set(context.contextId, settings?.options);
+                }
+                return context;
+            } catch (error) {
+                if (optionsCallBack) releaseOptions(settings?.options);
+                throw error;
+            }
         },
         updateAgentContext(
             enable,
@@ -915,12 +953,14 @@ export async function createAgentRpcClient(
             regIdsByContext.delete(contextId);
         }
         contextMap.close(context);
-        // Clean up the options RPC channel once this agent context is closed.
-        // Options are agent-scoped (created once per initializeAgentContext call)
-        // so they can be released when the context is torn down.
-        if (optionsRpc !== undefined) {
-            channelProvider.deleteChannel(getOptionsChannelName(name, options));
-            optionsRpc = undefined;
+        const agentContextId = context.agentContext?.contextId;
+        if (
+            agentContextId !== undefined &&
+            contextOptions.has(agentContextId)
+        ) {
+            const initOptions = contextOptions.get(agentContextId);
+            contextOptions.delete(agentContextId);
+            releaseOptions(initOptions);
         }
         return result;
     };
diff --git a/ts/packages/agentRpc/test/actionContext.spec.ts b/ts/packages/agentRpc/test/actionContext.spec.ts
index d8264d4f51..b4e50f5516 100644
--- a/ts/packages/agentRpc/test/actionContext.spec.ts
+++ b/ts/packages/agentRpc/test/actionContext.spec.ts
@@ -14,10 +14,108 @@ import {
 import { createAgentRpcServer } from "../src/server.js";
 import {
     ChoiceManager,
+    createActionResultFromTextDisplay,
     createYesNoChoiceResult,
 } from "@typeagent/agent-sdk/helpers/action";
 
 describe("agent action context RPC", () => {
+    test.each([false, true])(
+        "closing a context preserves surviving option callbacks (shared options: %s)",
+        async (shared) => {
+            let clientProvider: ChannelProviderAdapter;
+            let serverProvider: ChannelProviderAdapter;
+            clientProvider = createChannelProviderAdapter(
+                "options-client",
+                (message, callback) => {
+                    queueMicrotask(() =>
+                        serverProvider.notifyMessage(
+                            JSON.parse(JSON.stringify(message)),
+                        ),
+                    );
+                    callback?.(null);
+                },
+            );
+            serverProvider = createChannelProviderAdapter(
+                "options-server",
+                (message, callback) => {
+                    queueMicrotask(() =>
+                        clientProvider.notifyMessage(
+                            JSON.parse(JSON.stringify(message)),
+                        ),
+                    );
+                    callback?.(null);
+                },
+            );
+            const deletedChannels: string[] = [];
+            const deleteChannel = clientProvider.deleteChannel;
+            clientProvider.deleteChannel = (name) => {
+                deletedChannels.push(name);
+                deleteChannel(name);
+            };
+            type Options = { read(): string; fail?: boolean };
+            const agent: AppAgent = {
+                initializeAgentContext: async (settings) => {
+                    const options = settings?.options as Options;
+                    if (options.fail) throw new Error("Initialization failed");
+                    return options;
+                },
+                closeAgentContext: async () => {},
+                executeAction: async (_, context: ActionContext<Options>) =>
+                    createActionResultFromTextDisplay(
+                        await context.sessionContext.agentContext.read(),
+                    ),
+            };
+            const server = createAgentRpcServer(
+                "retained-options",
+                agent,
+                serverProvider,
+            );
+            const client = await createAgentRpcClient(
+                "retained-options",
+                clientProvider,
+                server.agentInterface,
+            );
+            const first = { read: () => "first" };
+            const second = shared ? first : { read: () => "second" };
+            let sessionId = 0;
+            const initialize = async (options: Options) =>
+                ({
+                    sessionContextId: `options-${++sessionId}`,
+                    agentContext: await client.initializeAgentContext!({
+                        options,
+                    }),
+                }) as SessionContext<unknown>;
+            const read = (sessionContext: SessionContext<unknown>) =>
+                client.executeAction!(
+                    { schemaName: "test", actionName: "read" },
+                    { sessionContext } as ActionContext<unknown>,
+                );
+            try {
+                const a = await initialize(first);
+                const b = await initialize(second);
+                await expect(
+                    initialize({ read: () => "", fail: true }),
+                ).rejects.toThrow("Initialization failed");
+                await client.closeAgentContext!(a);
+                expect(deletedChannels).toEqual([]);
+                await expect(read(b)).resolves.toMatchObject({
+                    displayContent: shared ? "first" : "second",
+                });
+                await client.closeAgentContext!(b);
+                expect(deletedChannels).toContain("options:retained-options");
+                const c = await initialize(first);
+                await expect(read(c)).resolves.toMatchObject({
+                    displayContent: "first",
+                });
+                await client.closeAgentContext!(c);
+            } finally {
+                server.closeFn();
+                clientProvider.notifyDisconnected();
+                serverProvider.notifyDisconnected();
+            }
+        },
+    );
+
     test("invokes nested initialization option methods with their receiver", async () => {
         let clientProvider: ChannelProviderAdapter;
         let serverProvider: ChannelProviderAdapter;
diff --git a/ts/packages/agents/browser/README.md b/ts/packages/agents/browser/README.md
index 2c30958fa5..0fc40d48a2 100644
--- a/ts/packages/agents/browser/README.md
+++ b/ts/packages/agents/browser/README.md
@@ -39,8 +39,15 @@ separately. Updating Puppeteer does not patch system Chrome.
 ### Scoped graphs and Memory Hub navigation
 
 Memory Hub Explore supports entity, topic and maintained hierarchy graphs with
-document/event filters, bounded generation-aware paging, coverage diagnostics and
-exact evidence drilldown. Graph preparation happens separately from reads; hosts
+document/event filters, bounded graph previews and exact evidence drilldown.
+The entity and topic pages show filters, graph controls and the canvas without
+coverage disclosures, collection/count paging rows, browse lists or routine
+maintenance status messages. Loading, empty states and request failures remain
+visible. Refresh, Global and Fit are Font Awesome icon buttons with accessible
+labels and tooltips, grouped inside the upper-left corner of the graph canvas.
+The graph response omits coverage, counts, limits and inventory paging
+metadata; topic generation is retained for snapshot-safe evidence drilldown.
+Graph preparation happens separately from reads; hosts
 without the scoped capability report it explicitly. Retained originals and event
 bodies remain subject to current eligibility and suppression checks.
 
@@ -48,9 +55,69 @@ Views use paginated cards and a separate detail reader, with build receipts in a
 flyout. Grouped activity, Inbox navigation and responsive detail panels reuse
 summary inventories rather than fetching every view's full evidence. These
 navigation features do not depend on checkpoint or integrated-answer APIs.
+Inventory pages contain up to 25 summaries per collection, not 25 globally.
+Inbox has counted tabs for Question decisions, Views, and Sources & operations.
+Its All overview shows at most two compact rows per category, with Questions
+first; full explanations and existing actions open in a details side panel.
+Review uses a file-lines icon button, and each All-overview section's View all
+action uses a list icon button. Both retain descriptive accessible names and
+tooltips. Views uses a bell for Latest build, retaining its spinner while a build
+is running.
+Counts describe loaded attention items/groups, with `+` when more may be
+available, rather than claiming a complete cross-collection total. Switching
+tabs or opening an explanation does not fetch another evidence inventory.
+Activity and Inbox use summary conflict state where available; full conflict
+evidence is reserved for selected details or older-service compatibility.
+
+Explore, Inbox, Sources, Views, Questions and Activity share icon-and-underline
+navigation styling. Active filters retain their pressed state; actual tab panels
+retain their selected state. Tab strips scroll horizontally rather than wrapping
+or widening the page on smaller screens. Views exposes its existing type filter
+as tabs above search and build controls, preserving paginated inventory queries,
+search text, keyboard focus and horizontal scroll position when it refreshes.
+Supported Views tabs are ordered All, Knowledge Wiki, Project Brief, Timeline
+and Troubleshooting Guide. Questions has its own left-navigation entry rather
+than a duplicate Views filter tab. Collection-maintenance entry points use the
+screwdriver-and-wrench icon.
+
+Views and Questions place those tabs directly after the page title. Their lists,
+search controls and bottom pagination live in Sources-style surface cards with
+server-reported totals in the upper-right corner, not loaded-page counts.
+Unavailable question inventories are marked unavailable or partial rather than
+displayed as a complete zero. Knowledge preparation remains lazy and is placed
+at the bottom of Questions. Explore Overview has no separate refresh button;
+scope changes and the main refresh action retain their existing behavior.
+
+Wiki and Project Brief readers distinguish synopsis and coverage caveats from
+their main sections in a blue-tinted right-hand infobox, alongside version,
+completeness and revision
+metadata. Article text wraps beside the infobox on wide screens; at 800 px and
+below the panel stacks above the article. Source disclosures, section navigation
+and edit actions remain available. Project Brief goals, owners, status, milestones,
+decisions, risks and context stay in the main reading flow; other view types retain
+their layout.
+Reader Back and Edit controls are icon-only with accessible names and tooltips.
+The overflow control opens the shared icon-and-text action menu, including
+conditional conflict review and generated-update unlocks. Escape dismisses the
+menu; closing an action dialog returns focus to the overflow trigger.
+
+Views shows a spinner and loading message inside the list card during type
+changes, hiding stale results and paging until the new inventory settles.
+Rapid type changes queue the latest filter rather than dropping it while another
+read is in flight. Failed reads remain explicit and do not display a misleading
+empty result.
 
 ### Schema-defined questions
 
+The Questions landing page uses two columns of compact cards, stacking into one
+column at 800 px and below. A card opens a dedicated question reader at a
+corpus/view/slot deep link. Answer candidates and evidence stay in the main content,
+while an option B sidecard groups coverage, review/admission state, view version
+and evaluated-source metadata. The reader retains guarded edits, explicit errors,
+retry, history and exact evidence. Back returns to the previous scoped inventory
+with its filters and paging; direct links can load slots outside the current page
+without scanning every collection.
+
 The Memory hub's Questions workspace is a complete projection of versioned
 schema-view slots, including proposed and rejected slots. The inspector reviews
 candidates and exact source revisions, records schema-validated user assertions,
@@ -72,8 +139,10 @@ Markdown links preserve exact revisions, slots and collection item keys when
 opened in the browser. Optional service capabilities and operation errors are
 reported explicitly, not interpreted as empty inventories. Question lists use
 bounded summary pages; selecting a question separately loads its full evidence.
-Questions also mounts knowledge preparation status, discovery policy controls,
-bounded failed-discovery retries and captured readiness checkpoints. Existing
+Questions loads knowledge preparation status, discovery policy controls,
+bounded failed-discovery retries and captured readiness checkpoints. This
+progress is fetched only when the Knowledge preparation disclosure is expanded,
+not when loading question lists or Inbox attention. Existing
 corpora remain off until enabled; new corpora default to source observed.
 Policy admission is not human confirmation, and source indexing alone never
 implies knowledge readiness. Integrated search answers retain original-source
diff --git a/ts/packages/agents/browser/src/agent/memoryHubGraph.mts b/ts/packages/agents/browser/src/agent/memoryHubGraph.mts
index 07fa39667e..1bfe4dcdcd 100644
--- a/ts/packages/agents/browser/src/agent/memoryHubGraph.mts
+++ b/ts/packages/agents/browser/src/agent/memoryHubGraph.mts
@@ -158,10 +158,21 @@ export function createMemoryHubGraphFunctions(
                         Math.floor(maxEdges / selected.length),
                     ),
                 };
+                const graph = await timed(query.call(service, input));
                 result.corpora.push({
                     corpusId: corpus.corpusId,
                     corpusName: corpus.name,
-                    graph: await timed(query.call(service, input)),
+                    graph: {
+                        generation: graph.generation,
+                        nodes: graph.nodes,
+                        edges: graph.edges,
+                        ...(graph.coverage.topics?.generation
+                            ? {
+                                  topicGeneration:
+                                      graph.coverage.topics.generation,
+                              }
+                            : {}),
+                    },
                 });
             } catch (error) {
                 const message =
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHub.css b/ts/packages/agents/browser/src/views/client/library/memoryHub.css
index e3c7081386..94c6ace133 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHub.css
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHub.css
@@ -19,10 +19,27 @@ body[data-memory-hub] {
 }
 
 .hub-draft-views {
-  margin-top: 20px;
-  padding: 16px;
-  border: 1px solid var(--border);
-  border-radius: 8px;
+  min-width: 0;
+}
+.hub-draft-views > p:empty {
+  display: none;
+}
+.hub-draft-views .hub-tabs > button {
+  margin: 0 0 -1px;
+}
+.hub-list-card {
+  min-width: 0;
+}
+.hub-list-card > .section-heading {
+  margin-bottom: 12px;
+}
+.hub-list-card > .section-heading h2 {
+  margin: 0;
+}
+.hub-list-total {
+  color: var(--primary-dark);
+  font-size: 13px;
+  white-space: nowrap;
 }
 .hub-draft-views fieldset label {
   display: flex;
@@ -70,8 +87,12 @@ body[data-memory-hub] {
   gap: 8px;
   margin: 12px 0;
 }
-.hub-view-actions > details {
-  position: relative;
+.hub-view-actions button {
+  margin: 0;
+}
+.hub-view-actions .hub-menu {
+  width: max-content;
+  max-width: min(320px, calc(100vw - 64px));
 }
 .hub-view-document {
   max-width: 900px;
@@ -104,6 +125,64 @@ body[data-memory-hub] {
   color: var(--muted);
   font-size: 13px;
 }
+.hub-view-reading-flow {
+  display: flow-root;
+}
+.hub-view-infobox {
+  box-sizing: border-box;
+  float: right;
+  width: 310px;
+  max-width: 43%;
+  margin: 0 0 24px 28px;
+  padding: 20px;
+  border: 1px solid #cbdce8;
+  border-top: 4px solid #7599b6;
+  border-radius: 8px;
+  background: #edf5fa;
+  color: #3d5870;
+  font-size: 12px;
+  line-height: 1.75;
+}
+.hub-view-infobox > h3 {
+  margin: 0 0 6px;
+  color: #345b78;
+  font-size: 16px;
+}
+.hub-view-infobox-label {
+  margin: 0 0 14px;
+  color: #526e83;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+.hub-view-infobox .hub-view-lead > :first-child {
+  margin-top: 0;
+}
+.hub-view-infobox .hub-view-lead > :last-child {
+  margin-bottom: 0;
+}
+.hub-view-infobox > .hub-view-note,
+.hub-view-infobox > .hub-view-meta {
+  margin: 16px 0 0;
+  padding-top: 14px;
+  border-top: 1px solid #cddfea;
+  color: #526e83;
+  font-size: 11px;
+}
+.hub-view-infobox > .hub-view-meta {
+  display: block;
+}
+.hub-view-infobox .hub-chips {
+  margin-bottom: 8px;
+}
+@media (max-width: 800px) {
+  .hub-view-infobox {
+    float: none;
+    width: 100%;
+    max-width: none;
+    margin: 0 0 24px;
+  }
+}
 .hub-view-section > h3 {
   margin: 20px 0 8px;
   font-size: 15px;
@@ -153,22 +232,6 @@ body[data-memory-hub] {
   clip: rect(0 0 0 0);
   white-space: nowrap;
 }
-.hub-view-more-actions > summary {
-  display: inline-grid;
-  place-items: center;
-  width: 32px;
-  height: 32px;
-  border-radius: 6px;
-  list-style: none;
-  cursor: pointer;
-}
-.hub-view-more-actions > summary::-webkit-details-marker {
-  display: none;
-}
-.hub-view-more-actions > summary:hover {
-  background: var(--surface-alt);
-}
-.hub-draft-views:has(.hub-view-document) > h3,
 .hub-draft-views:has(.hub-view-document) > p,
 .hub-draft-views:has(.hub-view-document) > .hub-view-build-receipt {
   display: none;
@@ -192,7 +255,6 @@ body[data-memory-hub] {
   margin: 16px 0;
 }
 @media (max-width: 600px) {
-  .hub-draft-views,
   .hub-view-document {
     padding: 12px;
   }
@@ -543,14 +605,20 @@ body[data-memory-hub] {
 /* Tabs: underline style for both buttons and links */
 .hub-tabs {
   display: flex;
-  flex-wrap: wrap;
+  flex-wrap: nowrap;
   gap: 2px;
+  max-width: 100%;
+  min-width: 0;
   margin: 0 0 14px;
   border-bottom: 1px solid var(--border);
+  overflow-x: auto;
+  overflow-y: hidden;
+  scrollbar-width: thin;
 }
 .hub-tabs > button,
 .hub-tabs > a {
   display: inline-flex;
+  flex: 0 0 auto;
   align-items: center;
   gap: 7px;
   min-height: 0;
@@ -562,6 +630,7 @@ body[data-memory-hub] {
   background: transparent;
   color: var(--muted);
   text-decoration: none;
+  white-space: nowrap;
 }
 .hub-tabs > button:hover:not(:disabled),
 .hub-tabs > a:hover {
@@ -569,12 +638,17 @@ body[data-memory-hub] {
   color: var(--text);
 }
 .hub-tabs > button[aria-selected="true"],
+.hub-tabs > button[aria-selected="true"]:hover,
+.hub-page .hub-tabs > button[aria-pressed="true"],
 .hub-tabs > a[aria-current="page"] {
   border-bottom-color: var(--primary);
   background: transparent;
   color: var(--primary-dark);
   font-weight: 650;
 }
+.hub-tabs > :focus-visible {
+  outline-offset: -3px;
+}
 .hub-explore-nav {
   margin-top: 0;
 }
@@ -717,6 +791,62 @@ textarea:focus-visible {
 }
 
 /* Inbox */
+.hub-inbox-tabs {
+  position: sticky;
+  top: 0;
+  z-index: 2;
+  background: var(--background);
+}
+.hub-inbox-workspace [role="tabpanel"][hidden] {
+  display: none;
+}
+.hub-inbox-overview-group {
+  margin: 8px 0 16px;
+}
+.hub-inbox-overview-head {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.hub-inbox-overview-head h3 {
+  margin: 0;
+}
+.hub-inbox-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin: 6px 0;
+  padding: 10px 12px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+}
+.hub-inbox-item-text {
+  flex: 1;
+  min-width: 0;
+}
+.hub-inbox-item h4 {
+  margin: 0;
+  font-size: 14px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.hub-inbox-item p {
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  overflow-wrap: anywhere;
+  margin: 3px 0 0;
+  font-size: 12px;
+  color: var(--muted);
+}
+.hub-inbox-item > button {
+  flex: 0 0 auto;
+}
 .inbox-card {
   display: flex;
   align-items: center;
@@ -1222,10 +1352,13 @@ textarea:focus-visible {
   max-height: none;
 }
 
-/* Questions: list on the left, selected question beside it */
+/* Questions: card inventory and a separate detail reader */
 .hub-qhead {
   flex-wrap: wrap;
 }
+.hub-qhead [role="status"]:empty {
+  display: none;
+}
 .hub-qfilters {
   display: flex;
   flex-wrap: wrap;
@@ -1275,16 +1408,10 @@ textarea:focus-visible {
 .hub-notice i {
   margin-right: 8px;
 }
-.hub-split {
-  display: grid;
-  grid-template-columns: minmax(280px, 2fr) minmax(0, 3fr);
-  gap: 16px;
-  align-items: start;
-}
 .hub-qlist {
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
   min-width: 0;
 }
 .hub-qrow {
@@ -1329,30 +1456,14 @@ textarea:focus-visible {
   white-space: nowrap;
 }
 .hub-qdetail {
-  position: sticky;
-  top: 8px;
-  max-height: calc(100vh - 24px);
   min-width: 0;
-  overflow: auto;
-  padding: 0 4px 16px;
-}
-.hub-qdetail:empty::before {
-  content: "Select a question to see its answers.";
-  color: var(--muted);
-}
-.hub-qdetail-head {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 8px;
 }
-.hub-qdetail-head h3 {
-  flex: 1 1 100%;
-  margin: 0;
-  font-size: 16px;
+.hub-question-content {
+  display: flow-root;
 }
-.hub-qdetail-head .hub-row-actions {
-  margin-left: auto;
+.hub-question-reader .hub-view-actions {
+  max-width: 900px;
+  margin: 0 auto 8px;
 }
 .hub-qdetail details {
   margin: 10px 0;
@@ -1384,14 +1495,10 @@ textarea:focus-visible {
   cursor: pointer;
   font-weight: 600;
 }
-@media (max-width: 900px) {
-  .hub-split {
+@media (max-width: 800px) {
+  .hub-qlist {
     grid-template-columns: minmax(0, 1fr);
   }
-  .hub-qdetail {
-    position: static;
-    max-height: none;
-  }
 }
 .hub-qdetail .card .hub-row-actions {
   display: flex;
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHub.html b/ts/packages/agents/browser/src/views/client/library/memoryHub.html
index f6c8cc7720..d3a8b09c9f 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHub.html
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHub.html
@@ -101,42 +101,44 @@ <h1><i class="fa-solid fa-brain" aria-hidden="true"></i>Memory</h1>
             <h2>Inbox</h2>
             <span id="inboxSummary" class="hub-chip"></span>
           </div>
-          <div class="hub-controls" id="inboxFilters">
-            <div
-              id="inboxChips"
-              class="hub-chips"
-              role="group"
-              aria-label="Filter by kind"
-            ></div>
-            <label class="checkbox"
-              ><input id="inboxDismissed" type="checkbox" />Show dismissed and
-              snoozed</label
-            >
+          <div id="hubInboxOperations">
+            <div class="hub-controls" id="inboxFilters">
+              <div
+                id="inboxChips"
+                class="hub-chips"
+                role="group"
+                aria-label="Filter by kind"
+              ></div>
+              <label class="checkbox"
+                ><input id="inboxDismissed" type="checkbox" />Show dismissed and
+                snoozed</label
+              >
+            </div>
+            <div id="hubInbox"></div>
+            <div class="pager">
+              <button
+                id="inboxPrevious"
+                class="icon-btn"
+                type="button"
+                aria-label="Previous page"
+                title="Previous page"
+              >
+                <i class="fa-solid fa-chevron-left" aria-hidden="true"></i>
+              </button>
+              <span id="inboxPage"></span>
+              <button
+                id="inboxNext"
+                class="icon-btn"
+                type="button"
+                aria-label="Next page"
+                title="Next page"
+              >
+                <i class="fa-solid fa-chevron-right" aria-hidden="true"></i>
+              </button>
+            </div>
           </div>
-          <div id="hubInbox"></div>
           <div id="hubViewAttention"></div>
           <div id="hubQuestionAttention"></div>
-          <div class="pager">
-            <button
-              id="inboxPrevious"
-              class="icon-btn"
-              type="button"
-              aria-label="Previous page"
-              title="Previous page"
-            >
-              <i class="fa-solid fa-chevron-left" aria-hidden="true"></i>
-            </button>
-            <span id="inboxPage"></span>
-            <button
-              id="inboxNext"
-              class="icon-btn"
-              type="button"
-              aria-label="Next page"
-              title="Next page"
-            >
-              <i class="fa-solid fa-chevron-right" aria-hidden="true"></i>
-            </button>
-          </div>
         </section>
         <section id="page-questions" class="hub-page hidden">
           <div id="hubQuestions"></div>
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHub.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHub.test.ts
index cd3a2197f5..e7ea37d2e6 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHub.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHub.test.ts
@@ -11,6 +11,7 @@ import { invokeMemory, invokeView } from "./viewClient";
 import { hubAction, mountMemoryHub } from "./memoryHub";
 import * as webExplore from "./memoryHubWebExplore";
 import * as graphExplore from "./memoryHubGraph";
+import { question } from "./memoryHubQuestionsTestData";
 
 jest.mock("./viewClient", () => ({
     invokeMemory: jest.fn(),
@@ -105,6 +106,12 @@ beforeEach(() => {
     invoke.mockImplementation(
         async (method: string, params: { corpusId?: string }) => {
             switch (method) {
+                case "memoryViewCapabilities":
+                    return { derivedViews: { kinds: ["schemaView"] } };
+                case "memoryListQuestionSummaries":
+                    return { head: "head", items: [], total: 0, warnings: [] };
+                case "memoryListQuestionAttention":
+                    return { items: [], total: 0 };
                 case "memoryGetCorpus":
                     return { ...corpus, corpusId: params.corpusId };
                 case "memoryListJobs":
@@ -706,12 +713,18 @@ test("the complete shell mounts reused panels, global Add and reversible triage"
     expect(value("hubSettings").querySelector("#saveHowToSettings")).toBeNull();
     expect(value("createCorpusDialog").parentElement).toBe(document.body);
     value("hubInbox")
+        .querySelector<HTMLButtonElement>('[aria-label^="Review:"]')!
+        .click();
+    value("page-inbox")
         .querySelector<HTMLButtonElement>('[aria-label="Dismiss"]')!
         .click();
     expect(value("inboxBadge").textContent).toBe("0");
     value<HTMLInputElement>("inboxDismissed").checked = true;
     value("inboxDismissed").dispatchEvent(new Event("change"));
     value("hubInbox")
+        .querySelector<HTMLButtonElement>('[aria-label^="Review:"]')!
+        .click();
+    value("page-inbox")
         .querySelector<HTMLButtonElement>('[aria-label="Restore"]')!
         .click();
     expect(value("inboxBadge").textContent).toBe("1");
@@ -757,6 +770,15 @@ test("the complete shell mounts reused panels, global Add and reversible triage"
     expect(value("contentEditor").classList.contains("hidden")).toBe(true);
     expect(document.getElementById("hubInspector")).toBeNull();
     expect(value("page-activity").dataset.activityTab).toBe("jobs");
+    for (const tab of value("page-activity").querySelectorAll(
+        ".hub-tabs button",
+    ))
+        expect(tab.querySelector('i[aria-hidden="true"]')).not.toBeNull();
+    const sourceTabs = value("hubSources").querySelector(".hub-source-types")!;
+    expect(sourceTabs.classList).toContain("hub-tabs");
+    expect(sourceTabs.querySelectorAll('i[aria-hidden="true"]')).toHaveLength(
+        7,
+    );
     expect(value("page-settings").dataset.settingsTab).toBe("graph");
     expect(document.getElementById("hubRunbooks")).toBeNull();
     expect(document.getElementById("hubLegacyGuides")).toBeNull();
@@ -1013,6 +1035,74 @@ test("the complete shell mounts reused panels, global Add and reversible triage"
     expect(document.querySelector(".alert-success")?.textContent).toBe(
         'Forgot source "Source".',
     );
+    const beforeQuestions = invoke.getMockImplementation()!;
+    const selectedQuestion = { ...question(), corpusId: "a" };
+    invoke.mockImplementation((method: string, params: unknown) => {
+        if (method === "memoryViewCapabilities")
+            return Promise.resolve({ derivedViews: { kinds: ["schemaView"] } });
+        if (method === "memoryListQuestionSummaries")
+            return Promise.resolve({
+                head: "head",
+                items: [selectedQuestion],
+                total: 1,
+                warnings: [],
+            });
+        if (method === "memoryGetQuestion")
+            return Promise.resolve(selectedQuestion);
+        if (method === "memoryListQuestionAttention")
+            return Promise.resolve({ items: [], total: 0 });
+        return beforeQuestions(method, params);
+    });
+    viewInvoke.mockImplementation(beforeInboxRefresh);
+    selector.value = "";
+    selector.dispatchEvent(new Event("change"));
+    await settle();
+    value("hubRefresh").click();
+    await settle();
+    await settle();
+    jest.advanceTimersByTime(6000);
+    await settle();
+    history.replaceState({}, "", "#/questions");
+    window.dispatchEvent(new HashChangeEvent("hashchange"));
+    await settle();
+    expect(value("page-questions").textContent).toContain("What is the name?");
+    value("page-questions")
+        .querySelector<HTMLButtonElement>(".hub-qrow button")!
+        .click();
+    expect(location.hash).toBe("#/questions/a/view/slot/slot");
+    window.dispatchEvent(new HashChangeEvent("hashchange"));
+    await settle();
+    expect(
+        value("page-questions").querySelector(".hub-view-infobox")!.textContent,
+    ).toContain("Question overview");
+    const questionAnswer = value(
+        "page-questions",
+    ).querySelector<HTMLTextAreaElement>(".hub-qdetail textarea")!;
+    questionAnswer.value = '"Ada"';
+    questionAnswer.dispatchEvent(new Event("input"));
+    const questionBack = value(
+        "page-questions",
+    ).querySelector<HTMLButtonElement>('[aria-label="Back to questions"]')!;
+    jest.mocked(window.confirm).mockReturnValueOnce(false);
+    questionBack.click();
+    expect(location.hash).toBe("#/questions/a/view/slot/slot");
+    questionBack.click();
+    expect(location.hash).toBe("#/questions");
+    window.dispatchEvent(new HashChangeEvent("hashchange"));
+    await settle();
+    expect(
+        value("page-questions").querySelector<HTMLElement>(
+            ".hub-question-reader",
+        )!.hidden,
+    ).toBe(true);
+    history.replaceState({}, "", "#/questions/a/view/slot/slot");
+    window.dispatchEvent(new HashChangeEvent("hashchange"));
+    await settle();
+    expect(
+        value("page-questions").querySelector<HTMLElement>(
+            ".hub-question-reader",
+        )!.hidden,
+    ).toBe(false);
     history.replaceState({}, "", "#/settings");
     window.dispatchEvent(new HashChangeEvent("hashchange"));
     await settle();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHub.ts b/ts/packages/agents/browser/src/views/client/library/memoryHub.ts
index 05cc6dfd7b..2f96c222de 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHub.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHub.ts
@@ -20,6 +20,7 @@ import { mountMemoryHubCapture } from "./memoryHubCapture";
 
 import { mountMemoryHubViews } from "./memoryHubViews";
 import { mountMemoryHubQuestions } from "./memoryHubQuestions";
+import { mountMemoryHubInbox } from "./memoryHubInbox";
 import { mountMemoryHubViewActivity } from "./memoryHubViewActivity";
 import { renderDerivedViewUsage } from "./memoryHubViewUsage";
 
@@ -30,7 +31,13 @@ import { mountMemoryHubWebExplore } from "./memoryHubWebExplore";
 import { notificationManager } from "./knowledgeUtilities";
 import { migrateLegacyMemoryLocation } from "./memoryHubMigration";
 import { mountThemeToggle } from "./memoryHubTheme";
-import { icon, iconButton, menuButton, setIconButton } from "./memoryHubUi";
+import {
+    icon,
+    iconButton,
+    menuButton,
+    setIconButton,
+    setTabLabel,
+} from "./memoryHubUi";
 import {
     inboxCounts,
     inboxItems,
@@ -79,6 +86,9 @@ let questionsPanel: ReturnType<typeof mountMemoryHubQuestions>;
 let viewActivityPanel: ReturnType<typeof mountMemoryHubViewActivity>;
 let viewAttentionCount = 0;
 let questionAttentionCount = 0;
+let viewAttentionMore = false;
+let questionAttentionMore = false;
+let inboxPanel: ReturnType<typeof mountMemoryHubInbox>;
 
 let runbookImportsPanel: ReturnType<typeof mountMemoryHubRunbookImports>;
 let webMaintenancePanel: ReturnType<typeof mountMemoryHubWebMaintenance>;
@@ -483,7 +493,9 @@ function renderInbox(): void {
             : "?";
     el("activityBadge").dataset.count = String(counts.failedJobs);
     el("inboxSummary").textContent =
-        snapshotAvailable && attentionCount ? `${attentionCount} need you` : "";
+        snapshotAvailable && attentionCount
+            ? `${attentionCount}${viewAttentionMore || questionAttentionMore ? "+" : ""} need you`
+            : "";
     const dismissedBox = el<HTMLInputElement>("inboxDismissed");
     const dismissed = dismissedBox.checked;
     const available = inboxItems(snapshot.inbox, hidden, {
@@ -509,9 +521,13 @@ function renderInbox(): void {
     );
     const list = el("hubInbox");
     list.replaceChildren(
-        ...items
-            .slice(inboxPage * 25, (inboxPage + 1) * 25)
-            .map((item) => inboxCard(item, dismissed)),
+        ...items.slice(inboxPage * 25, (inboxPage + 1) * 25).map((item) =>
+            inboxPanel.present({
+                title: item.title,
+                summary: `${inboxKinds[item.kind].label} · ${item.reason}`,
+                detail: inboxCard(item, dismissed),
+            }),
+        ),
     );
     if (!items.length && !viewAttentionCount && !questionAttentionCount)
         list.append(
@@ -530,6 +546,7 @@ function renderInbox(): void {
     el<HTMLButtonElement>("inboxPrevious").disabled = inboxPage === 0;
     el<HTMLButtonElement>("inboxNext").disabled =
         (inboxPage + 1) * 25 >= items.length;
+    if (snapshotAvailable) inboxPanel.setCount("operations", counts.inbox);
 }
 
 function renderErrors(): void {
@@ -558,6 +575,7 @@ async function refreshSnapshot(refreshQuestions = true): Promise<void> {
     } catch (error) {
         if (version === snapshotVersion) {
             snapshotAvailable = false;
+            inboxPanel.fail("operations", error);
             renderInbox();
         }
         throw error;
@@ -689,17 +707,17 @@ async function loadManagement(): Promise<void> {
     typeSelect.id = "hubSourceType";
     typeSelect.hidden = true;
     const typeChips = document.createElement("div");
-    typeChips.className = "hub-chips hub-source-types";
+    typeChips.className = "hub-tabs hub-source-types";
     typeChips.setAttribute("role", "group");
     typeChips.setAttribute("aria-label", "Source type");
-    for (const [type, label] of [
-        ["", "All"],
-        ["web", "Web"],
-        ["markdown", "Markdown"],
-        ["text", "Text"],
-        ["html", "HTML"],
-        ["vtt", "Transcript"],
-        [PDF_CHIP, "PDF"],
+    for (const [type, label, glyph] of [
+        ["", "All", "fa-layer-group"],
+        ["web", "Web", "fa-globe"],
+        ["markdown", "Markdown", "fa-file-lines"],
+        ["text", "Text", "fa-file"],
+        ["html", "HTML", "fa-code"],
+        ["vtt", "Transcript", "fa-closed-captioning"],
+        [PDF_CHIP, "PDF", "fa-file-pdf"],
     ]) {
         if (type !== PDF_CHIP) {
             const option = document.createElement("option");
@@ -717,6 +735,7 @@ async function loadManagement(): Promise<void> {
                 other.setAttribute("aria-pressed", String(other === chip));
             el("applySourceFilter").click();
         });
+        setTabLabel(chip, glyph, label);
         chip.setAttribute("aria-pressed", String(type === ""));
         typeChips.append(chip);
     }
@@ -831,7 +850,7 @@ function mountPageTabs(
     pageId: string,
     attribute: string,
     label: string,
-    tabs: ReadonlyArray<readonly [string, string]>,
+    tabs: ReadonlyArray<readonly [string, string, string]>,
 ): void {
     const page = el(pageId);
     const nav = document.createElement("nav");
@@ -846,8 +865,12 @@ function mountPageTabs(
                 String(tab.dataset.pageTab === name),
             );
     };
-    for (const [name, text] of tabs) {
-        const tab = button(text, () => select(name));
+    for (const [name, text, glyph] of tabs) {
+        const tab = setTabLabel(
+            button(text, () => select(name)),
+            glyph,
+            text,
+        );
         tab.setAttribute("role", "tab");
         tab.dataset.pageTab = name;
         nav.append(tab);
@@ -858,13 +881,13 @@ function mountPageTabs(
 
 function mountPageTabSets(): void {
     mountPageTabs("page-activity", "activityTab", "Activity views", [
-        ["jobs", "Operations"],
-        ["web", "Web history"],
-        ["changes", "Changes"],
+        ["jobs", "Operations", "fa-list-check"],
+        ["web", "Web history", "fa-clock-rotate-left"],
+        ["changes", "Changes", "fa-code-compare"],
     ]);
     mountPageTabs("page-settings", "settingsTab", "Settings groups", [
-        ["graph", "Browser graph"],
-        ["view", "View"],
+        ["graph", "Browser graph", "fa-diagram-project"],
+        ["view", "View", "fa-sliders"],
     ]);
 }
 
@@ -1080,6 +1103,7 @@ function updateExploreScope(
 }
 
 function showPage(route: HubRoute, visiblePage: (typeof pages)[number]): void {
+    inboxPanel.close();
     if (visiblePage !== "views") draftViewsPanel.hide();
     if (visiblePage !== "questions") questionsPanel.hide();
     if (visiblePage !== "activity") viewActivityPanel.hide();
@@ -1205,7 +1229,11 @@ async function showManagedRoute(
         );
     const corpusId = item?.corpusId ?? route.corpusId ?? scope;
     if (route.page === "questions") {
-        await questionsPanel.show(route.objectId, corpusId || undefined);
+        await questionsPanel.show(
+            route.objectId,
+            corpusId || undefined,
+            route.questionSlotId,
+        );
         return;
     }
     if (route.page === "views") {
@@ -1327,6 +1355,19 @@ export async function mountMemoryHub(): Promise<void> {
         history.replaceState(history.state, "", migrated.href);
         lastHash = location.hash;
     }
+    inboxPanel = mountMemoryHubInbox(el("page-inbox"), [
+        {
+            id: "questions",
+            label: "Question decisions",
+            host: el("hubQuestionAttention"),
+        },
+        { id: "views", label: "Views", host: el("hubViewAttention") },
+        {
+            id: "operations",
+            label: "Sources & operations",
+            host: el("hubInboxOperations"),
+        },
+    ]);
     el("hubRefresh").onclick = () => location.reload();
     await loadManagement();
     mountPhaseTwo();
@@ -1338,6 +1379,9 @@ export async function mountMemoryHub(): Promise<void> {
             corpora: () => snapshot.corpora,
             hidden,
             persistHidden,
+            onNavigate: (route) => {
+                open(route);
+            },
             onError: (error) => {
                 void hubAction(async () => {
                     throw error;
@@ -1346,8 +1390,12 @@ export async function mountMemoryHub(): Promise<void> {
             onOpenSource: (corpusId, objectId) => {
                 open({ page: "library", corpusId, objectId });
             },
-            onAttentionCount: (count) => {
+            presentAttention: inboxPanel.present,
+            onAttentionError: (error) => inboxPanel.fail("questions", error),
+            onAttentionCount: (count, hasMore = false) => {
                 questionAttentionCount = count;
+                questionAttentionMore = hasMore;
+                inboxPanel.setCount("questions", count, hasMore);
                 renderInbox();
             },
         },
@@ -1395,8 +1443,12 @@ export async function mountMemoryHub(): Promise<void> {
                     objectId,
                     activityKind: "view-build",
                 }),
-            onAttentionCount: (count) => {
+            presentAttention: inboxPanel.present,
+            onAttentionError: (error) => inboxPanel.fail("views", error),
+            onAttentionCount: (count, hasMore = false) => {
                 viewAttentionCount = count;
+                viewAttentionMore = hasMore;
+                inboxPanel.setCount("views", count, hasMore);
                 renderInbox();
             },
         },
@@ -1507,6 +1559,11 @@ export async function mountMemoryHub(): Promise<void> {
 
         draftViewsPanel.scopeChanged();
         viewActivityPanel.scopeChanged();
+        viewAttentionCount = 0;
+        questionAttentionCount = 0;
+        viewAttentionMore = false;
+        questionAttentionMore = false;
+        inboxPanel.reset();
 
         runbookImportsPanel.scopeChanged();
         renderErrors();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubEditorial.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubEditorial.test.ts
index c432163ed0..868184a94a 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubEditorial.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubEditorial.test.ts
@@ -146,6 +146,9 @@ test("explicit authenticated unit unlock and current related navigation use exis
         await settle();
         click(host, "Deliberate human title");
         await settle();
+        host.querySelector<HTMLButtonElement>(
+            'button[aria-label="More actions"]',
+        )!.click();
         expect(
             [...host.querySelectorAll("button")].some(
                 (entry) =>
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.test.ts
index 9b7583e573..8969d03825 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.test.ts
@@ -123,6 +123,7 @@ afterEach(() => {
 
 test("overview retains counts and corpus-qualified provenance without plotting a combined graph", async () => {
     await mounted.show();
+    expect(host.querySelector('[aria-label="Refresh overview"]')).toBeNull();
     expect(invoke).toHaveBeenCalledWith("memoryHubExplore", {
         corpusId: "a",
         maxNodes: 6,
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.ts
index f47b8a4639..10fd6fcb41 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubExplore.ts
@@ -7,7 +7,7 @@ import type {
     MemoryHubKnowledgeItem,
     MemoryHubKnowledgeKind,
 } from "@typeagent/browser-control-rpc/viewRpc";
-import { iconButton, watchSlowRequest } from "./memoryHubUi";
+import { watchSlowRequest } from "./memoryHubUi";
 import { invokeView } from "./viewClient";
 import {
     mountKnowledgeCollection,
@@ -39,7 +39,6 @@ export function mountMemoryHubExplore(
 ) {
     const root = text("section", undefined, "memory-phase2 memory-explore");
     root.setAttribute("aria-label", "Corpus overview");
-    const controls = text("div", undefined, "phase2-controls");
     const status = text(
         "p",
         "Open Overview to load corpus-neutral knowledge.",
@@ -54,7 +53,7 @@ export function mountMemoryHubExplore(
     const flyout = mountFlyout(host, "Knowledge detail");
     const graphDetails = mountGraphDetails(host, options);
     const lists = text("div", undefined, "phase2-lists");
-    root.append(controls, status, warning, counts, note, lists);
+    root.append(status, warning, counts, note, lists);
     host.append(root);
     const topics = mountTopicBrowser(root, {
         corpusId: options.scope,
@@ -66,7 +65,6 @@ export function mountMemoryHubExplore(
     let cached: MemoryHubExploreResult | undefined;
     let version = 0;
     let disposed = false;
-    let loading = false;
     let collections: ReturnType<typeof mountKnowledgeCollection>[] = [];
 
     function sourceItems(
@@ -191,13 +189,6 @@ export function mountMemoryHubExplore(
         collections.forEach((value) => value.dispose());
         collections = [];
     }
-    function renderControls() {
-        const refresh = iconButton("fa-rotate", "Refresh overview", () => {
-            void load();
-        });
-        refresh.disabled = loading;
-        controls.replaceChildren(refresh);
-    }
     function render(data: MemoryHubExploreResult) {
         counts.replaceChildren(
             ...Object.entries(data.counts).map(([name, count]) =>
@@ -291,20 +282,15 @@ export function mountMemoryHubExplore(
                         : "No derived knowledge in this scope.",
                 ),
             );
-        renderControls();
     }
     async function load() {
         topics.refresh();
         const requestVersion = ++version;
         const scope = options.scope();
-        loading = true;
         status.textContent = "Loading corpus overview…";
-        renderControls();
         const stopWatching = watchSlowRequest(status, () => {
             version++;
-            loading = false;
             status.textContent = "Overview loading cancelled.";
-            renderControls();
         });
         try {
             const data = await invokeView("memoryHubExplore", {
@@ -318,7 +304,6 @@ export function mountMemoryHubExplore(
             )
                 return;
             cached = data;
-            loading = false;
             render(data);
         } catch (error) {
             if (
@@ -327,15 +312,12 @@ export function mountMemoryHubExplore(
                 scope !== options.scope()
             )
                 return;
-            loading = false;
             status.textContent = `Explore unavailable: ${error instanceof Error ? error.message : String(error)}`;
             options.onError(error);
-            renderControls();
         } finally {
             stopWatching();
         }
     }
-    renderControls();
     return {
         async show() {
             if (disposed) return;
@@ -347,14 +329,12 @@ export function mountMemoryHubExplore(
             version++;
             cached = undefined;
             clearCollections();
-            loading = false;
             counts.replaceChildren();
             lists.replaceChildren();
             note.replaceChildren();
             warning.hidden = true;
             status.textContent =
                 "Scope changed. Open Overview to load this corpus.";
-            renderControls();
         },
         hide() {
             flyout.close();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css
index 4712c41b9f..6f40bc59e7 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css
@@ -6,13 +6,28 @@
 .hub-scoped-graph[hidden] {
   display: none;
 }
-.hub-graph-controls,
-.hub-graph-toolbar {
+.hub-graph-controls {
   display: flex;
   flex-wrap: wrap;
   gap: 0.75rem;
   align-items: end;
 }
+.hub-graph-viewport {
+  position: relative;
+  isolation: isolate;
+}
+.hub-graph-toolbar {
+  position: absolute;
+  top: 0.5rem;
+  left: 0.5rem;
+  z-index: 1;
+  display: flex;
+  gap: 0.25rem;
+  padding: 0.25rem;
+  background: var(--surface);
+  border: 1px solid var(--border, #d5d9e0);
+  border-radius: 0.375rem;
+}
 .hub-graph-controls label {
   display: flex;
   flex-direction: column;
@@ -25,17 +40,16 @@
   height: min(65vh, 650px);
   min-height: 360px;
   position: relative;
+  z-index: 0;
   border: 1px solid var(--border, #d5d9e0);
   border-radius: 0.5rem;
 }
 .hub-scoped-graph [role="status"] {
   white-space: pre-wrap;
 }
-.hub-graph-items,
 .hub-graph-support {
   padding-left: 1.25rem;
 }
-.hub-graph-items li,
 .hub-graph-support li {
   margin-bottom: 0.5rem;
 }
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts
index 4876c57b85..f8ddccdd56 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts
@@ -11,9 +11,9 @@ jest.mock("./entityGraphVisualizer", () => ({
     EntityGraphVisualizer: jest.fn().mockImplementation(() => ({
         initialize: jest.fn().mockResolvedValue(undefined),
         loadGlobalGraph: jest.fn().mockResolvedValue(undefined),
-        onEntityClick: jest.fn(),
-        onEdgeClick: jest.fn(),
-        fitToView: jest.fn(),
+        onEntityClick: mockEntityClick,
+        onEdgeClick: mockEdgeClick,
+        fitToView: mockFitToView,
         resize: jest.fn(),
         destroy: jest.fn(),
     })),
@@ -21,15 +21,19 @@ jest.mock("./entityGraphVisualizer", () => ({
 jest.mock("./topicGraphVisualizer", () => ({
     TopicGraphVisualizer: jest.fn().mockImplementation(() => ({
         init: jest.fn().mockResolvedValue(undefined),
-        onTopicClick: jest.fn(),
-        onEdgeClick: jest.fn(),
-        fitToView: jest.fn(),
+        onTopicClick: mockTopicClick,
+        onEdgeClick: mockEdgeClick,
+        fitToView: mockFitToView,
         resize: jest.fn(),
         dispose: jest.fn(),
     })),
 }));
 
 const invoke = invokeView as jest.Mock;
+const mockEntityClick = jest.fn();
+const mockTopicClick = jest.fn();
+const mockEdgeClick = jest.fn();
+const mockFitToView = jest.fn();
 const nodeId = `graph:a:entity:${"1".repeat(32)}`;
 const sample: MemoryHubGraphResult = {
     corpora: [
@@ -37,9 +41,7 @@ const sample: MemoryHubGraphResult = {
             corpusId: "a",
             corpusName: "Alpha",
             graph: {
-                corpusId: "a",
                 generation: "g1",
-                state: "ready",
                 nodes: [
                     {
                         id: nodeId,
@@ -51,28 +53,6 @@ const sample: MemoryHubGraphResult = {
                     },
                 ],
                 edges: [],
-                counts: {
-                    nodes: 1,
-                    edges: 0,
-                    omittedNodes: 0,
-                    omittedEdges: 0,
-                },
-                limits: { maxNodes: 250, maxEdges: 500 },
-                coverage: {
-                    documents: {
-                        state: "ready",
-                        total: 1,
-                        eligible: 1,
-                        indexed: 1,
-                    },
-                    events: {
-                        state: "ready",
-                        total: 0,
-                        eligible: 0,
-                        indexed: 0,
-                    },
-                    reasons: [],
-                },
             },
         },
     ],
@@ -92,7 +72,9 @@ async function settle() {
 }
 function button(label: string) {
     const value = [...host.querySelectorAll<HTMLButtonElement>("button")].find(
-        (element) => element.textContent === label,
+        (element) =>
+            element.getAttribute("aria-label") === label ||
+            element.textContent === label,
     );
     if (!value) throw new Error(`Missing button: ${label}`);
     return value;
@@ -102,6 +84,10 @@ function select(label: string) {
         `select[aria-label="${label}"]`,
     )!;
 }
+function clickNode(view: "entities" | "topics" = "entities") {
+    const listener = view === "entities" ? mockEntityClick : mockTopicClick;
+    listener.mock.calls[0][0]({ id: nodeId });
+}
 
 beforeEach(() => {
     host = document.createElement("div");
@@ -111,6 +97,10 @@ beforeEach(() => {
     onOpenSource = jest.fn();
     onRouteChanged = jest.fn();
     invoke.mockReset();
+    mockEntityClick.mockClear();
+    mockTopicClick.mockClear();
+    mockEdgeClick.mockClear();
+    mockFitToView.mockClear();
     invoke.mockImplementation((method) => {
         if (method === "memoryHubGraph") return Promise.resolve(sample);
         if (method === "memoryHubGraphSupport")
@@ -143,10 +133,58 @@ test("uses bounded corpus-neutral graph calls and never fetches browser analytic
     );
     expect(invoke.mock.calls).toHaveLength(1);
     expect(invoke.mock.calls[0][1]).not.toHaveProperty("corpusId");
-    expect(host.textContent).toContain("1 of 1 matching nodes");
+    expect(host.querySelector(".hub-scoped-graph-canvas")).not.toBeNull();
     expect(onError).not.toHaveBeenCalled();
 });
 
+test.each(["entities", "topics"] as const)(
+    "%s keeps accessible icon controls inside the graph viewport across refreshes",
+    async (view) => {
+        await mounted.show({ view });
+        const toolbar = host.querySelector('[aria-label="Graph controls"]')!;
+        expect(toolbar.getAttribute("role")).toBe("group");
+        expect(toolbar.parentElement?.className).toBe("hub-graph-viewport");
+        expect(
+            toolbar.parentElement?.querySelector(".hub-scoped-graph-canvas"),
+        ).not.toBeNull();
+        for (const [label, glyph] of [
+            ["Refresh graph", "fa-rotate"],
+            ["Global graph", "fa-globe"],
+            ["Fit graph", "fa-expand"],
+        ]) {
+            const control = button(label);
+            expect(control.title).toBe(label);
+            expect(control.type).toBe("button");
+            expect(control.classList.contains("icon-btn")).toBe(true);
+            expect(control.textContent).toBe("");
+            expect(
+                control
+                    .querySelector(`.fa-solid.${glyph}`)
+                    ?.getAttribute("aria-hidden"),
+            ).toBe("true");
+            expect(toolbar.contains(control)).toBe(true);
+        }
+        button("Fit graph").click();
+        expect(mockFitToView).toHaveBeenCalledTimes(1);
+        expect(invoke.mock.calls).toHaveLength(1);
+        button("Global graph").click();
+        await settle();
+        expect(onRouteChanged).toHaveBeenLastCalledWith(
+            view === "entities" ? "entities" : "hierarchy",
+        );
+        expect(invoke.mock.calls).toHaveLength(2);
+        expect(invoke.mock.calls[1][1]).not.toHaveProperty("nodeId");
+        button("Refresh graph").click();
+        await settle();
+        expect(invoke.mock.calls).toHaveLength(3);
+        expect(host.querySelector('[aria-label="Graph controls"]')).toBe(
+            toolbar,
+        );
+        expect(toolbar.querySelectorAll("button")).toHaveLength(3);
+        expect(onError).not.toHaveBeenCalled();
+    },
+);
+
 test("opaque graph routes retain node identity instead of becoming label searches", async () => {
     scope = "a";
     await mounted.show({ view: "entities", selection: nodeId });
@@ -158,62 +196,41 @@ test("opaque graph routes retain node identity instead of becoming label searche
     expect(onRouteChanged).toHaveBeenCalledWith("entities", nodeId);
 });
 
-test("inventory pages preserve the original query and effective limits, with honest last-page omissions", async () => {
-    invoke.mockImplementation((method, request) => {
-        if (method !== "memoryHubGraph")
-            throw new Error(`Unexpected graph call: ${method}`);
-        const last = request.continuationToken !== undefined;
-        return Promise.resolve({
-            ...sample,
-            corpora: [
-                {
-                    ...sample.corpora[0],
-                    graph: {
-                        ...sample.corpora[0].graph,
-                        counts: {
-                            nodes: 2,
-                            edges: 0,
-                            omittedNodes: 1,
-                            omittedEdges: 0,
-                        },
-                        limits: { maxNodes: 1, maxEdges: 1 },
-                        ...(last ? {} : { nextContinuationToken: "next-page" }),
-                    },
-                },
-            ],
-        });
-    });
-    await mounted.show({ view: "entities" });
-    expect(host.textContent).toContain("1 of 2 matching nodes");
-    host.querySelector<HTMLInputElement>(
-        'input[aria-label="Find graph nodes"]',
-    )!.value = "An unapplied search";
-    select("Graph evidence kinds").value = "event";
-    button("Next nodes in Alpha").click();
-    await settle();
-    const request = invoke.mock.calls[invoke.mock.calls.length - 1][1];
-    expect(request).toEqual(
-        expect.objectContaining({
-            corpusId: "a",
-            kind: "entities",
-            maxNodes: 1,
-            maxEdges: 1,
-            evidenceKinds: ["document", "event"],
-            eventFilter: {},
-            expectedGeneration: "g1",
-            continuationToken: "next-page",
-        }),
-    );
-    expect(request).not.toHaveProperty("search");
-    expect(button("Next nodes in Alpha").disabled).toBe(true);
-    expect(button("First nodes in Alpha").disabled).toBe(false);
-    expect(host.textContent).toContain("1 not on this page");
-    button("First nodes in Alpha").click();
-    await settle();
-    expect(
-        invoke.mock.calls[invoke.mock.calls.length - 1][1],
-    ).not.toHaveProperty("continuationToken");
-});
+test.each(["entities", "topics"] as const)(
+    "%s shows the graph without coverage, collection inventory or browse disclosures",
+    async (view) => {
+        await mounted.show({ view });
+        const root = host.querySelector(".hub-scoped-graph")!;
+        expect(root.textContent).not.toContain("Graph coverage");
+        expect(root.textContent).not.toContain(
+            "Browse graph nodes and relationships",
+        );
+        expect(root.textContent).not.toContain("Alpha");
+        expect(root.textContent).not.toContain("matching nodes");
+        expect(root.textContent).not.toContain("responding corpora");
+        expect(
+            root.querySelector('[aria-label="Graph inventory pages"]'),
+        ).toBeNull();
+        expect(root.querySelector(".hub-graph-items")).toBeNull();
+        expect(
+            [...root.querySelectorAll<HTMLElement>('[role="status"]')].every(
+                (element) => element.hidden,
+            ),
+        ).toBe(true);
+        expect(invoke.mock.calls).toHaveLength(1);
+        clickNode(view);
+        await settle();
+        expect(host.textContent).toContain("Alpha · Casey");
+        expect(invoke).toHaveBeenLastCalledWith(
+            "memoryHubGraphSupport",
+            expect.objectContaining({
+                corpusId: "a",
+                generation: "g1",
+                nodeId,
+            }),
+        );
+    },
+);
 
 test("opens a loading shell before the graph resolves and rejects stale scope results", async () => {
     let finish!: (value: typeof sample) => void;
@@ -234,7 +251,7 @@ test("opens a loading shell before the graph resolves and rejects stale scope re
 test("preserves selected corpus and qualified node identity in support reads", async () => {
     scope = "a";
     await mounted.show({ view: "entities" });
-    button("Alpha · Casey · 2 mentions").click();
+    clickNode();
     await settle();
     expect(invoke).toHaveBeenLastCalledWith(
         "memoryHubGraphSupport",
@@ -248,6 +265,45 @@ test("preserves selected corpus and qualified node identity in support reads", a
     expect(onRouteChanged).toHaveBeenCalledWith("entities", nodeId);
 });
 
+test("graph edge selection still loads exact generation-bound evidence", async () => {
+    const edgeId = "graph:a:edge:one";
+    invoke.mockResolvedValueOnce({
+        ...sample,
+        corpora: [
+            {
+                ...sample.corpora[0],
+                graph: {
+                    ...sample.corpora[0].graph,
+                    edges: [
+                        {
+                            id: edgeId,
+                            source: nodeId,
+                            target: nodeId,
+                            type: "related",
+                            count: 1,
+                            supportCount: 1,
+                        },
+                    ],
+                },
+            },
+        ],
+    });
+    await mounted.show({ view: "entities" });
+    expect(invoke.mock.calls).toHaveLength(1);
+    mockEdgeClick.mock.calls[0][0](edgeId);
+    await settle();
+    expect(invoke).toHaveBeenLastCalledWith(
+        "memoryHubGraphSupport",
+        expect.objectContaining({
+            corpusId: "a",
+            generation: "g1",
+            edgeId,
+            pageSize: 50,
+        }),
+    );
+    expect(onError).not.toHaveBeenCalled();
+});
+
 test("topic hierarchy and co-occurrence remain explicitly distinct", async () => {
     await mounted.show({ view: "topics" });
     expect(invoke).toHaveBeenLastCalledWith(
@@ -261,7 +317,9 @@ test("topic hierarchy and co-occurrence remain explicitly distinct", async () =>
         "memoryHubGraph",
         expect.objectContaining({ kind: "topics" }),
     );
-    expect(host.textContent).toContain("not a topic hierarchy");
+    expect(select("Topic graph meaning").selectedOptions[0].textContent).toBe(
+        "Source co-occurrence",
+    );
     expect(onRouteChanged).toHaveBeenCalledWith("topics");
 });
 
@@ -290,7 +348,7 @@ test("event filters preserve conversation, producer and authority semantics", as
     );
 });
 
-test("reports partial and building coverage rather than claiming complete empty memory", async () => {
+test("keeps actual collection failures and omitted collections visible without coverage status", async () => {
     invoke.mockResolvedValue({
         ...sample,
         corpora: [
@@ -298,11 +356,6 @@ test("reports partial and building coverage rather than claiming complete empty
                 ...sample.corpora[0],
                 graph: {
                     ...sample.corpora[0].graph,
-                    state: "building",
-                    coverage: {
-                        ...sample.corpora[0].graph.coverage,
-                        reasons: ["Event projection is not ready."],
-                    },
                     nodes: [],
                 },
             },
@@ -311,50 +364,54 @@ test("reports partial and building coverage rather than claiming complete empty
         omittedCorpora: 2,
     });
     await mounted.show({ view: "entities" });
-    expect(host.textContent).toContain("Alpha: building");
-    expect(host.textContent).toContain("Event projection is not ready.");
+    expect(host.textContent).toContain("No nodes in the available projection.");
     expect(host.textContent).toContain("b: Unavailable");
     expect(host.textContent).toContain("2 corpora omitted");
 });
 
-test("coverage distinguishes eligible and indexed documents and events from inventory totals", async () => {
-    invoke.mockResolvedValue({
-        ...sample,
-        corpora: [
-            {
-                ...sample.corpora[0],
-                graph: {
-                    ...sample.corpora[0].graph,
-                    state: "building",
-                    coverage: {
-                        documents: {
-                            state: "building",
-                            total: 10,
-                            eligible: 4,
-                            indexed: 2,
-                        },
-                        events: {
-                            state: "stale",
-                            total: 12,
-                            eligible: 8,
-                            indexed: 7,
+test.each(["entities", "topics"] as const)(
+    "%s ignores routine coverage/build messages from older responses",
+    async (view) => {
+        invoke.mockResolvedValue({
+            ...sample,
+            corpora: [
+                {
+                    ...sample.corpora[0],
+                    graph: {
+                        ...sample.corpora[0].graph,
+                        state: "building",
+                        coverage: {
+                            documents: {
+                                state: "building",
+                                total: 10,
+                                eligible: 4,
+                                indexed: 2,
+                            },
+                            events: {
+                                state: "stale",
+                                total: 12,
+                                eligible: 8,
+                                indexed: 7,
+                            },
+                            topics: {
+                                state: "building",
+                                generation: "topics-v1",
+                            },
+                            reasons: [
+                                "Rebuild topics to populate the hierarchy.",
+                            ],
                         },
-                        topics: { state: "building", generation: "topics-v1" },
-                        reasons: [],
                     },
                 },
-            },
-        ],
-    });
-    await mounted.show({ view: "entities" });
-    expect(host.textContent).toContain(
-        "documents building: 2 of 4 eligible indexed (10 total)",
-    );
-    expect(host.textContent).toContain(
-        "events stale: 7 of 8 eligible indexed (12 total)",
-    );
-    expect(host.textContent).toContain("topics building");
-});
+            ],
+        });
+        await mounted.show({ view });
+        expect(host.textContent).not.toContain("building");
+        expect(host.textContent).not.toContain("eligible indexed");
+        expect(host.textContent).not.toContain("Rebuild topics");
+        expect(onError).not.toHaveBeenCalled();
+    },
+);
 
 test("loads exact event evidence without document reads or timeline capability calls", async () => {
     invoke.mockImplementation((method) => {
@@ -385,7 +442,7 @@ test("loads exact event evidence without document reads or timeline capability c
         throw new Error(`Unexpected event evidence call: ${method}`);
     });
     await mounted.show({ view: "entities" });
-    button("Alpha · Casey · 2 mentions").click();
+    clickNode();
     await settle();
     expect(host.textContent).toContain("evidence-only");
     button("Original turn").click();
@@ -418,7 +475,7 @@ test("support from a different generation is rejected before rendering", async (
         throw new Error(`Unexpected graph call: ${method}`);
     });
     await mounted.show({ view: "entities" });
-    button("Alpha · Casey · 2 mentions").click();
+    clickNode();
     await settle();
     expect(host.textContent).toContain("Graph generation changed");
     expect(host.textContent).not.toContain("Unexpected support");
@@ -433,7 +490,11 @@ test("failed graph reads have an explicit error and retry control", async () =>
     expect(onError).toHaveBeenCalledTimes(1);
     button("Refresh graph").click();
     await settle();
-    expect(host.textContent).toContain("Alpha · Casey");
+    expect(
+        host.querySelector(".hub-scoped-graph")?.getAttribute("aria-busy"),
+    ).toBe("false");
+    expect(host.textContent).not.toContain("Projection unavailable");
+    expect(host.textContent).not.toContain("Graph could not be loaded");
 });
 
 test("support paging stays generation-bound and failed pages can be retried", async () => {
@@ -458,7 +519,7 @@ test("support paging stays generation-bound and failed pages can be retried", as
         throw new Error(`Unexpected support call: ${method}`);
     });
     await mounted.show({ view: "entities" });
-    button("Alpha · Casey · 2 mentions").click();
+    clickNode();
     await settle();
     button("Next support page").click();
     await settle();
@@ -506,7 +567,7 @@ test("document evidence retains exact revision and locator rather than reading c
         throw new Error(`Unexpected document call: ${method}`);
     });
     await mounted.show({ view: "entities" });
-    button("Alpha · Casey · 2 mentions").click();
+    clickNode();
     await settle();
     button("Document evidence").click();
     await settle();
@@ -548,13 +609,7 @@ test.each([
                                         summaryState: "pending",
                                     },
                                 ],
-                                coverage: {
-                                    ...sample.corpora[0].graph.coverage,
-                                    topics: {
-                                        state: "ready",
-                                        generation: "topic-g1",
-                                    },
-                                },
+                                topicGeneration: "topic-g1",
                             },
                         },
                     ],
@@ -598,7 +653,7 @@ test.each([
             "memoryQueryTopics",
             expect.anything(),
         );
-        button("Alpha · Casey · 2 mentions · summary pending").click();
+        clickNode("topics");
         await settle();
         expect(invoke).toHaveBeenCalledWith("memoryQueryTopics", {
             corpusId: "a",
@@ -628,7 +683,7 @@ test("closing the graph invalidates outstanding evidence reads", async () => {
             : new Promise((resolve) => (finish = resolve)),
     );
     await mounted.show({ view: "entities" });
-    button("Alpha · Casey · 2 mentions").click();
+    clickNode();
     mounted.hide();
     finish({ items: [{ title: "Stale secret" }], total: 1 });
     await settle();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts
index ffb47aec5a..0c767f8b78 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts
@@ -11,17 +11,13 @@ import type {
 } from "@typeagent/browser-control-rpc/viewRpc";
 import { EntityGraphVisualizer } from "./entityGraphVisualizer";
 import { TopicGraphVisualizer } from "./topicGraphVisualizer";
-import {
-    graphText,
-    graphButton,
-    mountGraphDetails,
-} from "./memoryHubGraphDetails";
+import { graphText, mountGraphDetails } from "./memoryHubGraphDetails";
 import { mountGraphControls } from "./memoryHubGraphControls";
+import { iconButton } from "./memoryHubUi";
 import { invokeView } from "./viewClient";
 import "./memoryHubGraph.css";
 
 type GraphKind = MemoryGraphQueryRequest["kind"];
-type CorpusGraph = MemoryHubGraphResult["corpora"][number];
 export interface MemoryHubGraphOptions {
     scope: () => string | undefined;
     onOpenSource: (corpusId: string, sourceId: string) => void;
@@ -62,28 +58,14 @@ export function mountMemoryHubGraph(
     status.setAttribute("role", "status");
     const warning = graphText("div");
     warning.setAttribute("role", "status");
-    const coverageDetails = graphText("details");
-    coverageDetails.append(graphText("summary", "Graph coverage"));
-    const coverageInfo = graphText("div");
-    coverageDetails.append(coverageInfo);
     const toolbar = graphText("div", undefined, "hub-graph-toolbar");
-    const paging = graphText("div");
-    paging.setAttribute("aria-label", "Graph inventory pages");
+    toolbar.setAttribute("role", "group");
+    toolbar.setAttribute("aria-label", "Graph controls");
+    const viewport = graphText("div", undefined, "hub-graph-viewport");
     const canvas = graphText("div", undefined, "hub-scoped-graph-canvas");
     canvas.setAttribute("aria-label", "Memory graph visualization");
-    const browse = graphText("details");
-    browse.append(graphText("summary", "Browse graph nodes and relationships"));
-    const items = graphText("ul", undefined, "hub-graph-items");
-    browse.append(items);
-    root.append(
-        status,
-        warning,
-        coverageDetails,
-        toolbar,
-        paging,
-        canvas,
-        browse,
-    );
+    viewport.append(toolbar, canvas);
+    root.append(status, warning, viewport);
     host.append(root);
     const details = mountGraphDetails(host, options);
     let version = 0;
@@ -100,9 +82,6 @@ export function mountMemoryHubGraph(
         else renderer?.dispose();
         renderer = undefined;
         canvas.replaceChildren();
-        items.replaceChildren();
-        paging.replaceChildren();
-        coverageInfo.replaceChildren();
         details.close();
         result = undefined;
     }
@@ -138,10 +117,9 @@ export function mountMemoryHubGraph(
             node?.topicId
                 ? {
                       topicId: node.topicId,
-                      ...(corpus.graph.coverage.topics?.generation
+                      ...(corpus.graph.topicGeneration
                           ? {
-                                generation:
-                                    corpus.graph.coverage.topics.generation,
+                                generation: corpus.graph.topicGeneration,
                             }
                           : {}),
                   }
@@ -149,27 +127,6 @@ export function mountMemoryHubGraph(
         );
         if (node) options.onRouteChanged(kind, id);
     }
-    function browseCorpus(corpus: CorpusGraph) {
-        const entries = [
-            ...corpus.graph.nodes.map((node) => ({
-                id: node.id,
-                label: `${node.label} · ${node.mentionCount} mentions${node.summaryState ? ` · summary ${node.summaryState}` : ""}`,
-            })),
-            ...corpus.graph.edges.map((edge) => ({
-                id: edge.id,
-                label: `${edge.label ?? edge.type} · ${edge.count} mentions`,
-            })),
-        ];
-        for (const entry of entries) {
-            const row = graphText("li");
-            row.append(
-                graphButton(`${corpus.corpusName} · ${entry.label}`, () =>
-                    openSelection(entry.id),
-                ),
-            );
-            items.append(row);
-        }
-    }
     async function renderGraph(data: MemoryHubGraphResult, ticket: number) {
         if (kind === "entities") {
             const entity = new EntityGraphVisualizer(canvas);
@@ -190,28 +147,10 @@ export function mountMemoryHubGraph(
         }
         if (ticket === version) renderer?.resize();
     }
-    function coverage(data: MemoryHubGraphResult) {
+    function showErrors(data: MemoryHubGraphResult) {
         const messages = data.errors.map(
             (error) => `${error.corpusId}: ${error.message}`,
         );
-        for (const corpus of data.corpora) {
-            const parts = (["documents", "events"] as const).map((kind) => {
-                const coverage = corpus.graph.coverage[kind];
-                return `${kind} ${coverage.state}: ${coverage.indexed} of ${coverage.eligible} eligible indexed (${coverage.total} total)`;
-            });
-            if (corpus.graph.coverage.topics)
-                parts.push(`topics ${corpus.graph.coverage.topics.state}`);
-            coverageInfo.append(
-                graphText("p", `${corpus.corpusName}: ${parts.join("; ")}`),
-            );
-            messages.push(
-                ...corpus.graph.coverage.reasons.map(
-                    (reason) => `${corpus.corpusName}: ${reason}`,
-                ),
-            );
-            if (corpus.graph.state !== "ready")
-                messages.push(`${corpus.corpusName}: ${corpus.graph.state}`);
-        }
         if (data.omittedCorpora)
             messages.push(
                 `${data.omittedCorpora} corpora omitted by node budget.`,
@@ -219,116 +158,50 @@ export function mountMemoryHubGraph(
         warning.textContent = messages.join("\n");
         warning.hidden = !messages.length;
     }
-    function inventoryPages(
-        data: MemoryHubGraphResult,
-        request: MemoryHubGraphRequest,
-    ) {
-        for (const corpus of data.corpora) {
-            const graph = corpus.graph;
-            if (
-                !graph.counts.omittedNodes &&
-                !graph.nextContinuationToken &&
-                !request.continuationToken
-            )
-                continue;
-            const firstRequest: MemoryHubGraphRequest = {
-                ...request,
-                corpusId: corpus.corpusId,
-                expectedGeneration: graph.generation,
-                maxNodes: graph.limits.maxNodes,
-                maxEdges: graph.limits.maxEdges,
-            };
-            delete firstRequest.continuationToken;
-            const row = graphText("div", undefined, "hub-graph-toolbar");
-            row.append(
-                graphText(
-                    "span",
-                    `${corpus.corpusName}: ${graph.nodes.length} of ${graph.counts.nodes} matching nodes on this page; ${graph.counts.omittedNodes} not on this page.`,
-                ),
-            );
-            const first = graphButton(
-                `First nodes in ${corpus.corpusName}`,
-                () => void load({}, firstRequest),
-            );
-            first.disabled = !request.continuationToken;
-            const token = graph.nextContinuationToken;
-            const next = graphButton(
-                `Next nodes in ${corpus.corpusName}`,
-                () => {
-                    if (token)
-                        void load(
-                            {},
-                            { ...firstRequest, continuationToken: token },
-                        );
-                },
-            );
-            next.disabled = !token;
-            row.append(first, next);
-            paging.append(row);
-        }
-    }
     async function load(
         focus: Partial<
             Pick<MemoryHubGraphRequest, "corpusId" | "nodeId" | "search">
         > = {},
-        snapshot?: MemoryHubGraphRequest,
     ) {
         const ticket = ++version;
         release();
         root.hidden = false;
         root.setAttribute("aria-busy", "true");
         warning.replaceChildren();
+        warning.hidden = true;
         controls.showMode(kind !== "entities");
+        status.hidden = false;
         status.textContent = "Loading scoped memory graph...";
         try {
-            let request = snapshot;
-            if (!request) {
-                const filters = controls.request();
-                const corpusId = options.scope();
-                request = {
-                    ...filters,
-                    evidenceKinds: [...filters.evidenceKinds],
-                    ...(corpusId === undefined ? {} : { corpusId }),
-                    kind,
-                    maxNodes: 250,
-                    maxEdges: 500,
-                    ...focus,
-                };
-            }
+            const filters = controls.request();
+            const corpusId = options.scope();
+            const request: MemoryHubGraphRequest = {
+                ...filters,
+                evidenceKinds: [...filters.evidenceKinds],
+                ...(corpusId === undefined ? {} : { corpusId }),
+                kind,
+                maxNodes: 250,
+                maxEdges: 500,
+                ...focus,
+            };
             const data = await invokeView("memoryHubGraph", request);
             if (ticket !== version || disposed) return;
             result = data;
-            coverage(data);
+            showErrors(data);
             const nodes = data.corpora.flatMap((corpus) => corpus.graph.nodes);
-            const edges = data.corpora.flatMap((corpus) => corpus.graph.edges);
-            const totalNodes = data.corpora.reduce(
-                (total, corpus) => total + corpus.graph.counts.nodes,
-                0,
-            );
-            const totalEdges = data.corpora.reduce(
-                (total, corpus) => total + corpus.graph.counts.edges,
-                0,
-            );
-            const meaning =
-                kind === "entities"
-                    ? "Extracted entity relationships"
-                    : kind === "hierarchy"
-                      ? "Maintained topic hierarchy and related topics"
-                      : "Source co-occurrence, not a topic hierarchy";
-            status.textContent = `${meaning} · ${nodes.length} of ${totalNodes} matching nodes · ${edges.length} of ${totalEdges} matching edges · ${data.corpora.length} responding corpora`;
             if (nodes.length) await renderGraph(data, ticket);
-            else
-                status.textContent +=
-                    " · No nodes in the available projection.";
             if (ticket !== version || disposed) return;
-            data.corpora.forEach(browseCorpus);
-            inventoryPages(data, request);
+            status.textContent = nodes.length
+                ? ""
+                : "No nodes in the available projection.";
+            status.hidden = nodes.length > 0;
             if (request.nodeId) openSelection(request.nodeId);
         } catch (error) {
             if (ticket === version && !disposed) {
                 release();
                 status.textContent =
                     "Graph could not be loaded. Retry with Refresh graph.";
+                status.hidden = false;
                 warning.textContent =
                     error instanceof Error ? error.message : String(error);
                 warning.hidden = false;
@@ -339,12 +212,12 @@ export function mountMemoryHubGraph(
         }
     }
     toolbar.append(
-        graphButton("Refresh graph", () => void load()),
-        graphButton("Global graph", () => {
+        iconButton("fa-rotate", "Refresh graph", () => void load()),
+        iconButton("fa-globe", "Global graph", () => {
             options.onRouteChanged(kind);
             void load();
         }),
-        graphButton("Fit graph", () => {
+        iconButton("fa-expand", "Fit graph", () => {
             if (renderer instanceof EntityGraphVisualizer) renderer.fitToView();
             else renderer?.fitToView();
         }),
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
new file mode 100644
index 0000000000..cb2a7010a3
--- /dev/null
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
@@ -0,0 +1,192 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { mountMemoryHubInbox } from "./memoryHubInbox";
+
+function setup() {
+    const host = document.createElement("section");
+    const questions = document.createElement("div");
+    const views = document.createElement("div");
+    const operations = document.createElement("div");
+    document.body.replaceChildren(host);
+    const inbox = mountMemoryHubInbox(host, [
+        { id: "questions", label: "Question decisions", host: questions },
+        { id: "views", label: "Views", host: views },
+        { id: "operations", label: "Sources & operations", host: operations },
+    ]);
+    function add(target: HTMLElement, title: string, summary = "Needs review") {
+        const detail = document.createElement("article");
+        detail.textContent = `${title}: Full explanation, corpus-opaque-id and provenance. ${"Long evidence. ".repeat(150)}`;
+        const action = document.createElement("button");
+        action.textContent = "Inspect operation";
+        const inspect = jest.fn();
+        action.onclick = inspect;
+        detail.append(action);
+        target.append(inbox.present({ title, summary, detail }));
+        return { detail, inspect };
+    }
+    return { host, inbox, questions, views, operations, add };
+}
+function button(host: HTMLElement, label: string) {
+    const result = [...host.querySelectorAll<HTMLButtonElement>("button")].find(
+        (element) =>
+            element.getAttribute("aria-label") === label ||
+            element.textContent === label,
+    );
+    if (!result) throw new Error(`Missing button: ${label}`);
+    return result;
+}
+
+test("keeps all attention types discoverable with a bounded overview even with 105 view cards", () => {
+    const { host, inbox, questions, views, operations, add } = setup();
+    add(questions, "Resolve conflicting candidates");
+    add(questions, "Review stale answer");
+    for (let index = 0; index < 105; index++) add(views, `View ${index}`);
+    add(operations, "Failed import");
+    inbox.setCount("questions", 5, true);
+    inbox.setCount("views", 208, true);
+    inbox.setCount("operations", 1);
+    expect(host.querySelector(".hub-inbox-tabs")!.classList).toContain(
+        "hub-tabs",
+    );
+    for (const tab of host.querySelectorAll(".hub-inbox-tabs button")) {
+        expect(tab.querySelectorAll('i[aria-hidden="true"]')).toHaveLength(1);
+    }
+    const overview = host.querySelector("#inbox-panel-all")!;
+    const viewAllButtons = overview.querySelectorAll<HTMLButtonElement>(
+        ".hub-inbox-overview-head button",
+    );
+    expect(
+        [...viewAllButtons].map((control) =>
+            control.getAttribute("aria-label"),
+        ),
+    ).toEqual([
+        "View all question decisions",
+        "View all views",
+        "View all sources & operations",
+    ]);
+    for (const control of viewAllButtons) {
+        expect(control.textContent).toBe("");
+        expect(control.classList).toContain("icon-btn");
+        expect(control.title).toBe(control.getAttribute("aria-label"));
+        expect(control.querySelector("i")!.className).toBe("fa-solid fa-list");
+        expect(control.querySelector("i")!.getAttribute("aria-hidden")).toBe(
+            "true",
+        );
+    }
+    expect(overview.querySelectorAll(".hub-inbox-item")).toHaveLength(5);
+    expect(overview.querySelectorAll("h3")[0].textContent).toContain(
+        "Question decisions",
+    );
+    expect(button(host, "Question decisions (5+)").getAttribute("role")).toBe(
+        "tab",
+    );
+    expect(button(host, "Views (208+)").getAttribute("role")).toBe("tab");
+    expect(button(host, "All (214+)").getAttribute("aria-selected")).toBe(
+        "true",
+    );
+    expect(host.querySelector<HTMLElement>("#inbox-panel-views")!.hidden).toBe(
+        true,
+    );
+    button(host, "View all views").click();
+    expect(host.querySelector<HTMLElement>("#inbox-panel-views")!.hidden).toBe(
+        false,
+    );
+    expect(views.querySelectorAll(".hub-inbox-item")).toHaveLength(105);
+    expect(host.querySelector<HTMLElement>("#inbox-panel-all")!.hidden).toBe(
+        true,
+    );
+});
+
+test("opens full untruncated explanations and working actions only in the details panel", () => {
+    const { host, inbox, views, add } = setup();
+    const { detail, inspect } = add(views, "Blocked view", "A".repeat(1800));
+    inbox.setCount("views", 1);
+    const overview = host.querySelector("#inbox-panel-all")!;
+    expect(
+        overview.querySelector(".hub-inbox-item p")!.textContent,
+    ).toHaveLength(180);
+    expect(overview.textContent).not.toContain("corpus-opaque-id");
+    const review = button(overview as HTMLElement, "Review: Blocked view");
+    expect(review.textContent).toBe("");
+    expect(review.classList).toContain("icon-btn");
+    expect(review.title).toBe("Review: Blocked view");
+    expect(review.querySelector("i")!.className).toBe("fa-solid fa-file-lines");
+    expect(review.querySelector("i")!.getAttribute("aria-hidden")).toBe("true");
+    review.focus();
+    review.click();
+    const panel = host.querySelector<HTMLElement>(
+        'aside[aria-label="Inbox details"]',
+    )!;
+    expect(panel.hidden).toBe(false);
+    expect(panel.contains(detail)).toBe(true);
+    expect(panel.textContent).toContain("corpus-opaque-id");
+    expect(panel.textContent!.length).toBeGreaterThan(1800);
+    button(panel, "Inspect operation").click();
+    expect(inspect).toHaveBeenCalledTimes(1);
+    button(panel, "Close").click();
+    expect(panel.hidden).toBe(true);
+    expect(document.activeElement).toBe(review);
+    review.click();
+    expect(panel.contains(detail)).toBe(true);
+    panel.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "Escape", bubbles: true }),
+    );
+    expect(panel.hidden).toBe(true);
+});
+
+test("supports arrow, Home and End navigation with one tabbable category", () => {
+    const { host } = setup();
+    const tabs = host.querySelector<HTMLElement>('[role="tablist"]')!;
+    for (const [key, id] of [
+        ["ArrowRight", "questions"],
+        ["End", "operations"],
+        ["ArrowRight", "all"],
+        ["ArrowLeft", "operations"],
+        ["Home", "all"],
+    ]) {
+        tabs.dispatchEvent(
+            new KeyboardEvent("keydown", { key, bubbles: true }),
+        );
+        const tab = host.querySelector<HTMLButtonElement>(`#inbox-tab-${id}`)!;
+        expect(tab.getAttribute("aria-selected")).toBe("true");
+        expect(document.activeElement).toBe(tab);
+        expect(
+            [...tabs.querySelectorAll<HTMLButtonElement>("button")].filter(
+                (element) => element.tabIndex === 0,
+            ),
+        ).toHaveLength(1);
+        expect(
+            host.querySelector<HTMLElement>(`#inbox-panel-${id}`)!.hidden,
+        ).toBe(false);
+    }
+});
+
+test("distinguishes loading and errors from empty counts and resets details on scope changes", () => {
+    const { host, inbox, views, add } = setup();
+    expect(button(host, "Question decisions (...)")).toBeDefined();
+    inbox.fail("questions", new Error("Question inventory offline"));
+    expect(button(host, "Question decisions (unavailable)")).toBeDefined();
+    expect(host.querySelector("#inbox-panel-all")!.textContent).toContain(
+        "Question inventory offline",
+    );
+    inbox.setCount("questions", 0);
+    expect(button(host, "Question decisions (0)")).toBeDefined();
+    add(views, "Stale view");
+    inbox.setCount("views", 1);
+    button(
+        host.querySelector("#inbox-panel-all")!,
+        "Review: Stale view",
+    ).click();
+    inbox.reset();
+    expect(host.querySelector<HTMLElement>("aside")!.hidden).toBe(true);
+    expect(button(host, "All (...)").getAttribute("aria-selected")).toBe(
+        "true",
+    );
+    expect(button(host, "Views (...)")).toBeDefined();
+    expect(views.hidden).toBe(true);
+    expect(views.querySelector(".hub-inbox-item")).toBeNull();
+    expect(host.querySelector("#inbox-panel-all")!.textContent).not.toContain(
+        "Stale view",
+    );
+});
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
new file mode 100644
index 0000000000..3509108891
--- /dev/null
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
@@ -0,0 +1,256 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { mountFlyout } from "./memoryHubFlyout";
+import { rbButton, rbIconButton, rbNode } from "./memoryHubDocumentUi";
+import { setTabLabel } from "./memoryHubUi";
+
+export type InboxCategory = "questions" | "views" | "operations";
+export interface InboxAttentionCard {
+    title: string;
+    summary: string;
+    detail: HTMLElement;
+    entries?: number;
+}
+
+const tabIcons: Record<string, string> = {
+    all: "fa-inbox",
+    questions: "fa-circle-question",
+    views: "fa-layer-group",
+    operations: "fa-list-check",
+};
+
+export function mountMemoryHubInbox(
+    host: HTMLElement,
+    sections: Array<{
+        id: InboxCategory;
+        label: string;
+        host: HTMLElement;
+    }>,
+) {
+    const root = rbNode("section", undefined, "hub-inbox-workspace");
+    const tabs = rbNode("div", undefined, "hub-tabs hub-inbox-tabs");
+    tabs.setAttribute("role", "tablist");
+    tabs.setAttribute("aria-label", "Inbox attention types");
+    const overview = rbNode("section");
+    const panels = new Map<string, HTMLElement>([["all", overview]]);
+    const buttons = new Map<string, HTMLButtonElement>();
+    const statuses = new Map<InboxCategory, HTMLElement>();
+    const counts = new Map<InboxCategory, { count: number; more: boolean }>();
+    const errors = new Map<InboxCategory, string>();
+    const cards = new WeakMap<HTMLElement, InboxAttentionCard>();
+    const inspector = mountFlyout(host, "Inbox details");
+    let selected = "all";
+
+    root.append(tabs, overview);
+    for (const section of sections) {
+        const panel = rbNode("section");
+        const status = rbNode("p");
+        status.setAttribute("role", "status");
+        statuses.set(section.id, status);
+        panel.append(status, section.host);
+        panels.set(section.id, panel);
+        root.append(panel);
+    }
+    host.append(root);
+    for (const [id, label] of [
+        ["all", "All"],
+        ...sections.map((section) => [section.id, section.label]),
+    ]) {
+        const tab = setTabLabel(
+            rbButton(label, () => select(id)),
+            tabIcons[id],
+            label,
+        );
+        tab.id = `inbox-tab-${id}`;
+        tab.setAttribute("role", "tab");
+        tab.setAttribute("aria-controls", `inbox-panel-${id}`);
+        const panel = panels.get(id)!;
+        panel.id = `inbox-panel-${id}`;
+        panel.setAttribute("role", "tabpanel");
+        panel.setAttribute("aria-labelledby", tab.id);
+        panel.tabIndex = 0;
+        buttons.set(id, tab);
+        tab.title =
+            "Counts cover loaded attention items or groups. + means additional items may be available.";
+        tabs.append(tab);
+    }
+    tabs.addEventListener("keydown", (event) => {
+        const keys = [...buttons.keys()];
+        const index = keys.indexOf(selected);
+        const target =
+            event.key === "Home"
+                ? 0
+                : event.key === "End"
+                  ? keys.length - 1
+                  : event.key === "ArrowRight"
+                    ? (index + 1) % keys.length
+                    : event.key === "ArrowLeft"
+                      ? (index + keys.length - 1) % keys.length
+                      : undefined;
+        if (target === undefined) return;
+        event.preventDefault();
+        select(keys[target]);
+        buttons.get(keys[target])!.focus();
+    });
+
+    function select(id: string) {
+        inspector.close();
+        selected = id;
+        for (const [key, tab] of buttons) {
+            tab.setAttribute("aria-selected", String(key === id));
+            tab.tabIndex = key === id ? 0 : -1;
+            panels.get(key)!.hidden = key !== id;
+        }
+    }
+    function formatCount(id: InboxCategory) {
+        const value = counts.get(id);
+        if (errors.has(id))
+            return value?.count ? `${value.count}+; partial` : "unavailable";
+        return value ? `${value.count}${value.more ? "+" : ""}` : "...";
+    }
+    function row(card: InboxAttentionCard) {
+        const item = rbNode("article", undefined, "hub-inbox-item");
+        item.dataset.entries = String(card.entries ?? 1);
+        const content = rbNode("div", undefined, "hub-inbox-item-text");
+        content.append(
+            rbNode("h4", card.title),
+            rbNode(
+                "p",
+                card.summary.length > 180
+                    ? `${card.summary.slice(0, 177)}...`
+                    : card.summary,
+            ),
+        );
+        const review = rbIconButton(
+            "fa-file-lines",
+            `Review: ${card.title}`,
+            () =>
+                inspector.open({
+                    title: card.title,
+                    render(body) {
+                        body.append(card.detail);
+                        return () => card.detail.remove();
+                    },
+                }),
+        );
+        item.append(content, review);
+        cards.set(item, card);
+        return item;
+    }
+    function renderCategory(section: (typeof sections)[number]) {
+        const count = formatCount(section.id);
+        const status = statuses.get(section.id)!;
+        const value = counts.get(section.id);
+        const message = errors.get(section.id);
+        section.host.hidden = !value && !message;
+        status.setAttribute("role", message ? "alert" : "status");
+        status.textContent =
+            message ??
+            (value
+                ? value.more
+                    ? "Showing loaded attention groups. Use the paging controls or workspace link for more."
+                    : value.count === 0
+                      ? "No active attention items on this page."
+                      : ""
+                : "Loading attention items...");
+        status.hidden = !status.textContent;
+        setTabLabel(
+            buttons.get(section.id)!,
+            tabIcons[section.id],
+            `${section.label} (${count})`,
+        );
+        const group = rbNode("section", undefined, "hub-inbox-overview-group");
+        const heading = rbNode("div", undefined, "hub-inbox-overview-head");
+        heading.append(
+            rbNode("h3", `${section.label} (${count})`),
+            rbIconButton(
+                "fa-list",
+                `View all ${section.label.toLowerCase()}`,
+                () => {
+                    select(section.id);
+                    buttons.get(section.id)!.focus();
+                },
+            ),
+        );
+        group.append(heading);
+        if (message) {
+            const error = rbNode("p", message);
+            error.setAttribute("role", "alert");
+            group.append(error);
+        }
+        const items =
+            value || message
+                ? [
+                      ...section.host.querySelectorAll<HTMLElement>(
+                          ".hub-inbox-item",
+                      ),
+                  ]
+                : [];
+        for (const item of items.slice(0, 2)) {
+            const card = cards.get(item);
+            if (card) group.append(row(card));
+        }
+        if (!items.length && !message)
+            group.append(
+                rbNode(
+                    "p",
+                    counts.has(section.id)
+                        ? "No attention items on this page."
+                        : "Loading attention items...",
+                ),
+            );
+        return group;
+    }
+    function render() {
+        const restoreTabFocus = overview.contains(document.activeElement);
+        const total = [...counts.values()].reduce(
+            (sum, value) => sum + value.count,
+            0,
+        );
+        const incomplete =
+            counts.size !== sections.length ||
+            errors.size > 0 ||
+            [...counts.values()].some((value) => value.more);
+        setTabLabel(
+            buttons.get("all")!,
+            tabIcons.all,
+            counts.size
+                ? `All (${total}${incomplete ? "+" : ""})`
+                : "All (...)",
+        );
+        overview.replaceChildren(...sections.map(renderCategory));
+        if (restoreTabFocus) buttons.get(selected)!.focus();
+    }
+    select("all");
+    render();
+    return {
+        present: row,
+        setCount(id: InboxCategory, count: number, more = false) {
+            inspector.close();
+            counts.set(id, { count, more });
+            errors.delete(id);
+            render();
+        },
+        fail(id: InboxCategory, error: unknown) {
+            inspector.close();
+            errors.set(
+                id,
+                error instanceof Error ? error.message : String(error),
+            );
+            render();
+        },
+        reset() {
+            inspector.close();
+            counts.clear();
+            errors.clear();
+            for (const section of sections)
+                section.host
+                    .querySelectorAll(".hub-inbox-item")
+                    .forEach((item) => item.remove());
+            select("all");
+            render();
+        },
+        close: inspector.close,
+    };
+}
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.test.ts
index 1dbf4387c2..b70cb4dc88 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.test.ts
@@ -164,6 +164,16 @@ test("maintenance editor sends explicit guarded configuration, previews blockers
     });
     expect(saved).toHaveBeenCalledTimes(1);
     click(host, "Preview maintenance");
+    for (const control of host.querySelectorAll("button")) {
+        if (
+            ["Preview maintenance", "Run manual maintenance"].includes(
+                control.textContent ?? "",
+            )
+        )
+            expect(control.querySelector("i")!.className).toBe(
+                "fa-solid fa-screwdriver-wrench",
+            );
+    }
     await pending;
     expect(host.textContent).toContain("Pending ingestion");
     click(host, "Run manual maintenance");
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.ts
index dd1354b99f..8b7c6b2456 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubMaintenance.ts
@@ -5,6 +5,7 @@ import type { ViewBuildJob, ViewVersion } from "@typeagent/memory-service";
 import { viewMaintenanceDefinitionSchema } from "@typeagent/memory-client/view-protocol";
 import { invokeMemory } from "./viewClient";
 import { rbButton, rbNode } from "./memoryHubDocumentUi";
+import { setTabLabel } from "./memoryHubUi";
 
 export function createMaintenancePanel(
     view: ViewVersion,
@@ -193,49 +194,63 @@ export function createMaintenancePanel(
                 await options.saved();
             }),
         ),
-        rbButton("Preview maintenance", () =>
-            options.action(async () => {
-                if (!options.isCurrent()) return;
-                requireSaved();
-                const plan = await invokeMemory("memoryPlanViewMaintenance", {
-                    corpusId: view.corpusId,
-                    viewIds: [view.viewId],
-                });
-                if (!options.isCurrent()) return;
-                result.textContent = JSON.stringify(plan, null, 2);
-                summary.textContent = `Preview ready: ${plan.targets.length} explicit target(s). Inspect the exact plan before running.`;
-            }),
+        setTabLabel(
+            rbButton("Preview maintenance", () =>
+                options.action(async () => {
+                    if (!options.isCurrent()) return;
+                    requireSaved();
+                    const plan = await invokeMemory(
+                        "memoryPlanViewMaintenance",
+                        {
+                            corpusId: view.corpusId,
+                            viewIds: [view.viewId],
+                        },
+                    );
+                    if (!options.isCurrent()) return;
+                    result.textContent = JSON.stringify(plan, null, 2);
+                    summary.textContent = `Preview ready: ${plan.targets.length} explicit target(s). Inspect the exact plan before running.`;
+                }),
+            ),
+            "fa-screwdriver-wrench",
+            "Preview maintenance",
         ),
-        rbButton("Run manual maintenance", () =>
-            options.action(async () => {
-                if (!options.isCurrent()) return;
-                requireSaved();
-                const plan = await invokeMemory("memoryPlanViewMaintenance", {
-                    corpusId: view.corpusId,
-                    viewIds: [view.viewId],
-                });
-                if (!options.isCurrent()) return;
-                const receipt = await invokeMemory("memoryMaintainViews", {
-                    corpusId: view.corpusId,
-                    expectedHead: plan.expectedHead,
-                    targets: plan.targets.map(
-                        ({ viewId, expectedVersion }) => ({
-                            viewId,
-                            expectedVersion,
-                        }),
-                    ),
-                });
-                if (!options.isCurrent()) return;
-                result.textContent = JSON.stringify(
-                    { receiptId: receipt.receiptId, plan: receipt.plan },
-                    null,
-                    2,
-                );
-                if (receipt.job) options.onBuild(receipt.job);
-                summary.textContent = receipt.job
-                    ? `Update started: ${receipt.job.state}. Results are recorded per target.`
-                    : "Maintenance receipt recorded. No build job was started; inspect the exact receipt.";
-            }),
+        setTabLabel(
+            rbButton("Run manual maintenance", () =>
+                options.action(async () => {
+                    if (!options.isCurrent()) return;
+                    requireSaved();
+                    const plan = await invokeMemory(
+                        "memoryPlanViewMaintenance",
+                        {
+                            corpusId: view.corpusId,
+                            viewIds: [view.viewId],
+                        },
+                    );
+                    if (!options.isCurrent()) return;
+                    const receipt = await invokeMemory("memoryMaintainViews", {
+                        corpusId: view.corpusId,
+                        expectedHead: plan.expectedHead,
+                        targets: plan.targets.map(
+                            ({ viewId, expectedVersion }) => ({
+                                viewId,
+                                expectedVersion,
+                            }),
+                        ),
+                    });
+                    if (!options.isCurrent()) return;
+                    result.textContent = JSON.stringify(
+                        { receiptId: receipt.receiptId, plan: receipt.plan },
+                        null,
+                        2,
+                    );
+                    if (receipt.job) options.onBuild(receipt.job);
+                    summary.textContent = receipt.job
+                        ? `Update started: ${receipt.job.state}. Results are recorded per target.`
+                        : "Maintenance receipt recorded. No build job was started; inspect the exact receipt.";
+                }),
+            ),
+            "fa-screwdriver-wrench",
+            "Run manual maintenance",
         ),
         manifest,
         summary,
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubModel.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubModel.test.ts
index 7966fdb41b..076a063729 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubModel.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubModel.test.ts
@@ -38,6 +38,13 @@ test("deep links round-trip reserved characters without losing identity", () =>
         objectId: "source:# ?/1",
     };
     expect(parseRoute(routeHash(source))).toEqual(source);
+    const question = {
+        page: "questions" as const,
+        corpusId: "corpus/a",
+        objectId: "view:# ?/1",
+        questionSlotId: "slot/a ?",
+    };
+    expect(parseRoute(routeHash(question))).toEqual(question);
     const inbox = { page: "inbox" as const, objectId: "job:c/a" };
     expect(parseRoute(routeHash(inbox))).toEqual(inbox);
     expect(parseRoute("#/unknown")).toEqual({
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubModel.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubModel.ts
index 8f473bbc56..85dc06a3e9 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubModel.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubModel.ts
@@ -21,6 +21,7 @@ export type HubRoute = {
     viewRevisionId?: string;
     viewPageId?: string;
     viewItemKey?: string;
+    questionSlotId?: string;
     activityKind?: "view-build";
     webView?: "analytics" | "entities" | "topics";
     webEntity?: string;
@@ -90,6 +91,9 @@ export function parseRoute(hash: string): HubRoute {
         corpusId: parts[1] || undefined,
         objectId: parts[2] || undefined,
         ...(page === "views" ? parseViewSelection(parts) : {}),
+        ...(page === "questions" && parts[3] === "slot" && parts[4]
+            ? { questionSlotId: parts[4] }
+            : {}),
         ...(page === "activity" && parts[3] === "view-build"
             ? { activityKind: "view-build" as const }
             : {}),
@@ -121,6 +125,9 @@ export function routeHash(route: HubRoute): string {
                 : [
                       route.corpusId,
                       route.objectId,
+                      ...(route.page === "questions" && route.questionSlotId
+                          ? ["slot", route.questionSlotId]
+                          : []),
                       ...(route.page === "views" && route.viewRevisionId
                           ? ["revision", route.viewRevisionId]
                           : []),
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubProjectBrief.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubProjectBrief.test.ts
index a50522c78b..ff8f8fa2f6 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubProjectBrief.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubProjectBrief.test.ts
@@ -144,7 +144,9 @@ async function settle() {
 }
 function click(host: HTMLElement, label: string) {
     const button = [...host.querySelectorAll("button")].find(
-        (button) => button.textContent === label,
+        (button) =>
+            button.textContent === label ||
+            button.getAttribute("aria-label") === label,
     );
     if (!button) throw new Error(`Missing project control: ${label}`);
     button.click();
@@ -276,6 +278,97 @@ describe("Memory Hub project brief selector, editor and scope safety", () => {
         panel.dispose();
         jest.restoreAllMocks();
     });
+    test.each([
+        { summary: content.summary, coverageNote: "Selected evidence only" },
+        { summary: undefined, coverageNote: "Selected evidence only" },
+        { summary: undefined, coverageNote: undefined },
+    ])(
+        "brief sidecard separates overview and metadata without losing sections or evidence: %o",
+        async (overview) => {
+            const original = invoke.getMockImplementation()!;
+            const briefContent: ProjectBriefContent = {
+                ...content,
+                ...overview,
+                status: "partial",
+            };
+            invoke.mockImplementation(
+                inventoryFixture((method, params) =>
+                    method === "memoryListViews"
+                        ? Promise.resolve({
+                              head,
+                              views: [
+                                  {
+                                      ...view,
+                                      content: briefContent,
+                                      createdAt: "2026-10-27T19:08:34.209Z",
+                                  },
+                              ],
+                          })
+                        : original(method, params),
+                ),
+            );
+            await panel.refresh();
+            click(host, "Payments reliability");
+            await settle();
+            const article = host.querySelector(".hub-view-document")!;
+            const flow = article.querySelector(".hub-view-reading-flow")!;
+            const sidecard = flow.querySelector(
+                'aside[aria-label="About this brief"]',
+            )!;
+            expect(sidecard.querySelector("h3")!.textContent).toBe(
+                overview.summary ? "Synopsis" : "About this brief",
+            );
+            expect(
+                sidecard.querySelector(".hub-view-infobox-label")!.textContent,
+            ).toBe("Brief overview");
+            expect(
+                sidecard.querySelector(".hub-view-lead")?.textContent.trim(),
+            ).toBe(overview.summary);
+            expect(sidecard.querySelector(".hub-view-note")?.textContent).toBe(
+                overview.coverageNote
+                    ? "Coverage: Selected evidence only"
+                    : undefined,
+            );
+            expect(sidecard.textContent).toContain("Version 1");
+            expect(sidecard.textContent).toContain("Completeness: partial");
+            expect(sidecard.querySelector("time")!.dateTime).toBe(
+                "2026-10-27T19:08:34.209Z",
+            );
+            expect(
+                [...flow.querySelectorAll(".hub-view-section")].map(
+                    (section) => ({
+                        heading: section.querySelector("h3")!.textContent,
+                        body: section
+                            .querySelector(".markdown-preview")!
+                            .textContent.trim(),
+                    }),
+                ),
+            ).toEqual(
+                content.sections.map((section) => ({
+                    heading: section.heading,
+                    body: section.body,
+                })),
+            );
+            expect(sidecard.querySelector(".hub-view-section")).toBeNull();
+            expect(
+                article.querySelector(":scope > details > summary")!
+                    .textContent,
+            ).toBe("Sources (1)");
+            expect(
+                article.querySelector(
+                    'button[aria-label="Open exact evidence status"]',
+                ),
+            ).not.toBeNull();
+            click(host, "Edit");
+            expect(
+                host.querySelector(
+                    '[aria-label="Project brief fixed template"]',
+                ),
+            ).not.toBeNull();
+            expect(errors).toEqual([]);
+        },
+    );
+
     test("kind picker builds indexed project summaries and fixed-template edits retain the query selector", async () => {
         await panel.refresh();
         click(host, "Build views");
@@ -399,7 +492,8 @@ describe("Memory Hub project brief selector, editor and scope safety", () => {
         });
         await settle();
         expect(host.textContent).not.toContain("Do not leak across scope");
-        expect(host.textContent).toContain("across your collections");
+        expect(host.textContent).toContain("Collection: Payments");
+        expect(host.querySelectorAll(".hub-view-card")).toHaveLength(1);
         expect(host.querySelector('[aria-label="View kind"]')).toBeNull();
     });
     test("older capabilities do not advertise or open an unsupported project kind", async () => {
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
index 35027bc1dd..f7e5ee9621 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
@@ -26,7 +26,10 @@ function click(label: string) {
     if (!target) throw new Error(`Missing button ${label}`);
     target.click();
 }
-function setup(scope: () => string | undefined = () => "corpus") {
+function setup(
+    scope: () => string | undefined = () => "corpus",
+    onNavigate?: Parameters<typeof mountMemoryHubQuestions>[2]["onNavigate"],
+) {
     document.body.innerHTML = "<main></main><aside></aside>";
     const onError = jest.fn();
     return {
@@ -41,6 +44,7 @@ function setup(scope: () => string | undefined = () => "corpus") {
                 persistHidden: jest.fn(),
                 onError,
                 onOpenSource: jest.fn(),
+                onNavigate,
             },
         ),
     };
@@ -59,6 +63,169 @@ beforeEach(() => {
         }),
     );
 });
+test("question cards navigate to a corpus-qualified slot reader and Back restores the list route", async () => {
+    const onNavigate = jest.fn();
+    const { panel, onError } = setup(() => "corpus", onNavigate);
+    await panel.show();
+    click("What is the name?");
+    expect(onNavigate).toHaveBeenLastCalledWith({
+        page: "questions",
+        corpusId: "corpus",
+        objectId: "view",
+        questionSlotId: "slot",
+    });
+    await panel.show("view", "corpus", "slot");
+    const reader = document.querySelector<HTMLElement>(".hub-question-reader")!;
+    expect(reader.hidden).toBe(false);
+    expect(
+        document.querySelector<HTMLElement>('[aria-label="Questions list"]')!
+            .hidden,
+    ).toBe(true);
+    const overview = reader.querySelector(
+        'aside[aria-label="About this question"]',
+    )!;
+    expect(overview.classList).toContain("hub-view-infobox");
+    expect(overview.textContent).toContain("Coverage unknown");
+    expect(overview.textContent).toContain("Version 2");
+    expect(reader.querySelector(".hub-question-content")).not.toBeNull();
+    click("Back to questions");
+    expect(onNavigate).toHaveBeenLastCalledWith({ page: "questions" });
+    await panel.show();
+    expect(reader.hidden).toBe(true);
+    expect(
+        document.querySelector<HTMLElement>('[aria-label="Questions list"]')!
+            .hidden,
+    ).toBe(false);
+    expect(onError).not.toHaveBeenCalled();
+});
+
+test("direct question links load the exact slot without searching every collection or inventory page", async () => {
+    const original = invoke.getMockImplementation()!;
+    invoke.mockImplementation((method, params) =>
+        method === "memoryGetQuestion"
+            ? Promise.resolve(question("off-page"))
+            : original(method, params),
+    );
+    const { panel, onError } = setup();
+    await panel.show("view", "corpus", "off-page");
+    expect(invoke).toHaveBeenCalledWith("memoryGetQuestion", {
+        corpusId: "corpus",
+        viewId: "view",
+        slotId: "off-page",
+    });
+    expect(invoke).toHaveBeenCalledWith("memoryListQuestionSummaries", {
+        corpusId: "corpus",
+        viewId: "view",
+        pageSize: 1,
+    });
+    expect(document.querySelector(".hub-view-infobox")!.textContent).toContain(
+        "Coverage unknown",
+    );
+    const answer = document.querySelector<HTMLTextAreaElement>(
+        '[aria-label="Question inspector"] textarea',
+    )!;
+    answer.value = '"Ada"';
+    answer.dispatchEvent(new Event("input"));
+    click("Save user assertion");
+    await settle();
+    expect(invoke).toHaveBeenCalledWith(
+        "memoryEditQuestion",
+        expect.objectContaining({
+            slotId: "off-page",
+            expectedHead: "head",
+            expectedVersion: 2,
+        }),
+    );
+    expect(document.querySelector(".hub-view-infobox")).not.toBeNull();
+    expect(onError).not.toHaveBeenCalled();
+});
+
+test("Back invalidates pending question details and operation errors stay visible on the reader", async () => {
+    const { panel } = setup();
+    await panel.show();
+    const original = invoke.getMockImplementation()!;
+    let resolve!: (value: unknown) => void;
+    invoke.mockImplementation((method, params) =>
+        method === "memoryGetQuestion"
+            ? new Promise((done) => {
+                  resolve = done;
+              })
+            : original(method, params),
+    );
+    click("What is the name?");
+    click("Back to questions");
+    resolve(question());
+    await settle();
+    expect(
+        document.querySelector<HTMLElement>(".hub-question-reader")!.hidden,
+    ).toBe(true);
+    expect(document.querySelector(".hub-qdetail")!.textContent).toBe("");
+    invoke.mockImplementation(original);
+    click("What is the name?");
+    await settle();
+    invoke.mockImplementation((method, params) =>
+        method === "memoryEditQuestion"
+            ? Promise.reject(new Error("Edit rejected"))
+            : original(method, params),
+    );
+    const answer = document.querySelector<HTMLTextAreaElement>(
+        '[aria-label="Question inspector"] textarea',
+    )!;
+    answer.value = '"Ada"';
+    answer.dispatchEvent(new Event("input"));
+    click("Save user assertion");
+    await settle();
+    expect(
+        document.querySelector(".hub-qdetail [role=alert]")!.textContent,
+    ).toContain("Edit rejected");
+});
+test("questions put tabs after the title, totals and paging inside the list card, and preparation last", async () => {
+    const original = invoke.getMockImplementation()!;
+    invoke.mockImplementation(async (method, params) => {
+        const result = await original(method, params);
+        return method === "memoryListQuestionSummaries" &&
+            result &&
+            typeof result === "object"
+            ? { ...result, total: 70 }
+            : result;
+    });
+    const { panel } = setup();
+    await panel.show();
+    const host = document.querySelector("main")!;
+    const tabs = host.querySelector('[aria-label="Question filter"]')!;
+    const card = host.querySelector('[aria-label="Questions list"]')!;
+    expect(tabs.previousElementSibling!.classList).toContain("hub-qhead");
+    expect(tabs.nextElementSibling).toBe(card);
+    expect(card.classList).toContain("card");
+    expect(card.querySelector(".hub-list-total")!.textContent).toBe("70 total");
+    expect(card.querySelectorAll(".hub-qrow")).toHaveLength(1);
+    expect(
+        card.lastElementChild!.querySelector("nav")!.getAttribute("aria-label"),
+    ).toBe("questions pages");
+    expect(host.lastElementChild!.querySelector("summary")!.textContent).toBe(
+        "Knowledge preparation",
+    );
+});
+test("question filter tabs keep icons, exclusive selection and server filters", async () => {
+    const { panel, onError } = setup();
+    await panel.show();
+    const filters = document.querySelector('[aria-label="Question filter"]')!;
+    expect(filters.classList).toContain("hub-tabs");
+    expect(filters.closest(".hub-qfilters")).toBeNull();
+    expect(filters.querySelectorAll('i[aria-hidden="true"]')).toHaveLength(3);
+    for (const answerFilter of ["open", "answered"]) {
+        click(answerFilter === "open" ? "Open" : "Answered");
+        await settle();
+        expect(filters.querySelectorAll('[aria-pressed="true"]')).toHaveLength(
+            1,
+        );
+        expect(invoke).toHaveBeenCalledWith(
+            "memoryListQuestionSummaries",
+            expect.objectContaining({ answerFilter }),
+        );
+    }
+    expect(onError).not.toHaveBeenCalled();
+});
 test("a scope switch cannot reuse another collection's fresh cached question page", async () => {
     let scope = "corpus";
     const { panel } = setup(() => scope);
@@ -225,7 +392,7 @@ test.each([false, true])(
             invoke.mock.calls.some(
                 ([method]) => method === "memoryGetKnowledgeStatus",
             ),
-        ).toBe(true);
+        ).toBe(false);
         if (policyAdmission) {
             expect(document.body.textContent).toContain("Policy-discovered");
             expect(document.body.textContent).toContain(
@@ -242,6 +409,37 @@ test.each([false, true])(
         ).not.toBeNull();
     },
 );
+test("knowledge progress loads only when expanded and is not fetched for Inbox attention", async () => {
+    const { panel } = setup();
+    await panel.show();
+    expect(
+        invoke.mock.calls.some(
+            ([method]) =>
+                method === "memoryGetKnowledgeStatus" ||
+                method === "memoryGetCorpus",
+        ),
+    ).toBe(false);
+    const knowledgePanel = document
+        .querySelector('[aria-label="Knowledge preparation"]')!
+        .closest("details")!;
+    knowledgePanel.open = true;
+    knowledgePanel.dispatchEvent(new Event("toggle"));
+    await settle();
+    expect(invoke).toHaveBeenCalledWith("memoryGetKnowledgeStatus", {
+        corpusId: "corpus",
+    });
+    const calls = invoke.mock.calls.length;
+    await panel.refreshAttention();
+    expect(
+        invoke.mock.calls
+            .slice(calls)
+            .some(
+                ([method]) =>
+                    method === "memoryGetKnowledgeStatus" ||
+                    method === "memoryGetCorpus",
+            ),
+    ).toBe(false);
+});
 test("invalid answers and unapproved authoring do not reach service edits", async () => {
     const { panel, onError } = setup();
     await panel.show();
@@ -297,6 +495,9 @@ test("an inventory failure clears stale decisions and reports an incomplete resu
     );
 
     await panel.refresh();
+    expect(document.querySelector(".hub-list-total")!.textContent).toBe(
+        "Unavailable",
+    );
     expect(document.body.textContent).toContain(
         "Incomplete question inventory",
     );
@@ -325,7 +526,9 @@ test("question maintenance errors remain explicit alongside the complete invento
     expect(document.body.textContent).toContain(
         "Question maintenance failed: Source evaluation failed",
     );
-    expect(document.body.textContent).toContain("1 question");
+    expect(document.querySelector(".hub-list-total")!.textContent).toBe(
+        "1 total",
+    );
 });
 
 test("candidate review retains exact source citations and never counts mentions as votes", async () => {
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
index f8bf39f109..3153dc8d05 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
@@ -17,7 +17,7 @@ import {
     rbField,
     rbError,
 } from "./memoryHubDocumentUi";
-import { icon, menuButton } from "./memoryHubUi";
+import { icon, menuButton, setTabLabel } from "./memoryHubUi";
 import {
     questionAttention,
     questionIdentity,
@@ -26,10 +26,15 @@ import {
     questionCandidateCount,
     type QuestionListItem,
 } from "./memoryHubQuestionsModel";
-import { routeHash, type HiddenItems } from "./memoryHubModel";
+import { routeHash, type HiddenItems, type HubRoute } from "./memoryHubModel";
 import { schemaViewPageBrowserLink } from "./memoryHubViewPages";
 import { mountMemoryHubAcquisitions } from "./memoryHubAcquisitions";
 import { mountMemoryHubKnowledgeStatus } from "./memoryHubKnowledgeStatus";
+import type { InboxAttentionCard } from "./memoryHubInbox";
+
+type QuestionTarget = Pick<MemoryQuestion, "corpusId" | "viewId"> & {
+    slot: { id: string; question?: string };
+};
 
 export function mountMemoryHubQuestions(
     host: HTMLElement,
@@ -41,7 +46,10 @@ export function mountMemoryHubQuestions(
         persistHidden: () => void;
         onError: (error: unknown) => void;
         onOpenSource: (corpusId: string, sourceId: string) => void;
-        onAttentionCount?: (count: number) => void;
+        onNavigate?: (route: HubRoute) => void;
+        onAttentionCount?: (count: number, hasMore?: boolean) => void;
+        onAttentionError?: (error: unknown) => void;
+        presentAttention?: (card: InboxAttentionCard) => HTMLElement;
     },
 ) {
     let inventories = new Map<string, QuestionSummaryPage>();
@@ -56,6 +64,7 @@ export function mountMemoryHubQuestions(
     let dirty = false;
     type Filter = "all" | "open" | "answered";
     let selectedKey: string | undefined;
+    let selectedQuestion: QuestionTarget | undefined;
     let filter: Filter = "all";
     let search = "";
     let loadedAt = 0;
@@ -64,16 +73,45 @@ export function mountMemoryHubQuestions(
     let failureLines: string[] = [];
     const status = rbChip("");
     status.setAttribute("role", "status");
+    const total = rbNode("span", "Loading...", "hub-list-total");
     const notice = rbNode("div", undefined, "hub-notice");
     notice.hidden = true;
     const list = rbNode("div", undefined, "hub-qlist");
-    const inspector = rbNode("section", undefined, "hub-qdetail");
+    const inspector = rbNode(
+        "article",
+        undefined,
+        "hub-qdetail hub-view-document",
+    );
     inspector.setAttribute("aria-label", "Question inspector");
+    const reader = rbNode("section", undefined, "hub-question-reader");
+    reader.hidden = true;
+    const readerActions = rbNode("div", undefined, "hub-view-actions");
+    const back = rbIconButton(
+        "fa-arrow-left",
+        "Back to questions",
+        backToQuestions,
+    );
+    readerActions.append(back);
+    reader.append(readerActions, inspector);
     const author = rbNode("section");
     const acquisitionHost = rbNode("section");
     const acquisitions = mountMemoryHubAcquisitions(acquisitionHost);
     const knowledgeHost = rbNode("section");
     const knowledge = mountMemoryHubKnowledgeStatus(knowledgeHost);
+    const knowledgePanel = rbNode("details", undefined, "hub-panel");
+    knowledgePanel.append(
+        rbNode("summary", "Knowledge preparation"),
+        knowledgeHost,
+    );
+    let knowledgeLoaded = false;
+    async function loadKnowledge() {
+        if (!knowledgePanel.open || knowledgeLoaded || attentionOnly) return;
+        knowledgeLoaded = true;
+        await knowledge.refresh(panelCorpora);
+    }
+    knowledgePanel.addEventListener("toggle", () => {
+        void loadKnowledge().catch(options.onError);
+    });
     const panel = rbNode("details", undefined, "hub-panel");
     panel.append(
         rbNode("summary", "Deferred evidence acquisition"),
@@ -82,20 +120,20 @@ export function mountMemoryHubQuestions(
     let panelCorpora: Array<{ corpusId: string; name: string }> = [];
     let panelLoaded = false;
     async function loadPanel() {
-        if (!panel.open || panelLoaded) return;
+        if (!panel.open || panelLoaded || attentionOnly) return;
         panelLoaded = true;
         await acquisitions.refresh(panelCorpora, selectedView);
     }
     panel.addEventListener("toggle", () => {
         void loadPanel().catch((error: unknown) => options.onError(error));
     });
-    const chips = rbNode("div", undefined, "hub-chips");
+    const chips = rbNode("div", undefined, "hub-tabs");
     chips.setAttribute("role", "group");
     chips.setAttribute("aria-label", "Question filter");
-    for (const [value, label] of [
-        ["all", "All"],
-        ["open", "Open"],
-        ["answered", "Answered"],
+    for (const [value, label, glyph] of [
+        ["all", "All", "fa-list"],
+        ["open", "Open", "fa-circle-question"],
+        ["answered", "Answered", "fa-circle-check"],
     ] as const) {
         const chip = rbButton(label, () => {
             filter = value;
@@ -105,6 +143,7 @@ export function mountMemoryHubQuestions(
             pager.reset();
             void refresh().catch(options.onError);
         });
+        setTabLabel(chip, glyph, label);
         chip.setAttribute("aria-pressed", String(value === filter));
         chips.append(chip);
     }
@@ -149,19 +188,47 @@ export function mountMemoryHubQuestions(
         }),
     );
     const filters = rbNode("div", undefined, "hub-qfilters");
-    filters.append(chips, searchBox);
-    const split = rbNode("div", undefined, "hub-split");
-    split.append(list, inspector);
-    host.append(
-        head,
-        notice,
-        knowledgeHost,
-        author,
-        filters,
-        split,
-        pagination,
-        panel,
-    );
+    filters.append(searchBox);
+    const card = rbNode("section", undefined, "card hub-list-card");
+    card.setAttribute("aria-label", "Questions list");
+    const cardHead = rbNode("div", undefined, "section-heading");
+    cardHead.append(rbNode("h2", "Questions"), total);
+    card.append(cardHead, notice, filters, list, pagination);
+    host.append(head, chips, card, reader, author, panel, knowledgePanel);
+
+    function setDetailMode(detail: boolean) {
+        reader.hidden = !detail;
+        for (const element of [
+            head,
+            chips,
+            card,
+            author,
+            panel,
+            knowledgePanel,
+        ])
+            element.hidden = detail;
+    }
+
+    function backToQuestions() {
+        if (busy || (dirty && !confirm("Discard unsaved question edits?")))
+            return;
+        dirty = false;
+        detailSequence++;
+        selectedKey = undefined;
+        selectedQuestion = undefined;
+        inspector.setAttribute("aria-busy", "false");
+        inspector.replaceChildren();
+        if (options.onNavigate)
+            options.onNavigate({
+                page: "questions",
+                ...(selectedView ? { objectId: selectedView } : {}),
+                ...(selectedCorpus ? { corpusId: selectedCorpus } : {}),
+            });
+        else {
+            setDetailMode(false);
+            renderList();
+        }
+    }
 
     function action(work: () => Promise<void>) {
         if (busy) return;
@@ -169,6 +236,11 @@ export function mountMemoryHubQuestions(
         void work()
             .catch((error: unknown) => {
                 status.textContent = `Question operation failed: ${rbError(error)}`;
+                if (!reader.hidden) {
+                    const alert = rbNode("p", status.textContent);
+                    alert.setAttribute("role", "alert");
+                    inspector.append(alert);
+                }
                 options.onError(error);
             })
             .finally(() => {
@@ -231,24 +303,25 @@ export function mountMemoryHubQuestions(
         return section;
     }
     async function edit(question: MemoryQuestion, edit: QuestionEdit) {
+        const current = detailSequence;
+        const inventory = inventories.get(question.corpusId);
+        if (!inventory)
+            throw new Error(
+                "Question inventory is unavailable. Reload the question before editing.",
+            );
         await invokeMemory("memoryEditQuestion", {
             corpusId: question.corpusId,
             viewId: question.viewId,
             slotId: question.slot.id,
-            expectedHead: inventories.get(question.corpusId)!.head,
+            expectedHead: inventory.head,
             expectedVersion: question.viewVersion,
             edit,
         });
         dirty = false;
         await refreshInventory();
-        const current = all().find(
-            (item) => questionIdentity(item) === questionIdentity(question),
-        );
-        if (current) inspect(await fetchQuestion(current));
-        else
-            inspector.replaceChildren(
-                rbNode("p", "This question is no longer available."),
-            );
+        if (current !== detailSequence || reader.hidden) return;
+        const updated = await fetchQuestion(question);
+        if (current === detailSequence && !reader.hidden) inspect(updated);
     }
     function originLabel(question: QuestionListItem) {
         return (
@@ -298,7 +371,7 @@ export function mountMemoryHubQuestions(
         if (count > 1) row.append(rbChip(`${count} candidates`));
         return row;
     }
-    async function fetchQuestion(question: QuestionListItem) {
+    async function fetchQuestion(question: QuestionTarget) {
         const detail = await invokeMemory("memoryGetQuestion", {
             corpusId: question.corpusId,
             viewId: question.viewId,
@@ -309,45 +382,81 @@ export function mountMemoryHubQuestions(
     }
     let detailSequence = 0;
     function select(question: QuestionListItem) {
+        if (options.onNavigate) {
+            options.onNavigate({
+                page: "questions",
+                corpusId: question.corpusId,
+                objectId: question.viewId,
+                questionSlotId: question.slot.id,
+            });
+        } else void loadDetail(question);
+    }
+    async function loadDetail(question: QuestionTarget) {
         if (busy) return;
         if (dirty && !confirm("Discard unsaved question edits?")) return;
         dirty = false;
         const current = ++detailSequence;
         const scope = options.scope();
-        selectedKey = questionKey(question);
+        const key = questionIdentity(question);
+        selectedKey = key;
+        selectedQuestion = question;
+        setDetailMode(true);
+        readerActions.replaceChildren(back);
         const isCurrent = () =>
             current === detailSequence &&
-            selectedKey === questionKey(question) &&
+            selectedKey === key &&
             scope === options.scope();
         inspector.setAttribute("aria-busy", "true");
-        inspector.replaceChildren(
-            rbNode("h3", question.slot.question),
+        inspector.append(
+            rbNode("h2", question.slot.question ?? "Question"),
             rbNode("p", "Loading question details..."),
         );
-        void fetchQuestion(question)
-            .then((detail) => {
-                if (isCurrent()) inspect(detail);
-            })
-            .catch((error: unknown) => {
-                if (!isCurrent()) return;
-                const alert = rbNode(
-                    "p",
-                    `Question details unavailable: ${rbError(error)}`,
-                );
-                alert.setAttribute("role", "alert");
-                inspector.replaceChildren(
-                    rbNode("h3", question.slot.question),
-                    alert,
-                    rbButton("Retry question details", () => select(question)),
+        try {
+            if (!schemaViewsSupported) {
+                const capabilities = await invokeMemory(
+                    "memoryViewCapabilities",
+                    {},
                 );
-                options.onError(error);
-            })
-            .finally(() => {
-                if (isCurrent()) inspector.setAttribute("aria-busy", "false");
-            });
-        renderList();
-        if (window.matchMedia?.("(max-width: 900px)").matches)
-            inspector.scrollIntoView?.({ block: "start" });
+                if (!isCurrent()) return;
+                schemaViewsSupported =
+                    capabilities.derivedViews?.kinds.includes("schemaView") ??
+                    false;
+                if (!schemaViewsSupported)
+                    throw new Error(
+                        "Schema-defined questions capability is unavailable.",
+                    );
+            }
+            const detail = await fetchQuestion(question);
+            if (!isCurrent()) return;
+            if (!inventories.has(question.corpusId)) {
+                const page = await invokeMemory("memoryListQuestionSummaries", {
+                    corpusId: question.corpusId,
+                    viewId: question.viewId,
+                    pageSize: 1,
+                });
+                if (!isCurrent()) return;
+                inventories.set(question.corpusId, page);
+                loadedAt = 0;
+            }
+            inspect(detail);
+        } catch (error: unknown) {
+            if (!isCurrent()) return;
+            const alert = rbNode(
+                "p",
+                `Question details unavailable: ${rbError(error)}`,
+            );
+            alert.setAttribute("role", "alert");
+            inspector.append(
+                rbNode("h2", question.slot.question ?? "Question"),
+                alert,
+                rbButton("Retry question details", () => {
+                    void loadDetail(question);
+                }),
+            );
+            options.onError(error);
+        } finally {
+            if (isCurrent()) inspector.setAttribute("aria-busy", "false");
+        }
     }
     function visibleQuestions() {
         return all().filter(
@@ -446,9 +555,36 @@ export function mountMemoryHubQuestions(
         // Decision first: the question, its status and the candidates.
         // Schemas, revisions and raw support stay under Advanced.
         inspector.replaceChildren();
+        const title = rbNode("h2", question.slot.question);
+        title.tabIndex = -1;
+        const flow = rbNode("div", undefined, "hub-view-reading-flow");
+        const overview = rbNode("aside", undefined, "hub-view-infobox");
+        overview.setAttribute("aria-label", "About this question");
+        overview.append(
+            rbNode("h3", "Question overview"),
+            rbNode(
+                "p",
+                "Answer coverage and metadata",
+                "hub-view-infobox-label",
+            ),
+            rowChips(question),
+            rbNode("p", detailMeta(question), "hub-view-note"),
+            rbNode(
+                "p",
+                `Collection: ${options.corpora().find((corpus) => corpus.corpusId === question.corpusId)?.name ?? question.corpusId}`,
+            ),
+            rbNode("p", `View: ${question.viewTitle}`),
+            rbNode(
+                "p",
+                `Version ${question.viewVersion} · ${details.evaluatedSources.length} evaluated sources`,
+            ),
+        );
+        const content = rbNode("div", undefined, "hub-question-content");
+        flow.append(overview, content);
+        inspector.append(title, flow);
         if (question.slot.admission) {
             const admission = question.slot.admission;
-            inspector.append(
+            overview.append(
                 rbChip(
                     admission.actor === "policy"
                         ? "Policy-discovered"
@@ -525,7 +661,7 @@ export function mountMemoryHubQuestions(
                                     ),
                                 );
                         }
-                        inspector.append(revisions);
+                        content.append(revisions);
                     }),
             },
             {
@@ -541,7 +677,7 @@ export function mountMemoryHubQuestions(
                         });
                         const link = rbNode("a", page.uri);
                         link.href = schemaViewPageBrowserLink(page.uri);
-                        inspector.append(
+                        content.append(
                             rbNode(
                                 "p",
                                 `Deterministic page · revision ${page.revisionId}`,
@@ -577,22 +713,20 @@ export function mountMemoryHubQuestions(
         headerActions.append(
             rbIconButton("fa-bell-slash", "Snooze one day", () => {
                 hideQuestions([question], Date.now() + 86400000);
-                inspector.replaceChildren();
+                backToQuestions();
             }),
             rbIconButton("fa-xmark", "Dismiss", () => {
                 hideQuestions([question]);
-                inspector.replaceChildren();
+                backToQuestions();
             }),
             menuButton("More question actions", menuItems),
         );
-        const titleRow = rbNode("div", undefined, "hub-qdetail-head");
-        titleRow.append(
-            rbNode("h3", question.slot.question),
-            rowChips(question),
+        readerActions.replaceChildren(
+            back,
+            rbNode("span", undefined, "hub-spacer"),
             headerActions,
         );
-        const meta = rbNode("p", detailMeta(question), "hub-muted");
-        inspector.append(titleRow, meta);
+        title.focus();
         const discovery = rbNode("details");
         discovery.append(rbNode("summary", "Configure bounded discovery"));
         const enable = rbNode("input");
@@ -637,7 +771,7 @@ export function mountMemoryHubQuestions(
             ),
         );
         advanced.append(discovery);
-        inspector.append(
+        content.append(
             details.candidates.length
                 ? rbNode("h4", "Candidates")
                 : rbNode("p", "No candidate answers yet."),
@@ -714,7 +848,7 @@ export function mountMemoryHubQuestions(
                 rbNode("pre", JSON.stringify(candidate.support, null, 2)),
             );
             card.append(detail);
-            inspector.append(card);
+            content.append(card);
         }
         const why = rbNode("details");
         why.append(
@@ -725,7 +859,7 @@ export function mountMemoryHubQuestions(
                 "Question discovery evidence",
             ),
         );
-        inspector.append(why);
+        content.append(why);
         let answer = "";
         let itemKey = "";
         let meaning = question.slot.question;
@@ -817,7 +951,7 @@ export function mountMemoryHubQuestions(
                 }),
             ),
         );
-        inspector.append(assertion, contract, advanced);
+        content.append(assertion, contract, advanced);
     }
     function hideQuestions(questions: QuestionListItem[], until?: number) {
         for (const question of questions)
@@ -830,17 +964,20 @@ export function mountMemoryHubQuestions(
     }
     function renderAttention() {
         attentionHost.replaceChildren();
-        const groups = questionAttention(
+        const allGroups = questionAttention(
             all().filter(
                 (question) =>
                     !options.scope() || question.corpusId === options.scope(),
             ),
             options.hidden,
+            Date.now(),
+            20,
         );
-        options.onAttentionCount?.(
-            groups.length + (attentionOnly && pager.hasNext ? 1 : 0),
-        );
-        if (!groups.length && !pager.hasNext) return;
+        const groups = allGroups.slice(0, 5);
+        if (!groups.length && !pager.hasNext) {
+            options.onAttentionCount?.(0, false);
+            return;
+        }
         attentionHost.append(rbNode("h3", "Question decisions"));
         const byReason = new Map<string, typeof groups>();
         for (const group of groups) {
@@ -867,6 +1004,9 @@ export function mountMemoryHubQuestions(
                     page: "questions",
                     corpusId: first.corpusId,
                     objectId: first.viewId,
+                    ...(group.questions.length === 1
+                        ? { questionSlotId: first.slot.id }
+                        : {}),
                 });
                 row.append(link);
                 for (const [label, glyph, until] of [
@@ -880,7 +1020,14 @@ export function mountMemoryHubQuestions(
                     );
                 rows.append(row);
             }
-            attentionHost.append(card);
+            attentionHost.append(
+                options.presentAttention?.({
+                    title: reason,
+                    summary: members.map((group) => group.title).join(", "),
+                    entries: members.length,
+                    detail: card,
+                }) ?? card,
+            );
         }
         if (attentionOnly)
             attentionHost.append(
@@ -888,6 +1035,14 @@ export function mountMemoryHubQuestions(
                     void refresh().catch(options.onError);
                 }),
             );
+        const workspace = rbNode("a", "Open Questions workspace");
+        workspace.href = "#/questions";
+        attentionHost.append(workspace);
+        options.onAttentionCount?.(
+            groups.length,
+            allGroups.length > groups.length ||
+                (attentionOnly && pager.hasNext),
+        );
     }
     function renderAuthor() {
         author.replaceChildren();
@@ -1011,7 +1166,12 @@ export function mountMemoryHubQuestions(
         );
         renderAuthor();
         const questions = all();
-        status.textContent = `Showing ${questions.length} of ${pager.total} questions`;
+        status.textContent = "";
+        total.textContent =
+            failureLines.length && failureLines.length === corpora.length
+                ? "Unavailable"
+                : `${pager.total} total${failureLines.length ? " (partial)" : ""}`;
+        total.title = `Showing ${questions.length} loaded questions${failureLines.length ? "; some collections are unavailable" : ""}.`;
         pagination.replaceChildren(
             pager.controls("questions", () => {
                 void refresh().catch(options.onError);
@@ -1019,6 +1179,7 @@ export function mountMemoryHubQuestions(
         );
         if (!corpora.length && corpusId) {
             status.textContent = "";
+            total.textContent = "Unavailable";
             failureLines = [
                 "Selected collection is unavailable; scope has not been broadened.",
             ];
@@ -1030,15 +1191,10 @@ export function mountMemoryHubQuestions(
         loadedScope = corpusId;
     }
     function scopedCorpora() {
-        const corpusId = options.scope();
+        const corpusId = selectedCorpus ?? options.scope();
         return options
             .corpora()
-            .filter(
-                (corpus) =>
-                    !corpusId ||
-                    corpus.corpusId === corpusId ||
-                    corpus.corpusId === selectedCorpus,
-            );
+            .filter((corpus) => !corpusId || corpus.corpusId === corpusId);
     }
     // Reloads the inventory only. Acquisition progress loads
     // when their panel is opened, not on every question edit.
@@ -1054,6 +1210,8 @@ export function mountMemoryHubQuestions(
     async function refresh() {
         const version = ++sequence;
         status.textContent = "Loading questions…";
+        total.textContent = "Loading...";
+        total.title = "";
         const corpora = scopedCorpora().filter((corpus) =>
             pager.includes(corpus.corpusId),
         );
@@ -1082,6 +1240,7 @@ export function mountMemoryHubQuestions(
             );
             options.onAttentionCount?.(0);
             status.textContent = `Questions unavailable: ${rbError(error)}`;
+            total.textContent = "Unavailable";
             throw error;
         }
         if (version !== sequence) return;
@@ -1097,6 +1256,7 @@ export function mountMemoryHubQuestions(
             attentionHost.replaceChildren();
             options.onAttentionCount?.(0);
             status.textContent = "";
+            total.textContent = "Unavailable";
             list.append(
                 rbNode(
                     "p",
@@ -1109,17 +1269,28 @@ export function mountMemoryHubQuestions(
         const results = await loadQuestions(corpora);
         if (version !== sequence) return;
         applyInventory(results, corpora, options.scope());
-        if (failureLines.length)
+        if (failureLines.length) {
             attentionHost.prepend(rbNode("p", failureLines.join("; ")));
+            if (attentionOnly)
+                options.onAttentionError?.(new Error(failureLines.join("; ")));
+        }
         panelCorpora = corpora.filter(
             (corpus) => !selectedCorpus || corpus.corpusId === selectedCorpus,
         );
         panelLoaded = false;
-        await knowledge.refresh(panelCorpora);
+        knowledgeLoaded = false;
+        knowledge.clear();
+        await loadKnowledge();
         if (panel.open) await loadPanel();
     }
     return {
-        async show(viewId?: string, corpusId?: string) {
+        async show(viewId?: string, corpusId?: string, slotId?: string) {
+            if (slotId && viewId && corpusId) {
+                attentionOnly = false;
+                await loadDetail({ corpusId, viewId, slot: { id: slotId } });
+                return;
+            }
+            setDetailMode(false);
             detailSequence++;
             inspector.setAttribute("aria-busy", "false");
             const same =
@@ -1139,7 +1310,11 @@ export function mountMemoryHubQuestions(
             }
             await refresh();
         },
-        refresh,
+        async refresh() {
+            await refresh();
+            if (!reader.hidden && selectedQuestion)
+                await loadDetail(selectedQuestion);
+        },
         hide() {
             detailSequence++;
             inspector.setAttribute("aria-busy", "false");
@@ -1150,7 +1325,12 @@ export function mountMemoryHubQuestions(
             selectedCorpus = undefined;
             clearTimeout(searchTimer);
             pager.reset();
-            await refresh();
+            try {
+                await refresh();
+            } catch (error) {
+                options.onAttentionError?.(error);
+                throw error;
+            }
         },
         discardChanges() {
             if (!dirty) return true;
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestionsModel.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestionsModel.ts
index 965943ac65..7aaef75fca 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestionsModel.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestionsModel.ts
@@ -15,7 +15,11 @@ export function questionCandidateCount(question: QuestionListItem): number {
         ? question.details.candidateCount
         : question.details.candidates.length;
 }
-export function questionIdentity(question: QuestionListItem): string {
+export function questionIdentity(
+    question: Pick<MemoryQuestion, "corpusId" | "viewId"> & {
+        slot: { id: string };
+    },
+): string {
     return JSON.stringify([
         "question",
         question.corpusId,
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubTimeline.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubTimeline.test.ts
index c7911b5649..0e85787c86 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubTimeline.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubTimeline.test.ts
@@ -70,7 +70,9 @@ async function settle() {
 }
 function click(host: HTMLElement, label: string) {
     const button = [...host.querySelectorAll("button")].find(
-        (button) => button.textContent === label,
+        (button) =>
+            button.textContent === label ||
+            button.getAttribute("aria-label") === label,
     );
     if (!button) throw new Error(`Missing timeline button ${label}`);
     button.click();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubUi.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubUi.test.ts
index 057146c6a5..9ce276a9d0 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubUi.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubUi.test.ts
@@ -5,6 +5,7 @@ import {
     iconButton,
     menuButton,
     setIconButton,
+    setTabLabel,
     watchSlowRequest,
 } from "./memoryHubUi";
 
@@ -12,6 +13,19 @@ afterEach(() => {
     document.body.replaceChildren();
 });
 
+test("tab labels retain readable text and one decorative icon after count updates", () => {
+    const button = document.createElement("button");
+    const action = jest.fn();
+    button.addEventListener("click", action);
+    setTabLabel(button, "fa-layer-group", "Views (2)");
+    setTabLabel(button, "fa-layer-group", "Views (3+)");
+    expect(button.textContent).toBe("Views (3+)");
+    expect(button.querySelectorAll("i")).toHaveLength(1);
+    expect(button.querySelector("i")!.getAttribute("aria-hidden")).toBe("true");
+    button.click();
+    expect(action).toHaveBeenCalledTimes(1);
+});
+
 test("icon buttons keep an accessible name and tooltip", () => {
     const action = jest.fn();
     const button = iconButton("fa-xmark", "Close", action, "danger");
@@ -62,6 +76,7 @@ test("menus open on demand, evaluate disabled state late and close on use", () =
     items[0].click();
     expect(first).toHaveBeenCalledTimes(1);
     expect(host.querySelector(".hub-menu")).toBeNull();
+    expect(document.activeElement).toBe(trigger);
     locked = false;
     trigger.click();
     host.querySelectorAll<HTMLButtonElement>("[role=menuitem]")[1].click();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubUi.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubUi.ts
index c5c493f5e1..6f15d9adc8 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubUi.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubUi.ts
@@ -16,6 +16,15 @@ export function icon(name: string): HTMLElement {
     return glyph;
 }
 
+export function setTabLabel(
+    target: HTMLButtonElement,
+    glyph: string,
+    label: string,
+): HTMLButtonElement {
+    target.replaceChildren(icon(glyph), document.createTextNode(label));
+    return target;
+}
+
 export function setIconButton(
     target: HTMLButtonElement,
     glyph: string,
@@ -120,6 +129,7 @@ export function menuButton(
             entry.append(icon(item.icon), item.label);
             entry.addEventListener("click", () => {
                 close();
+                trigger.focus();
                 item.action();
             });
             menu.append(entry);
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubUsability.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubUsability.test.ts
index fdbb34a8c8..70c6eeef37 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubUsability.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubUsability.test.ts
@@ -204,7 +204,7 @@ test("question detail passes the audit and hides raw JSON until Advanced is open
     expect(audit(document.body, 250)).toEqual([]);
     const advanced = [
         ...document.querySelectorAll(
-            '[aria-label="Question inspector"] > details',
+            '[aria-label="Question inspector"] .hub-question-content > details',
         ),
     ].find(
         (details) =>
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.test.ts
index 3ab97ca915..0473fc6547 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.test.ts
@@ -118,6 +118,64 @@ test("partial builds and failed targets remain explicit in Activity and Inbox",
     mounted.dispose();
 });
 
+test.each(["pending", "resolved", "missing", undefined] as const)(
+    "conflict attention uses summary state %s and fetches full evidence only for legacy summaries",
+    async (conflictState) => {
+        const previous = invoke.getMockImplementation()!;
+        invoke.mockImplementation(async (method, params) => {
+            if (method === "memoryListViewBuildSummaries")
+                return {
+                    total: 1,
+                    items: [
+                        {
+                            ...job(),
+                            results: [
+                                {
+                                    viewId: "wiki",
+                                    state: "conflicted",
+                                    reason: "Review overlap",
+                                    current: true,
+                                    conflictId: "conflict",
+                                    conflictState,
+                                    snapshot: {
+                                        pipeline: "informational-wiki-v1",
+                                        definition: { kind: "wiki" },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                };
+            if (method === "memoryGetViewConflict") return { state: "pending" };
+            return previous(method, params);
+        });
+        const attention = document.createElement("div");
+        const mounted = mountMemoryHubViewActivity(
+            document.createElement("div"),
+            attention,
+            {
+                scope: () => "alpha",
+                onError: jest.fn(),
+                onOpenView: jest.fn(),
+                onOpenBuild: jest.fn(),
+            },
+        );
+        try {
+            await mounted.show();
+            expect(attention.textContent?.includes("Resolve conflict")).toBe(
+                conflictState === "pending" || conflictState === undefined,
+            );
+            expect(
+                invoke.mock.calls.filter(
+                    ([method]) => method === "memoryGetViewConflict",
+                ),
+            ).toHaveLength(conflictState === undefined ? 1 : 0);
+        } finally {
+            mounted.dispose();
+        }
+    },
+);
+
 test("cancellation is not displayed as acknowledged until the service says so", async () => {
     jest.useFakeTimers();
     const running = job("running");
@@ -289,7 +347,7 @@ test("current indexing attention is counted once and maintenance plans respect t
         ([method]) => method === "memoryPlanViewMaintenance",
     );
     expect(plans.map(([, params]) => params.viewIds.length)).toEqual([25]);
-    expect(onAttentionCount).toHaveBeenLastCalledWith(2);
+    expect(onAttentionCount).toHaveBeenLastCalledWith(1, true);
     expect(attention.textContent).toContain(
         "Indexing failed: Indexer unavailable",
     );
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts
index 6faf2ffb9c..7c4a547a33 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts
@@ -12,6 +12,7 @@ import type {
 } from "@typeagent/memory-service";
 import { invokeMemory } from "./viewClient";
 import { MemoryHubInventoryPager } from "./memoryHubInventoryPager";
+import type { InboxAttentionCard } from "./memoryHubInbox";
 import {
     rbButton,
     rbChip,
@@ -79,7 +80,9 @@ export function mountMemoryHubViewActivity(
             revisionId?: string,
         ) => void;
         onOpenBuild: (corpusId: string, jobId: string) => void;
-        onAttentionCount?: (count: number) => void;
+        onAttentionCount?: (count: number, hasMore?: boolean) => void;
+        onAttentionError?: (error: unknown) => void;
+        presentAttention?: (card: InboxAttentionCard) => HTMLElement;
     },
 ) {
     const root = rbNode("section", undefined, "hub-view-activity");
@@ -104,6 +107,7 @@ export function mountMemoryHubViewActivity(
             await operation();
         } catch (error) {
             status.textContent = `View activity unavailable: ${rbError(error)}`;
+            if (!visible) options.onAttentionError?.(error);
             options.onError(error);
         }
     }
@@ -155,6 +159,7 @@ export function mountMemoryHubViewActivity(
                         : "Preview update";
                 Object.assign(card.dataset, {
                     group: `${corpusName} · ${reason}`,
+                    summary: reason,
                     title: view.content.title,
                     label,
                     corpusId,
@@ -341,12 +346,19 @@ export function mountMemoryHubViewActivity(
         current: number,
     ): Promise<boolean> {
         if (result.conflictId) {
-            const conflict = await invokeMemory("memoryGetViewConflict", {
-                corpusId: corpus.corpusId,
-                conflictId: result.conflictId,
-            });
-            if (disposed || current !== sequence) return false;
-            if (!conflict || conflict.state === "resolved") return true;
+            if (
+                result.conflictState === "resolved" ||
+                result.conflictState === "missing"
+            )
+                return true;
+            if (result.conflictState === undefined) {
+                const conflict = await invokeMemory("memoryGetViewConflict", {
+                    corpusId: corpus.corpusId,
+                    conflictId: result.conflictId,
+                });
+                if (disposed || current !== sequence) return false;
+                if (!conflict || conflict.state === "resolved") return true;
+            }
         }
         const item = rbNode("article", undefined, "card");
         item.append(
@@ -360,7 +372,13 @@ export function mountMemoryHubViewActivity(
                         : options.onOpenBuild(corpus.corpusId, job.jobId),
             ),
         );
-        attentionHost.append(item);
+        attentionHost.append(
+            options.presentAttention?.({
+                title: `${resultTitle(result)} · ${states[result.state]}`,
+                summary: result.reason,
+                detail: item,
+            }) ?? item,
+        );
         return true;
     }
 
@@ -385,6 +403,7 @@ export function mountMemoryHubViewActivity(
             bucket.forEach((entry) => collapsed.add(entry));
             const card = rbNode("article", undefined, "card");
             card.dataset.entries = String(bucket.length);
+            card.dataset.summary = alert.dataset.summary;
             const rows = rbNode("div", undefined, "hub-rows");
             card.append(
                 rbNode("h4", `${bucket.length} views need attention`),
@@ -424,7 +443,19 @@ export function mountMemoryHubViewActivity(
         let running = false;
         const seen = new Set<string>();
         for (const { corpus, jobs, alerts } of groups) {
-            attentionHost.append(...collapseAlerts(alerts));
+            attentionHost.append(
+                ...collapseAlerts(alerts).map(
+                    (card) =>
+                        options.presentAttention?.({
+                            title:
+                                card.querySelector("h4")?.textContent ??
+                                "View attention",
+                            summary: card.dataset.summary ?? "",
+                            entries: Number(card.dataset.entries ?? 1),
+                            detail: card,
+                        }) ?? card,
+                ),
+            );
             const ordered = [...jobs].sort((a, b) =>
                 b.updatedAt.localeCompare(a.updatedAt),
             );
@@ -539,15 +570,10 @@ export function mountMemoryHubViewActivity(
         status.textContent = total
             ? `Showing ${total} of ${jobPager.total} view operations`
             : "No view builds yet.";
-        options.onAttentionCount?.(
-            [...attentionHost.children].reduce(
-                (sum, child) =>
-                    sum + Number((child as HTMLElement).dataset.entries ?? 1),
-                0,
-            ) +
-                Number(
-                    !visible && (attentionPager.hasNext || jobPager.hasNext),
-                ),
+        const attentionCount = [...attentionHost.children].reduce(
+            (sum, child) =>
+                sum + Number((child as HTMLElement).dataset.entries ?? 1),
+            0,
         );
         if (visible)
             list.append(
@@ -573,6 +599,10 @@ export function mountMemoryHubViewActivity(
                 "Current view and build issues in this scope. The filters above apply to source and guide notifications.";
             attentionHost.prepend(heading);
         }
+        options.onAttentionCount?.(
+            attentionCount,
+            !visible && (attentionPager.hasNext || jobPager.hasNext),
+        );
         if (selected) {
             const job = await invokeMemory("memoryGetViewBuild", selected);
             if (disposed || current !== sequence) return;
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts
index 3442105064..7b47998550 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts
@@ -69,9 +69,21 @@ async function settle() {
     for (let index = 0; index < 30; index++) await Promise.resolve();
 }
 function click(host: HTMLElement, label: string) {
-    const button = [...host.querySelectorAll("button")].find(
-        (button) => button.textContent === label,
-    );
+    const find = () =>
+        [...host.querySelectorAll("button")].find(
+            (button) =>
+                button.textContent === label ||
+                button.getAttribute("aria-label") === label,
+        );
+    let button = find();
+    if (!button) {
+        host
+            .querySelector<HTMLButtonElement>(
+                '.hub-view-actions button[aria-haspopup="menu"]',
+            )
+            ?.click();
+        button = find();
+    }
     if (!button) throw new Error(`Missing button ${label}`);
     for (
         let parent = button.parentElement;
@@ -268,6 +280,247 @@ describe("Memory Center preview-first views", () => {
         click(host, "Compare and resolve conflict");
         await settle();
     }
+    test("gallery puts tabs before its white list card and shows the server total, not the loaded count", async () => {
+        const original = invoke.getMockImplementation()!;
+        invoke.mockImplementation(async (method, params) => {
+            const result = await original(method, params);
+            return method === "memoryListViewSummaries" &&
+                result &&
+                typeof result === "object"
+                ? {
+                      ...result,
+                      total: 85,
+                      wikiFamily: {
+                          enabled: true,
+                          pending: true,
+                          error: "Maintenance unavailable",
+                      },
+                  }
+                : result;
+        });
+        await panel.refresh();
+        const card = host.querySelector('[aria-label="Views list"]')!;
+        expect(card.classList).toContain("card");
+        expect(card.previousElementSibling!.getAttribute("aria-label")).toBe(
+            "Filter view type",
+        );
+        expect(card.querySelector(".hub-list-total")!.textContent).toBe(
+            "85 total",
+        );
+        expect(card.querySelectorAll(".hub-view-card")).toHaveLength(1);
+        expect(card.querySelector('[role="alert"]')!.textContent).toContain(
+            "Wiki retry needed: Maintenance unavailable",
+        );
+        expect(card.lastElementChild!.getAttribute("aria-label")).toBe(
+            "views pages",
+        );
+        expect(host.querySelector(".hub-draft-views > h3")).toBeNull();
+        expect(host.textContent).not.toContain("Read reusable documents");
+        expect(host.textContent).not.toContain("saved views across");
+    });
+    test.each(["empty", "failure"])(
+        "type tabs show loading inside the card until an %s result settles",
+        async (outcome) => {
+            await panel.refresh();
+            const original = invoke.getMockImplementation()!;
+            let resolve!: (value: unknown) => void;
+            let reject!: (error: Error) => void;
+            invoke.mockImplementation((method, params) =>
+                method === "memoryListViewSummaries"
+                    ? new Promise((done, fail) => {
+                          resolve = done;
+                          reject = fail;
+                      })
+                    : original(method, params),
+            );
+            click(host, "Knowledge Wiki");
+            await settle();
+            const pending = host.querySelector('[aria-label="Views list"]')!;
+            expect(pending.getAttribute("aria-busy")).toBe("true");
+            expect(
+                pending.querySelector<HTMLElement>(".hub-view-list-loading")!
+                    .hidden,
+            ).toBe(false);
+            expect(
+                pending.querySelector(".hub-view-list-loading i")!.classList,
+            ).toContain("fa-solid");
+            expect(
+                pending.querySelector<HTMLElement>(".hub-view-list")!.hidden,
+            ).toBe(true);
+            expect(
+                pending.querySelector<HTMLElement>(".hub-pager")!.hidden,
+            ).toBe(true);
+            expect(pending.querySelector(".hub-list-total")!.textContent).toBe(
+                "Loading...",
+            );
+            if (outcome === "empty") resolve({ head, total: 0, items: [] });
+            else reject(new Error("Inventory unavailable"));
+            await settle();
+            const settled = host.querySelector('[aria-label="Views list"]')!;
+            expect(settled.getAttribute("aria-busy")).toBe("false");
+            expect(
+                settled.querySelector<HTMLElement>(".hub-view-list-loading")!
+                    .hidden,
+            ).toBe(true);
+            if (outcome === "empty") {
+                expect(
+                    settled.querySelector(".hub-list-total")!.textContent,
+                ).toBe("0 total");
+                expect(
+                    settled.querySelector<HTMLElement>(".hub-view-list")!
+                        .hidden,
+                ).toBe(false);
+            } else {
+                expect(host.textContent).toContain("Inventory unavailable");
+                expect(
+                    settled.querySelector(".hub-list-total")!.textContent,
+                ).toBe("Unavailable");
+                expect(
+                    settled.querySelector<HTMLElement>(".hub-view-list")!
+                        .hidden,
+                ).toBe(true);
+            }
+        },
+    );
+    test("rapid type changes queue the latest filter without showing a stale empty result", async () => {
+        await panel.refresh();
+        const original = invoke.getMockImplementation()!;
+        const pending: Array<(value: unknown) => void> = [];
+        invoke.mockImplementation((method, params) =>
+            method === "memoryListViewSummaries"
+                ? new Promise((resolve) => pending.push(resolve))
+                : original(method, params),
+        );
+        click(host, "Knowledge Wiki");
+        await settle();
+        expect(pending).toHaveLength(1);
+        click(host, "Project Brief");
+        await settle();
+        expect(pending).toHaveLength(1);
+        pending[0]({ head, total: 0, items: [] });
+        await settle();
+        expect(pending).toHaveLength(2);
+        expect(invoke).toHaveBeenLastCalledWith(
+            "memoryListViewSummaries",
+            expect.objectContaining({ kind: "projectBrief" }),
+        );
+        expect(
+            host
+                .querySelector('[aria-label="Views list"]')!
+                .getAttribute("aria-busy"),
+        ).toBe("true");
+        pending[1]({ head, total: 0, items: [] });
+        await settle();
+        expect(
+            host
+                .querySelector('[aria-label="Views list"]')!
+                .getAttribute("aria-busy"),
+        ).toBe("false");
+        expect(host.querySelector('[aria-pressed="true"]')!.textContent).toBe(
+            "Project Brief",
+        );
+        expect(errors).toEqual([]);
+    });
+    test("type tabs use the requested labels and order independently of service capability order", async () => {
+        const original = invoke.getMockImplementation()!;
+        invoke.mockImplementation((method, params) =>
+            method === "memoryViewCapabilities"
+                ? Promise.resolve({
+                      derivedViews: {
+                          builds: true,
+                          informationalWiki: true,
+                          kinds: [
+                              "timeline",
+                              "troubleshootingGuide",
+                              "schemaView",
+                              "projectBrief",
+                              "wiki",
+                          ],
+                      },
+                  })
+                : original(method, params),
+        );
+        await panel.refresh();
+        const tabs = host.querySelector('[aria-label="Filter view type"]')!;
+        expect(
+            host.querySelector('button[aria-label="Maintain collection"] i')!
+                .className,
+        ).toBe("fa-solid fa-screwdriver-wrench");
+        click(host, "Maintain collection");
+        const maintenanceItems = host.querySelectorAll('[role="menuitem"]');
+        expect(maintenanceItems).toHaveLength(8);
+        for (const item of maintenanceItems)
+            expect(item.querySelector("i")!.className).toBe(
+                "fa-solid fa-screwdriver-wrench",
+            );
+        click(host, "Maintain collection");
+        expect(
+            [...tabs.querySelectorAll("button")].map((tab) => tab.textContent),
+        ).toEqual([
+            "All",
+            "Knowledge Wiki",
+            "Project Brief",
+            "Timeline",
+            "Troubleshooting Guide",
+        ]);
+        click(host, "Project Brief");
+        await settle();
+        expect(invoke).toHaveBeenCalledWith(
+            "memoryListViewSummaries",
+            expect.objectContaining({ kind: "projectBrief" }),
+        );
+        expect(
+            host.querySelector(
+                '[aria-label="Filter view type"] [aria-pressed="true"]',
+            )!.textContent,
+        ).toBe("Project Brief");
+    });
+
+    test("view type tabs preserve filtering, search, scroll position and keyboard focus across refresh", async () => {
+        await panel.refresh();
+        const kinds = host.querySelector<HTMLElement>(
+            '[aria-label="Filter view type"]',
+        )!;
+        expect(kinds.classList).toContain("hub-tabs");
+        expect(kinds.querySelectorAll('i[aria-hidden="true"]')).toHaveLength(5);
+        kinds.scrollLeft = 120;
+        const wiki = [...kinds.querySelectorAll("button")].find(
+            (tab) => tab.textContent === "Knowledge Wiki",
+        )!;
+        wiki.focus();
+        wiki.click();
+        await settle();
+        expect(invoke).toHaveBeenCalledWith(
+            "memoryListViewSummaries",
+            expect.objectContaining({ kind: "wiki" }),
+        );
+        const refreshed = host.querySelector<HTMLElement>(
+            '[aria-label="Filter view type"]',
+        )!;
+        expect(refreshed.scrollLeft).toBe(120);
+        expect(
+            refreshed.querySelectorAll('[aria-pressed="true"]'),
+        ).toHaveLength(1);
+        expect(document.activeElement).toBe(
+            refreshed.querySelector('[aria-pressed="true"]'),
+        );
+        expect(host.textContent).toContain("No views match.");
+        const search = host.querySelector<HTMLInputElement>(
+            '[aria-label="Find views"]',
+        )!;
+        search.value = "Guide";
+        search.dispatchEvent(new Event("input"));
+        click(host, "All");
+        await settle();
+        expect(
+            host.querySelector<HTMLInputElement>('[aria-label="Find views"]')!
+                .value,
+        ).toBe("Guide");
+        expect(host.querySelector(".hub-view-card")!.textContent).toContain(
+            "Guide",
+        );
+        expect(errors).toEqual([]);
+    });
     test("gallery shows an accessible spinner before capabilities or inventory finish", async () => {
         const original = invoke.getMockImplementation()!;
         let releaseCapabilities!: (value: unknown) => void;
@@ -397,7 +650,7 @@ describe("Memory Center preview-first views", () => {
         );
         expect(
             [...host.querySelectorAll("button")].some(
-                (button) => button.textContent === "Edit",
+                (button) => button.getAttribute("aria-label") === "Edit",
             ),
         ).toBe(false);
         resolve({ head, total: 0, items: [] });
@@ -405,7 +658,7 @@ describe("Memory Center preview-first views", () => {
         expect(host.querySelector(".hub-view-document")).toBe(article);
         expect(
             [...host.querySelectorAll("button")].some(
-                (button) => button.textContent === "Edit",
+                (button) => button.getAttribute("aria-label") === "Edit",
             ),
         ).toBe(true);
         expect(errors).toEqual([]);
@@ -449,7 +702,7 @@ describe("Memory Center preview-first views", () => {
         );
         expect(
             [...host.querySelectorAll("button")].some(
-                (button) => button.textContent === "Edit",
+                (button) => button.getAttribute("aria-label") === "Edit",
             ),
         ).toBe(false);
         expect(errors).toHaveLength(1);
@@ -516,6 +769,7 @@ describe("Memory Center preview-first views", () => {
             "View revision unavailable",
         );
         expect(host.querySelector(".hub-view-document")).toBeNull();
+        expect(host.textContent).not.toContain("Loading view details...");
         click(host, "Back to views");
         await settle();
         expect(navigate).toHaveBeenLastCalledWith("#/views");
@@ -567,7 +821,9 @@ describe("Memory Center preview-first views", () => {
         expect(host.querySelector(".hub-view-document img")).toBeNull();
         expect(host.querySelector("textarea")).toBeNull();
         expect(navigate).toHaveBeenCalledWith("#/views/c/guide");
-        expect(host.querySelector("h2")!.textContent).toBe("Guide");
+        expect(host.querySelector(".hub-view-document h2")!.textContent).toBe(
+            "Guide",
+        );
         click(host, "Edit");
         expect(
             host.querySelector('[aria-label="Troubleshooting guide editor"]'),
@@ -602,7 +858,83 @@ describe("Memory Center preview-first views", () => {
         expect(host.textContent).toContain(summary);
         expect(content).not.toHaveProperty("summary");
     });
-    test("reader keeps only Back and Edit direct and disclosure actions retain keyboard and dialog focus", async () => {
+
+    test.each([
+        {
+            summary: "A **grounded** synopsis",
+            coverageNote: "Partial evidence",
+        },
+        { summary: undefined, coverageNote: "Partial evidence" },
+        { summary: undefined, coverageNote: undefined },
+    ])(
+        "wiki infobox separates synopsis, coverage and metadata from article: %o",
+        async (overview) => {
+            const original = invoke.getMockImplementation()!;
+            const wiki = {
+                ...view,
+                createdAt: "2026-10-13T16:00:00Z",
+                content: {
+                    ...content,
+                    ...overview,
+                    kind: "wiki",
+                    status: "sufficient",
+                    citations: [
+                        { sourceId: "s", revisionId: "r", locator: "f3" },
+                    ],
+                },
+                definition: { ...definition, kind: "wiki" },
+            };
+            invoke.mockImplementation(
+                inventoryFixture((method, params) =>
+                    method === "memoryListViews"
+                        ? Promise.resolve({ ...snapshot, views: [wiki] })
+                        : original(method, params),
+                ),
+            );
+            await panel.refresh();
+            click(host, "Guide");
+            await settle();
+            const article = host.querySelector(".hub-view-document")!;
+            const flow = article.querySelector(".hub-view-reading-flow")!;
+            const infobox = flow.querySelector("aside")!;
+            expect(infobox.getAttribute("aria-label")).toBe(
+                "About this article",
+            );
+            expect(infobox.querySelector("h3")!.textContent).toBe(
+                overview.summary ? "Synopsis" : "About this article",
+            );
+            expect(infobox.textContent).toContain("Version 1");
+            expect(infobox.textContent).toContain("Completeness: sufficient");
+            expect(infobox.querySelector("time")!.dateTime).toBe(
+                "2026-10-13T16:00:00.000Z",
+            );
+            expect(infobox.querySelector(".hub-view-lead")?.textContent).toBe(
+                overview.summary ? "A grounded synopsis\n" : undefined,
+            );
+            expect(infobox.querySelector(".hub-view-note")?.textContent).toBe(
+                overview.coverageNote
+                    ? "Coverage: Partial evidence"
+                    : undefined,
+            );
+            expect(infobox.querySelector(".hub-view-section")).toBeNull();
+            expect(
+                flow.querySelector(".hub-view-section strong")!.textContent,
+            ).toBe("body");
+            expect(article.querySelector("script, img")).toBeNull();
+            const sources = [...article.children].find(
+                (element) => element.tagName === "DETAILS",
+            )!;
+            expect(sources.querySelector("summary")!.textContent).toBe(
+                "Sources (1)",
+            );
+            expect(
+                sources.querySelector("button")?.getAttribute("aria-label"),
+            ).toBe("Open exact evidence s");
+            expect(errors).toEqual([]);
+        },
+    );
+
+    test("reader icon toolbar opens an icon-and-text menu and restores keyboard and dialog focus", async () => {
         await panel.refresh();
         click(host, "Guide");
         await settle();
@@ -610,16 +942,27 @@ describe("Memory Center preview-first views", () => {
         expect(
             [...toolbar.children]
                 .filter((child) => child.tagName === "BUTTON")
-                .map((button) => button.textContent),
+                .map((button) => button.getAttribute("aria-label")),
         ).toEqual(["Back to views", "Edit"]);
-        const more = toolbar.querySelector<HTMLDetailsElement>(
-            ".hub-view-more-actions",
+        for (const button of toolbar.querySelectorAll(":scope > button")) {
+            expect(button.textContent).toBe("");
+            expect(
+                button.querySelector('i[aria-hidden="true"]'),
+            ).not.toBeNull();
+            expect(button.getAttribute("title")).toBe(
+                button.getAttribute("aria-label"),
+            );
+        }
+        const trigger = toolbar.querySelector<HTMLButtonElement>(
+            'button[aria-label="More actions"]',
         )!;
-        const summary = more.querySelector("summary")!;
-        expect(summary.textContent).toBe("More actions");
-        expect(more.open).toBe(false);
+        expect(trigger.getAttribute("aria-haspopup")).toBe("menu");
+        expect(trigger.getAttribute("aria-expanded")).toBe("false");
+        expect(toolbar.querySelector('[role="menu"]')).toBeNull();
+        trigger.click();
+        const menu = toolbar.querySelector('[role="menu"]')!;
         expect(
-            [...more.querySelectorAll("button")].map(
+            [...menu.querySelectorAll('[role="menuitem"]')].map(
                 (button) => button.textContent,
             ),
         ).toEqual([
@@ -628,10 +971,10 @@ describe("Memory Center preview-first views", () => {
             "History",
             "Update view",
         ]);
-        summary.focus();
-        summary.click();
-        expect(more.open).toBe(true);
-        const publication = [...more.querySelectorAll("button")].find(
+        for (const item of menu.querySelectorAll('[role="menuitem"]'))
+            expect(item.querySelector('i[aria-hidden="true"]')).not.toBeNull();
+        expect(document.activeElement).toBe(menu.querySelector("button"));
+        const publication = [...menu.querySelectorAll("button")].find(
             (button) => button.textContent === "Publication and search",
         )!;
         publication.focus();
@@ -642,16 +985,16 @@ describe("Memory Center preview-first views", () => {
                 cancelable: true,
             }),
         );
-        expect(more.open).toBe(false);
-        expect(document.activeElement).toBe(summary);
-        summary.click();
-        publication.focus();
-        publication.click();
+        expect(toolbar.querySelector('[role="menu"]')).toBeNull();
+        expect(document.activeElement).toBe(trigger);
+        trigger.click();
+        click(host, "Publication and search");
         await settle();
+        expect(toolbar.querySelector('[role="menu"]')).toBeNull();
+        expect(trigger.getAttribute("aria-expanded")).toBe("false");
         expect(document.activeElement?.tagName).toBe("DIALOG");
         click(host, "Close");
-        expect(document.activeElement).toBe(publication);
-        expect(more.open).toBe(true);
+        expect(document.activeElement).toBe(trigger);
     });
     test("All memory browsing isolates identical IDs by collection and build collection choice stays in the flow", async () => {
         scope = undefined;
@@ -1212,6 +1555,7 @@ describe("Memory Center preview-first views", () => {
         );
         await panel.show({ corpusId: "c", viewId: "guide" });
         expect(host.querySelector("textarea")).toBeNull();
+        click(host, "More actions");
         expect(host.textContent).toContain("Review pending conflict");
         expect(invoke).toHaveBeenCalledWith("memoryGetViewConflict", {
             corpusId: "c",
@@ -1245,6 +1589,7 @@ describe("Memory Center preview-first views", () => {
             'button[aria-label^="Latest build"]',
         )!;
         expect(latest.textContent).toBe("");
+        expect(latest.querySelector("i")!.className).toBe("fa-solid fa-bell");
         expect(host.querySelector(".hub-view-build-receipt")).toBeNull();
         expect(host.textContent).not.toContain(job.jobId);
         latest.click();
@@ -1281,6 +1626,51 @@ describe("Memory Center preview-first views", () => {
         expect(host.querySelector("textarea")).toBeNull();
         expect(errors).toEqual([]);
     });
+    test.each(["pending", "resolved"] as const)(
+        "reader uses %s conflict summary without fetching evidence until resolution is opened",
+        async (conflictState) => {
+            const original = invoke.getMockImplementation()!;
+            invoke.mockImplementation((method, params) =>
+                method === "memoryListViewBuildSummaries"
+                    ? Promise.resolve({
+                          total: 1,
+                          items: [
+                              {
+                                  ...job,
+                                  maintenance: false,
+                                  results: [
+                                      {
+                                          ...job.results[0],
+                                          current: true,
+                                          conflictState,
+                                      },
+                                  ],
+                              },
+                          ],
+                      })
+                    : original(method, params),
+            );
+            await panel.show({ corpusId: "c", viewId: "guide" });
+            click(host, "More actions");
+            expect(host.textContent?.includes("Review pending conflict")).toBe(
+                conflictState === "pending",
+            );
+            expect(
+                invoke.mock.calls.some(
+                    ([method]) => method === "memoryGetViewConflict",
+                ),
+            ).toBe(false);
+            expect(errors).toEqual([]);
+            if (conflictState === "pending") {
+                click(host, "Review pending conflict");
+                await settle();
+                expect(invoke).toHaveBeenCalledWith("memoryGetViewConflict", {
+                    corpusId: "c",
+                    conflictId: job.results[0].conflictId,
+                });
+            }
+        },
+    );
     test("late source response cannot render after scope switch or disposal", async () => {
         await panel.refresh();
         const original = invoke.getMockImplementation()!;
@@ -1347,7 +1737,7 @@ describe("Memory Center preview-first views", () => {
         expect(host.querySelector("textarea")).toBeNull();
         expect(
             [...host.querySelectorAll("button")].some(
-                (button) => button.textContent === "Edit",
+                (button) => button.getAttribute("aria-label") === "Edit",
             ),
         ).toBe(false);
         expect(errors).toEqual([]);
@@ -1376,7 +1766,7 @@ describe("Memory Center preview-first views", () => {
         expect(host.textContent).toContain("Exact revision (read-only)");
         expect(
             [...host.querySelectorAll("button")].some(
-                (button) => button.textContent === "Edit",
+                (button) => button.getAttribute("aria-label") === "Edit",
             ),
         ).toBe(false);
         click(host, "Open current view");
@@ -1384,7 +1774,7 @@ describe("Memory Center preview-first views", () => {
         expect(navigate).toHaveBeenCalledWith("#/views/c/guide");
         expect(
             [...host.querySelectorAll("button")].some(
-                (button) => button.textContent === "Edit",
+                (button) => button.getAttribute("aria-label") === "Edit",
             ),
         ).toBe(true);
     });
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts
index 212b4f5d29..0fc88379ce 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts
@@ -26,7 +26,13 @@ import {
     rbNode,
     rbMarkdown,
 } from "./memoryHubDocumentUi";
-import { icon, menuButton, setIconButton, type MenuItem } from "./memoryHubUi";
+import {
+    icon,
+    menuButton,
+    setIconButton,
+    setTabLabel,
+    type MenuItem,
+} from "./memoryHubUi";
 import { mountFlyout } from "./memoryHubFlyout";
 import { viewRevisionTime, viewSheet } from "./memoryHubViewUi";
 import {
@@ -70,6 +76,53 @@ function appendArticleCoverage(
         );
 }
 
+function appendArticleIntroduction(
+    article: HTMLElement,
+    view: ViewVersion,
+    meta: HTMLElement,
+): HTMLElement {
+    const hasInfobox =
+        view.content.kind === "wiki" || view.content.kind === "projectBrief";
+    const overviewLabel =
+        view.content.kind === "projectBrief"
+            ? "About this brief"
+            : "About this article";
+    const flow = hasInfobox
+        ? rbNode("div", undefined, "hub-view-reading-flow")
+        : article;
+    const overview = hasInfobox
+        ? rbNode("aside", undefined, "hub-view-infobox")
+        : article;
+    if (hasInfobox) {
+        overview.setAttribute("aria-label", overviewLabel);
+        overview.append(
+            rbNode("h3", view.content.summary ? "Synopsis" : overviewLabel),
+            rbNode(
+                "p",
+                view.content.kind === "projectBrief"
+                    ? "Brief overview"
+                    : "Article overview",
+                "hub-view-infobox-label",
+            ),
+        );
+    } else {
+        overview.append(meta);
+        appendArticleCoverage(overview, view.content);
+    }
+    if (view.content.summary) {
+        const lead = rbMarkdown(view.content.summary);
+        lead.classList.add("hub-view-lead");
+        overview.append(lead);
+    }
+    if (hasInfobox) {
+        appendArticleCoverage(overview, view.content);
+        overview.append(meta);
+        flow.append(overview);
+        article.append(flow);
+    }
+    return flow;
+}
+
 const viewKindLabels: Record<ViewKind, string> = {
     wiki: "Knowledge wiki",
     timeline: "Evidence-linked timeline",
@@ -78,6 +131,22 @@ const viewKindLabels: Record<ViewKind, string> = {
     schemaView: "Schema-defined questions",
 };
 
+const viewKindIcons: Record<ViewKind, string> = {
+    wiki: "fa-book-open",
+    timeline: "fa-timeline",
+    projectBrief: "fa-diagram-project",
+    troubleshootingGuide: "fa-screwdriver-wrench",
+    schemaView: "fa-table-list",
+};
+
+const viewTypeTabs: { kind?: ViewKind; label: string }[] = [
+    { label: "All" },
+    { kind: "wiki", label: "Knowledge Wiki" },
+    { kind: "projectBrief", label: "Project Brief" },
+    { kind: "timeline", label: "Timeline" },
+    { kind: "troubleshootingGuide", label: "Troubleshooting Guide" },
+];
+
 function publicationDescription(
     publication: ViewPublicationStatus | undefined,
 ): string {
@@ -152,7 +221,10 @@ function publicationChoice(label: string, inherit: boolean): HTMLSelectElement {
 function viewLoadingStatus(label: string): HTMLParagraphElement {
     const status = rbNode("p", label, "hub-view-loading");
     status.setAttribute("role", "status");
-    status.prepend(icon("fa-spinner fa-spin"), document.createTextNode(" "));
+    status.prepend(
+        icon("fa-solid fa-spinner fa-spin"),
+        document.createTextNode(" "),
+    );
     return status;
 }
 
@@ -178,31 +250,28 @@ export function mountMemoryHubViews(
     root.setAttribute("aria-label", "Derived views");
     const status = rbNode("p");
     status.setAttribute("role", "status");
+    const total = rbNode("span", "Loading...", "hub-list-total");
+    const familyNotice = rbNode("div", undefined, "hub-notice");
+    familyNotice.setAttribute("role", "alert");
+    familyNotice.hidden = true;
     const loading = viewLoadingStatus("Loading views...");
     loading.hidden = true;
+    const listLoading = viewLoadingStatus("Loading views...");
+    listLoading.classList.add("hub-view-list-loading");
+    listLoading.hidden = true;
     const controls = rbNode("div", undefined, "hub-view-controls");
     const receipt = rbNode("div", undefined, "hub-view-build-receipt");
     let flyout: ReturnType<typeof mountFlyout> | undefined;
     let latestJob:
         | Pick<ViewBuildJob, "corpusId" | "state" | "jobId">
         | undefined;
-    const latestBuild = rbIconButton("fa-list-check", "Latest build", () =>
+    const latestBuild = rbIconButton("fa-bell", "Latest build", () =>
         openLatestBuild(),
     );
     latestBuild.hidden = true;
     const drafts = rbNode("div");
     const comparison = rbNode("div");
-    root.append(
-        rbNode("h3", "Views"),
-        rbNode(
-            "p",
-            "Read reusable documents built from your memory. Choose a view to preview it, or build new views from ready evidence.",
-        ),
-        loading,
-        status,
-        drafts,
-        comparison,
-    );
+    root.append(loading, status, drafts, comparison);
     host.append(root);
     let snapshot: ViewSnapshot = { head: null, views: [] };
     let inventory: ViewSummary[] = [];
@@ -216,12 +285,17 @@ export function mountMemoryHubViews(
         views: {},
     };
     const publications = new Map<string, ViewPublicationStatus>();
-    const pendingConflicts = new Map<string, ViewMergeConflict>();
+    const pendingConflicts = new Map<string, string>();
     let sequence = 0;
     let timer: ReturnType<typeof setTimeout> | undefined;
     let dirty = false;
     let busy = false;
     let refreshPending = false;
+    type InventoryState = "loading" | "ready" | "error";
+    let inventoryState: InventoryState = "ready";
+    let inventoryElements:
+        | { card: HTMLElement; list: HTMLElement; pager: HTMLElement }
+        | undefined;
     let disposed = false;
     let detailRequest:
         | { key: string; sequence: number; work: Promise<void> }
@@ -295,12 +369,37 @@ export function mountMemoryHubViews(
         }
     }
 
+    function setInventoryState(state: InventoryState): void {
+        inventoryState = state;
+        listLoading.hidden = state !== "loading";
+        if (!inventoryElements) return;
+        inventoryElements.card.setAttribute(
+            "aria-busy",
+            String(state === "loading"),
+        );
+        inventoryElements.list.hidden = state !== "ready";
+        inventoryElements.pager.hidden = state !== "ready";
+    }
+
     async function refresh(): Promise<void> {
         const current = ++sequence;
-        loading.hidden = false;
+        loading.hidden = !!(
+            inventoryElements &&
+            drafts.contains(inventoryElements.card) &&
+            !drafts.hidden
+        );
+        setInventoryState("loading");
         status.textContent = "";
+        total.textContent = "Loading...";
         try {
             await refreshInventory(current);
+            if (current === sequence) setInventoryState("ready");
+        } catch (error) {
+            if (current === sequence) {
+                total.textContent = "Unavailable";
+                setInventoryState("error");
+            }
+            throw error;
         } finally {
             if (current === sequence) loading.hidden = true;
         }
@@ -395,7 +494,13 @@ export function mountMemoryHubViews(
                 void action(refresh);
             }),
             ...(maintenance.length
-                ? [menuButton("Maintain collection", maintenance, "fa-gear")]
+                ? [
+                      menuButton(
+                          "Maintain collection",
+                          maintenance,
+                          "fa-screwdriver-wrench",
+                      ),
+                  ]
                 : []),
             latestBuild,
         );
@@ -413,8 +518,9 @@ export function mountMemoryHubViews(
                 "Projects",
             ),
         ]);
+        familyNotice.textContent = familyStatus.join(" ");
+        familyNotice.hidden = !familyStatus.length;
         renderDrafts();
-        status.textContent += familyStatus.join(" ");
         if (jobs[0]) setLatest(jobs[0]);
         else clearReceipt();
 
@@ -423,9 +529,9 @@ export function mountMemoryHubViews(
             family: ViewSnapshot["wikiFamily"],
             label = "Wiki",
         ): string[] {
-            if (!family) return [];
+            if (!family?.error) return [];
             return [
-                `${corpusNames.get(corpusId) ?? corpusId}: ${label} ${family.enabled ? "automatic" : "paused"}; ${family.pending ? "bounded work pending" : "up to date"}${family.error ? `; retry needed: ${family.error}` : ""}.`,
+                `${corpusNames.get(corpusId) ?? corpusId}: ${label} retry needed: ${family.error}.`,
             ];
         }
 
@@ -435,17 +541,11 @@ export function mountMemoryHubViews(
             derivedViews?: { informationalWiki?: true };
         }): MenuItem[] {
             if (!capabilities.derivedViews?.informationalWiki) return [];
-            const glyphs = {
-                update: "fa-arrows-rotate",
-                rebuild: "fa-rotate-right",
-                pause: "fa-pause",
-                resume: "fa-play",
-            } as const;
             return (["wiki", "projects"] as const).flatMap((family) =>
                 (["update", "rebuild", "pause", "resume"] as const).map(
                     (operation): MenuItem => ({
                         label: `${operation[0].toUpperCase()}${operation.slice(1)} ${family === "wiki" ? "Wiki" : "Projects"}`,
-                        icon: glyphs[operation],
+                        icon: "fa-screwdriver-wrench",
                         action: () => {
                             void action(async () => {
                                 const corpusId = options.scope();
@@ -474,9 +574,6 @@ export function mountMemoryHubViews(
                 ),
             );
         }
-        status.textContent = pager.total
-            ? `Showing ${inventory.length} of ${pager.total} saved views${corpusId ? "" : " across your collections"}.`
-            : "No views yet. Wiki pages and Projects are discovered automatically from indexed evidence. Update a collection family or build a timeline or guide.";
         if (route && !dirty) await renderRoute(route, current);
     }
 
@@ -486,38 +583,54 @@ export function mountMemoryHubViews(
     ): Promise<void> {
         const references = new Map<
             string,
-            { corpusId: string; conflictId: string }
+            {
+                corpusId: string;
+                conflictId: string;
+                state: ViewBuildSummary["results"][number]["conflictState"];
+            }
         >();
+        const seen = new Set<string>();
         const ordered = [...jobs].sort((left, right) =>
             (right.createdAt ?? "").localeCompare(left.createdAt ?? ""),
         );
         for (const job of ordered)
             for (const result of job.results) {
                 const key = publicationKey(job.corpusId, result.viewId);
-                if (result.conflictId && !references.has(key))
+                if (result.conflictId && !seen.has(key)) {
+                    seen.add(key);
+                    if (result.conflictState === "resolved") continue;
                     references.set(key, {
                         corpusId: job.corpusId,
                         conflictId: result.conflictId,
+                        state: result.conflictState,
                     });
+                }
             }
         const conflicts = await Promise.all(
             [...references].map(async ([key, input]) => {
-                const conflict = await invokeMemory(
-                    "memoryGetViewConflict",
-                    input,
-                );
+                if (input.state === "pending")
+                    return { key, conflictId: input.conflictId };
+                const conflict = await invokeMemory("memoryGetViewConflict", {
+                    corpusId: input.corpusId,
+                    conflictId: input.conflictId,
+                });
                 if (!conflict)
                     throw new Error(
                         "A conflict referenced by a build receipt is unavailable; refresh Activity or inspect view history",
                     );
-                return { key, conflict };
+                return {
+                    key,
+                    conflictId:
+                        conflict.state === "pending"
+                            ? conflict.conflictId
+                            : undefined,
+                };
             }),
         );
         if (disposed || current !== sequence) return;
         pendingConflicts.clear();
-        for (const { key, conflict } of conflicts)
-            if (conflict.state === "pending")
-                pendingConflicts.set(key, conflict);
+        for (const { key, conflictId } of conflicts)
+            if (conflictId) pendingConflicts.set(key, conflictId);
     }
 
     async function ensureReaderCapabilities(current: number): Promise<boolean> {
@@ -613,7 +726,7 @@ export function mountMemoryHubViews(
             comparison
                 .querySelector(".hub-view-actions")
                 ?.replaceChildren(
-                    rbButton("Back to views", backToViews),
+                    rbIconButton("fa-arrow-left", "Back to views", backToViews),
                     rbNode("p", "Structured page (read-only)"),
                 );
             return;
@@ -641,7 +754,7 @@ export function mountMemoryHubViews(
         comparison.querySelector(".hub-view-actions")?.replaceChildren(
             revisionLabel,
             rbNode("p", `Revision: ${view.revisionId}`),
-            rbButton("Back to views", backToViews),
+            rbIconButton("fa-arrow-left", "Back to views", backToViews),
             rbButton("Open current view", () => {
                 void showView(
                     view.corpusId,
@@ -707,7 +820,7 @@ export function mountMemoryHubViews(
         drafts.hidden = controls.hidden = true;
         comparison.setAttribute("aria-busy", "true");
         comparison.replaceChildren(
-            rbButton("Back to views", backToViews),
+            rbIconButton("fa-arrow-left", "Back to views", backToViews),
             viewLoadingStatus("Loading view details..."),
         );
         const work = renderRoute(target, current)
@@ -723,6 +836,7 @@ export function mountMemoryHubViews(
             })
             .finally(() => {
                 if (disposed || current !== sequence) return;
+                comparison.querySelector(".hub-view-loading")?.remove();
                 comparison.setAttribute("aria-busy", "false");
                 detailRequest = undefined;
             });
@@ -1305,7 +1419,7 @@ export function mountMemoryHubViews(
             latestBuild,
             job.state === "running"
                 ? "fa-solid fa-circle-notch fa-spin"
-                : "fa-list-check",
+                : "fa-bell",
             `Latest build: ${job.state}`,
         );
         latestBuild.classList.toggle(
@@ -1554,17 +1668,36 @@ export function mountMemoryHubViews(
 
     function renderDrafts(): void {
         if (dirty) return;
+        const previousTabs = drafts.querySelector<HTMLElement>(".hub-tabs");
+        const restoreTabFocus = previousTabs?.contains(document.activeElement);
+        const tabScroll = previousTabs?.scrollLeft ?? 0;
         const search = document.createElement("input");
         search.type = "search";
         search.setAttribute("aria-label", "Find views");
         search.placeholder = "Find views";
         search.value = searchQuery;
-        const kind = document.createElement("select");
-        kind.setAttribute("aria-label", "Filter view type");
-        kind.append(new Option("All view types", ""));
-        for (const value of supportedKinds)
-            kind.append(new Option(viewKindLabels[value], value));
-        kind.value = selectedKind ?? "";
+        const kinds = rbNode("div", undefined, "hub-tabs");
+        kinds.setAttribute("role", "group");
+        kinds.setAttribute("aria-label", "Filter view type");
+        for (const { kind: value, label } of viewTypeTabs) {
+            if (value && !supportedKinds.includes(value)) continue;
+            const tab = setTabLabel(
+                rbButton(label, () => {
+                    selectedKind = value;
+                    for (const other of kinds.querySelectorAll("button"))
+                        other.setAttribute(
+                            "aria-pressed",
+                            String(other === tab),
+                        );
+                    render();
+                    reload();
+                }),
+                value ? viewKindIcons[value] : "fa-layer-group",
+                label,
+            );
+            tab.setAttribute("aria-pressed", String(value === selectedKind));
+            kinds.append(tab);
+        }
         const list = rbNode("div", undefined, "hub-view-list");
         // Kind plus one publication chip; version and index detail belong to
         // the view's own page.
@@ -1586,7 +1719,7 @@ export function mountMemoryHubViews(
             const matches = inventory.filter(
                 (view) =>
                     supportedKinds.some((kind) => view.content.kind === kind) &&
-                    (!kind.value || view.content.kind === kind.value) &&
+                    (!selectedKind || view.content.kind === selectedKind) &&
                     view.content.title
                         .toLowerCase()
                         .includes(search.value.toLowerCase()),
@@ -1625,6 +1758,13 @@ export function mountMemoryHubViews(
         };
         const reload = () => {
             pager.reset();
+            if (busy) {
+                sequence++;
+                refreshPending = true;
+                setInventoryState("loading");
+                total.textContent = "Loading...";
+                return;
+            }
             void action(refresh);
         };
         search.oninput = () => {
@@ -1633,24 +1773,32 @@ export function mountMemoryHubViews(
             clearTimeout(searchTimer);
             searchTimer = setTimeout(reload, 250);
         };
-        kind.onchange = () => {
-            selectedKind = supportedKinds.find((value) => value === kind.value);
-            reload();
-        };
         const toolbar = rbNode("div", undefined, "hub-view-toolbar");
         toolbar.append(
             search,
-            kind,
             rbNode("span", undefined, "hub-spacer"),
             controls,
         );
-        drafts.replaceChildren(
-            toolbar,
-            list,
-            pager.controls("views", () => {
-                void action(refresh);
-            }),
-        );
+        const card = rbNode("section", undefined, "card hub-list-card");
+        card.setAttribute("aria-label", "Views list");
+        const cardHead = rbNode("div", undefined, "section-heading");
+        total.textContent = `${pager.total} total`;
+        total.title = `Showing ${inventory.length} loaded views.`;
+        cardHead.append(rbNode("h2", "Views"), total);
+        card.append(cardHead);
+        if (!familyNotice.hidden) card.append(familyNotice);
+        const pagination = pager.controls("views", () => {
+            void action(refresh);
+        });
+        card.append(toolbar, listLoading, list, pagination);
+        inventoryElements = { card, list, pager: pagination };
+        setInventoryState(inventoryState);
+        drafts.replaceChildren(kinds, card);
+        kinds.scrollLeft = tabScroll;
+        if (restoreTabFocus)
+            kinds
+                .querySelector<HTMLButtonElement>('[aria-pressed="true"]')
+                ?.focus({ preventScroll: true });
         render();
     }
 
@@ -1671,7 +1819,7 @@ export function mountMemoryHubViews(
     function appendEditorialControls(
         view: ViewVersion,
         article: HTMLElement,
-        more: HTMLElement,
+        more: MenuItem[],
     ): void {
         if (view.relatedArticles?.length) {
             const related = rbNode("nav", undefined, "hub-related");
@@ -1698,8 +1846,10 @@ export function mountMemoryHubViews(
         )
             return;
         for (const target of protectedTargets)
-            more.append(
-                rbButton(`Unlock generated updates: ${target}`, () => {
+            more.push({
+                label: `Unlock generated updates: ${target}`,
+                icon: "fa-lock-open",
+                action: () => {
                     void action(async () => {
                         if (!discardChanges()) return;
                         await invokeMemory("memorySaveViewDraft", {
@@ -1737,8 +1887,8 @@ export function mountMemoryHubViews(
                         await changed();
                         await refresh();
                     });
-                }),
-            );
+                },
+            });
     }
 
     function citationKey(citation: ViewCitation) {
@@ -1785,13 +1935,8 @@ export function mountMemoryHubViews(
             ...articleCompleteness(view.content),
         );
         meta.append(metaChips, ...viewRevisionTime(view.createdAt));
-        article.append(title, meta);
-        appendArticleCoverage(article, view.content);
-        if (view.content.summary) {
-            const lead = rbMarkdown(view.content.summary);
-            lead.classList.add("hub-view-lead");
-            article.append(lead);
-        }
+        article.append(title);
+        const readingFlow = appendArticleIntroduction(article, view, meta);
         if (view.content.kind === "schemaView") {
             const questions = rbNode(
                 "a",
@@ -1844,7 +1989,7 @@ export function mountMemoryHubViews(
                         else window.location.hash = destination;
                     }),
                 );
-            article.append(contents);
+            readingFlow.append(contents);
         }
         for (const section of view.content.sections) {
             const page = rbNode("section", undefined, "hub-view-section");
@@ -1888,7 +2033,7 @@ export function mountMemoryHubViews(
                 );
                 page.append(evidence);
             }
-            article.append(page);
+            readingFlow.append(page);
         }
         if (view.content.citations.length) {
             const citations = rbNode("details");
@@ -1901,8 +2046,11 @@ export function mountMemoryHubViews(
             article.append(citations);
         }
         const actions = rbNode("div", undefined, "hub-view-actions");
-        const back = rbButton("Back to views", backToViews);
-        back.prepend(icon("fa-arrow-left"));
+        const back = rbIconButton(
+            "fa-arrow-left",
+            "Back to views",
+            backToViews,
+        );
         actions.append(
             back,
             rbNode("p", "Checking publication and conflicts..."),
@@ -1911,115 +2059,119 @@ export function mountMemoryHubViews(
         title.focus();
         function enableActions() {
             actions.replaceChildren();
-            const more = rbNode("details", undefined, "hub-view-more-actions");
-            const moreSummary = rbNode("summary");
-            moreSummary.append(
-                icon("fa-ellipsis"),
-                rbNode("span", "More actions", "hub-visually-hidden"),
-            );
-            more.append(moreSummary);
+            const more: MenuItem[] = [];
             appendEditorialControls(view, article, more);
-            more.addEventListener("keydown", (event) => {
-                if (event.key !== "Escape" || !more.open) return;
-                event.preventDefault();
-                more.open = false;
-                moreSummary.focus();
-            });
             const pendingConflict = pendingConflicts.get(
                 publicationKey(view.corpusId, view.viewId),
             );
             if (pendingConflict)
-                more.append(
-                    rbButton("Review pending conflict", () => {
+                more.push({
+                    label: "Review pending conflict",
+                    icon: "fa-code-compare",
+                    action: () => {
                         void action(() =>
-                            showConflict(
-                                view.corpusId,
-                                pendingConflict.conflictId,
-                            ),
+                            showConflict(view.corpusId, pendingConflict),
                         );
-                    }),
-                );
-            const editButton = rbButton("Edit", () => showEditor(view));
+                    },
+                });
+            const editButton = rbIconButton("fa-pen", "Edit", () =>
+                showEditor(view),
+            );
             editButton.classList.add("primary");
-            editButton.prepend(icon("fa-pen"));
             actions.append(
                 back,
                 rbNode("span", undefined, "hub-spacer"),
                 editButton,
             );
-            more.append(
-                rbButton("Rebuild from evidence", () => {
-                    exactInitialSources.clear();
-                    void action(() =>
-                        openBuilder(
-                            view.corpusId,
-                            view.definition.selector.sources.map(
-                                (source) => source.sourceId,
+            more.push(
+                {
+                    label: "Rebuild from evidence",
+                    icon: "fa-arrows-rotate",
+                    action: () => {
+                        exactInitialSources.clear();
+                        void action(() =>
+                            openBuilder(
+                                view.corpusId,
+                                view.definition.selector.sources.map(
+                                    (source) => source.sourceId,
+                                ),
+                                view,
                             ),
-                            view,
-                        ),
-                    );
-                }),
-                rbButton("Publication and search", () => {
-                    void action(async () => {
-                        const current = sequence;
-                        const savedPolicy = await invokeMemory(
-                            "memoryGetViewPublicationPolicy",
-                            { corpusId: view.corpusId },
-                        );
-                        if (disposed || current !== sequence) return;
-                        policies.set(view.corpusId, savedPolicy);
-                        const sheet = viewSheet(
-                            root,
-                            "Publication and search",
-                            () => !busy && discardChanges(),
                         );
-                        sheet.body.append(publicationPanel(view));
-                    });
-                }),
-                rbButton("History", () => {
-                    void action(async () => {
-                        const history = await invokeMemory(
-                            "memoryViewHistory",
-                            {
-                                corpusId: view.corpusId,
-                                viewId: view.viewId,
-                            },
-                        );
-                        if (disposed) return;
-                        const sheet = viewSheet(root, "View history");
-                        for (const entry of history)
-                            sheet.body.append(
-                                rbNode(
-                                    "h3",
-                                    `Version ${entry.version.version} (${entry.version.state}) @ ${entry.version.revisionId}`,
-                                ),
-                                rbMarkdown(
-                                    viewContentToText(entry.version.content),
-                                ),
-                                rbIconButton(
-                                    "fa-arrow-up-right-from-square",
-                                    "Open exact revision",
-                                    () => {
-                                        sheet.close();
-                                        void showView(
-                                            view.corpusId,
-                                            view.viewId,
-                                            entry.version.revisionId,
-                                        );
-                                    },
-                                ),
+                    },
+                },
+                {
+                    label: "Publication and search",
+                    icon: "fa-magnifying-glass",
+                    action: () => {
+                        void action(async () => {
+                            const current = sequence;
+                            const savedPolicy = await invokeMemory(
+                                "memoryGetViewPublicationPolicy",
+                                { corpusId: view.corpusId },
                             );
-                    });
-                }),
+                            if (disposed || current !== sequence) return;
+                            policies.set(view.corpusId, savedPolicy);
+                            const sheet = viewSheet(
+                                root,
+                                "Publication and search",
+                                () => !busy && discardChanges(),
+                            );
+                            sheet.body.append(publicationPanel(view));
+                        });
+                    },
+                },
+                {
+                    label: "History",
+                    icon: "fa-clock-rotate-left",
+                    action: () => {
+                        void action(async () => {
+                            const history = await invokeMemory(
+                                "memoryViewHistory",
+                                {
+                                    corpusId: view.corpusId,
+                                    viewId: view.viewId,
+                                },
+                            );
+                            if (disposed) return;
+                            const sheet = viewSheet(root, "View history");
+                            for (const entry of history)
+                                sheet.body.append(
+                                    rbNode(
+                                        "h3",
+                                        `Version ${entry.version.version} (${entry.version.state}) @ ${entry.version.revisionId}`,
+                                    ),
+                                    rbMarkdown(
+                                        viewContentToText(
+                                            entry.version.content,
+                                        ),
+                                    ),
+                                    rbIconButton(
+                                        "fa-arrow-up-right-from-square",
+                                        "Open exact revision",
+                                        () => {
+                                            sheet.close();
+                                            void showView(
+                                                view.corpusId,
+                                                view.viewId,
+                                                entry.version.revisionId,
+                                            );
+                                        },
+                                    ),
+                                );
+                        });
+                    },
+                },
             );
             if (
                 maintenanceSupported &&
                 view.state !== "archived" &&
                 !view.definition.wiki
             )
-                more.append(
-                    rbButton("Update view", () => {
+                more.push({
+                    label: "Update view",
+                    icon: "fa-screwdriver-wrench",
+                    action: () => {
                         if (!discardChanges()) return;
                         const sheet = viewSheet(
                             root,
@@ -2055,9 +2207,9 @@ export function mountMemoryHubViews(
                             },
                         );
                         sheet.body.append(panel);
-                    }),
-                );
-            actions.append(more);
+                    },
+                });
+            actions.append(menuButton("More actions", more));
         }
         if (actionsReady) enableActions();
         return enableActions;
diff --git a/ts/packages/agents/browser/test/memoryHubGraph.test.mjs b/ts/packages/agents/browser/test/memoryHubGraph.test.mjs
index ffbc51e3cc..b876f6f3bd 100644
--- a/ts/packages/agents/browser/test/memoryHubGraph.test.mjs
+++ b/ts/packages/agents/browser/test/memoryHubGraph.test.mjs
@@ -149,6 +149,49 @@ test("inventory paging preserves the selected corpus, generation and limits", as
     assert.equal(calls.length, 1);
 });
 
+test("graph responses omit inventory diagnostics but retain graph and topic evidence identity", async () => {
+    const { service, hub } = fixture();
+    const query = service.queryKnowledgeGraph;
+    const originals = [];
+    service.queryKnowledgeGraph = async (request) => {
+        const graph = await query(request);
+        graph.state = "building";
+        graph.coverage.topics = {
+            state: "building",
+            generation: "topics-g1",
+        };
+        graph.coverage.reasons = ["Rebuild topics to populate the hierarchy."];
+        graph.nextContinuationToken = "unused-inventory-page";
+        originals.push(graph);
+        return graph;
+    };
+    const result = await hub.memoryHubGraph({ kind: "hierarchy" });
+    for (const { graph } of result.corpora) {
+        assert.deepEqual(Object.keys(graph).sort(), [
+            "edges",
+            "generation",
+            "nodes",
+            "topicGeneration",
+        ]);
+        assert.equal(graph.topicGeneration, "topics-g1");
+        assert.equal(graph.nodes[0].label, "Casey");
+        assert.ok(graph.generation.endsWith("-generation"));
+    }
+    assert.ok(originals.every((graph) => graph.coverage.reasons.length === 1));
+    const compactBytes = Buffer.byteLength(JSON.stringify(result.corpora));
+    const originalBytes = Buffer.byteLength(
+        JSON.stringify(
+            result.corpora.map((corpus, index) => ({
+                ...corpus,
+                graph: originals[index],
+            })),
+        ),
+    );
+    assert.ok(compactBytes < originalBytes);
+    assert.equal(result.presetLayout.elements.length, 2);
+    assert.deepEqual(result.errors, []);
+});
+
 test("selected corpus never silently broadens graph or support scope", async () => {
     const { hub, calls } = fixture();
     const graph = await hub.memoryHubGraph({
diff --git a/ts/packages/agents/browserControlRpc/src/memoryGraphViewTypes.ts b/ts/packages/agents/browserControlRpc/src/memoryGraphViewTypes.ts
index 0128a8b5c3..31516938e9 100644
--- a/ts/packages/agents/browserControlRpc/src/memoryGraphViewTypes.ts
+++ b/ts/packages/agents/browserControlRpc/src/memoryGraphViewTypes.ts
@@ -19,7 +19,10 @@ export interface MemoryHubGraphResult {
     corpora: Array<{
         corpusId: string;
         corpusName: string;
-        graph: MemoryGraphQueryResult;
+        graph: Pick<
+            MemoryGraphQueryResult,
+            "generation" | "nodes" | "edges"
+        > & { topicGeneration?: string };
     }>;
     errors: Array<{ corpusId: string; message: string }>;
     omittedCorpora: number;
diff --git a/ts/packages/memory/client/src/inventoryProtocol.ts b/ts/packages/memory/client/src/inventoryProtocol.ts
index 8b47aec45e..362c3fea53 100644
--- a/ts/packages/memory/client/src/inventoryProtocol.ts
+++ b/ts/packages/memory/client/src/inventoryProtocol.ts
@@ -145,6 +145,9 @@ export const viewBuildSummarySchema = viewBuildJobSchema
             })
             .extend({
                 current: z.boolean(),
+                conflictState: z
+                    .enum(["pending", "resolved", "missing"])
+                    .optional(),
                 snapshot: result.shape.snapshot
                     .pick({ pipeline: true })
                     .extend({
diff --git a/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs b/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs
index 9bd154116c..2e8b8266c6 100644
--- a/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs
+++ b/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs
@@ -22,6 +22,7 @@ import {
     acquisitionProgressSchema,
     projectAcquisitionProgress,
     safeAcquisitionOperation,
+    viewBuildSummarySchema,
 } from "../dist/index.js";
 
 const view = JSON.parse(
@@ -33,6 +34,41 @@ const base = {
     expectedHead: null,
     expectedVersion: 1,
 };
+test("build summaries preserve lightweight conflict state and accept legacy responses", () => {
+    const summary = {
+        jobId: "00000000-0000-4000-8000-000000000001",
+        corpusId: "corpus",
+        createdAt: "2026-10-27T00:00:00Z",
+        updatedAt: "2026-10-27T00:00:00Z",
+        state: "partial",
+        maintenance: false,
+        results: [
+            {
+                viewId: "guide",
+                state: "conflicted",
+                reason: "Review overlap",
+                conflictId: "00000000-0000-4000-8000-000000000002",
+                current: true,
+                snapshot: {
+                    pipeline: "informational-wiki-v1",
+                    definition: { kind: "wiki" },
+                },
+            },
+        ],
+    };
+    assert.equal(
+        viewBuildSummarySchema.parse(summary).results[0].conflictState,
+        undefined,
+    );
+    for (const conflictState of ["pending", "resolved", "missing"]) {
+        const current = structuredClone(summary);
+        current.results[0].conflictState = conflictState;
+        assert.equal(
+            viewBuildSummarySchema.parse(current).results[0].conflictState,
+            conflictState,
+        );
+    }
+});
 test("generic view protocol preserves scoped local chronology without a timezone", () => {
     const local = structuredClone(view);
     const details = local.content.sections[0].details;
diff --git a/ts/packages/memory/service/README.md b/ts/packages/memory/service/README.md
index 7b50188e13..7d9b3b5856 100644
--- a/ts/packages/memory/service/README.md
+++ b/ts/packages/memory/service/README.md
@@ -31,6 +31,12 @@ View, build and publication summary operations avoid loading full evidence bodie
 for list navigation. A committed read projection preserves historical conflict
 fallback and source eligibility checks. View/event index preparation can release
 the writer lease, then revalidates captured evidence before installation.
+Build-result summaries include optional `conflictState` metadata (`pending`,
+`resolved`, or `missing`) so attention lists need not fetch full conflict
+snapshots. Older clients may ignore this field; clients connected to older
+services can still resolve conflict status through the detail operation.
+Startup upgrades an unversioned read projection once, without regenerating
+views, and subsequent clean restarts reuse that projection.
 
 ## Document import token budgets
 
@@ -718,6 +724,13 @@ failures appear in `failures` under a corpus/family/target key and keep
 rather than spinning until its deadline. A successful retry clears only that
 target's diagnostic. Infrastructure and persistence failures still block the
 affected family until its existing retry conditions are met.
+Question reconciliation also reports blocked or exhausted automatic outcomes
+in `failures` under a corpus/schema key and in the question inventory's
+`maintenanceError`. These outcomes keep `settled: false` without failing service
+shutdown. Full-input limits and stopped retries remain enforced; changed
+evidence or a successful explicit retry clears the diagnostic. Unexpected
+schema-maintenance errors, including exhausted head/version conflicts, still
+fail shutdown.
 Shutdown cancels their linked work before releasing storage. A provider that
 ignores cancellation must still be drained before storage ownership is released.
 
diff --git a/ts/packages/memory/service/src/fileMemoryService.ts b/ts/packages/memory/service/src/fileMemoryService.ts
index 6a7cbcc0af..0eb5a59c98 100644
--- a/ts/packages/memory/service/src/fileMemoryService.ts
+++ b/ts/packages/memory/service/src/fileMemoryService.ts
@@ -507,6 +507,8 @@ function knowledgeMaintenanceResult(
     };
 }
 
+class SchemaMaintenanceBlockedError extends Error {}
+
 interface StoredRevision extends SourceRevision {
     content: string;
     synopsis?: SourceSynopsis & { attempts: number };
@@ -1999,6 +2001,11 @@ export class FileMemoryService
                     error: synopsis.reason ?? "Source synopsis failed",
                 });
             }
+        for (const [corpusId, failure] of this.schemaMaintenanceFailures)
+            status.failures.push({
+                key: `${corpusId}:schema`,
+                error: failure.message,
+            });
         status.settled &&= status.failures.length === 0;
         return status;
     }
@@ -5580,7 +5587,7 @@ export class FileMemoryService
                 ),
             );
             if (failure)
-                throw new Error(
+                throw new SchemaMaintenanceBlockedError(
                     `Question reconciliation for ${failure.viewId} needs an explicit retry or changed evidence; automatic retries are stopped`,
                 );
             await this.maintainViews({
@@ -5595,7 +5602,7 @@ export class FileMemoryService
             return;
         }
         if (blocked)
-            throw new Error(
+            throw new SchemaMaintenanceBlockedError(
                 `Question reconciliation blocked: ${blocked.reason}`,
             );
     }
@@ -14554,7 +14561,8 @@ export class FileMemoryService
         for (const failure of this.wikiMaintenanceFailures.values())
             throw failure;
         for (const failure of this.schemaMaintenanceFailures.values())
-            throw failure;
+            if (!(failure instanceof SchemaMaintenanceBlockedError))
+                throw failure;
     }
     private closePromise: Promise<void> | undefined;
     private readonly viewIndexCleanup = new Map<string, Promise<void>>();
diff --git a/ts/packages/memory/service/src/inventoryTypes.ts b/ts/packages/memory/service/src/inventoryTypes.ts
index b507334134..fb9b1514cc 100644
--- a/ts/packages/memory/service/src/inventoryTypes.ts
+++ b/ts/packages/memory/service/src/inventoryTypes.ts
@@ -7,6 +7,7 @@ import type {
     ViewBuildJob,
     ViewBuildTargetResult,
     ViewBuildSnapshot,
+    ViewMergeConflict,
     ViewDefinition,
     ViewPublicationStatus,
     ViewSnapshot,
@@ -70,6 +71,7 @@ export interface ViewBuildResultSummary
         "viewId" | "state" | "reason" | "revisionId" | "conflictId"
     > {
     current: boolean;
+    conflictState?: ViewMergeConflict["state"] | "missing";
     snapshot: Pick<ViewBuildSnapshot, "pipeline"> & {
         definition: Pick<ViewDefinition, "kind">;
     };
diff --git a/ts/packages/memory/service/src/viewReadProjection.ts b/ts/packages/memory/service/src/viewReadProjection.ts
index e4f18a7fcb..de64f7ba32 100644
--- a/ts/packages/memory/service/src/viewReadProjection.ts
+++ b/ts/packages/memory/service/src/viewReadProjection.ts
@@ -14,6 +14,7 @@ import type {
 } from "./viewTypes.js";
 
 export const viewReadProjectionEntry = "view-read-projection.json";
+export const viewReadProjectionVersion = 1;
 
 export interface ViewInventoryBuild extends Omit<ViewBuildSummary, "results"> {
     results: Array<
@@ -26,6 +27,7 @@ export interface ViewInventoryBuild extends Omit<ViewBuildSummary, "results"> {
 }
 
 export interface ViewReadProjection {
+    version?: number;
     views: ViewVersion[];
     builds: ViewInventoryBuild[];
     publications: Record<string, ViewPublicationStatus>;
@@ -44,6 +46,7 @@ export function viewReadProjection(state: {
     conflicts?: Record<string, ViewMergeConflict>;
 }): ViewReadProjection {
     return {
+        version: viewReadProjectionVersion,
         views: Object.values(state.views).flatMap((versions) =>
             versions.length ? [versions[versions.length - 1]] : [],
         ),
@@ -55,6 +58,13 @@ export function viewReadProjection(state: {
                     const target = job.results[index]!;
                     return {
                         ...result,
+                        ...(target.conflictId
+                            ? {
+                                  conflictState:
+                                      state.conflicts?.[target.conflictId]
+                                          ?.state ?? "missing",
+                              }
+                            : {}),
                         inputFingerprint: target.snapshot.fingerprint,
                         evidenceFingerprint:
                             result.state === "conflicted" && result.conflictId
diff --git a/ts/packages/memory/service/src/viewStore.ts b/ts/packages/memory/service/src/viewStore.ts
index 215f9347f4..877f883718 100644
--- a/ts/packages/memory/service/src/viewStore.ts
+++ b/ts/packages/memory/service/src/viewStore.ts
@@ -30,6 +30,7 @@ import { maintenanceManifest } from "./viewMaintenance.js";
 import {
     viewReadProjection,
     viewReadProjectionEntry,
+    viewReadProjectionVersion,
     type ViewInventoryBuild,
     type ViewReadProjection,
 } from "./viewReadProjection.js";
@@ -329,7 +330,7 @@ export class TypedViewStore {
         const { head, value } = await history.readEntry<ViewReadProjection>(
             viewReadProjectionEntry,
         );
-        if (!head || value) return;
+        if (!head || value?.version === viewReadProjectionVersion) return;
         const { state } = await history.read(head);
         await history.commit(
             head,
diff --git a/ts/packages/memory/service/test/schemaViews.spec.ts b/ts/packages/memory/service/test/schemaViews.spec.ts
index b8595f2f1d..40c1b19e56 100644
--- a/ts/packages/memory/service/test/schemaViews.spec.ts
+++ b/ts/packages/memory/service/test/schemaViews.spec.ts
@@ -639,6 +639,80 @@ describe("ordinary-source schema lifecycle", () => {
         return { corpus, request };
     }
 
+    test.each([false, true])(
+        "oversized reconciliation remains visible without failing close; recovery=%s",
+        async (recover) => {
+            const corpus = await service.createCorpus("Bounded questions");
+            const corpusId = corpus.corpusId;
+            const def = definition([name]);
+            def.maintenance = {
+                schemaVersion: 1,
+                scope: { mode: "scopedSources", tags: ["profile"] },
+            };
+            await settled(
+                await service.buildViews({
+                    corpusId,
+                    expectedHead: (await service.listViews(corpusId)).head,
+                    publication: false,
+                    targets: [{ definition: def, expectedVersion: 0 }],
+                }),
+            );
+            const calls = modelCalls;
+            const source = {
+                sourceId: "bounded-profile",
+                sourceType: "text" as const,
+                title: "Profile",
+                tags: ["profile"],
+                text: "Preferred name is Ada. " + "x".repeat(120001),
+            };
+            const job = await service.ingestDocument({ corpusId, source });
+            await waitForMemoryJob(service, job.jobId);
+            let error: string | undefined;
+            for (let count = 0; count < 1000; count++) {
+                error = (await service.listQuestions(corpusId))
+                    .maintenanceError;
+                if (error) break;
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+            expect(error).toContain(
+                "Complete input exceeds 120000 characters; no truncation",
+            );
+            expect(service.getMaintenanceStatus()).toMatchObject({
+                settled: false,
+                failures: [{ key: `${corpusId}:schema`, error }],
+            });
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            expect(modelCalls).toBe(calls);
+            if (recover) {
+                const replacement = await service.ingestDocument({
+                    corpusId,
+                    source: { ...source, text: "Preferred name is Ada." },
+                });
+                await waitForMemoryJob(service, replacement.jobId);
+                for (let count = 0; count < 1000; count++) {
+                    const inventory = await service.listQuestions(corpusId);
+                    if (
+                        !inventory.maintenanceError &&
+                        inventory.items[0].details.candidates.length
+                    )
+                        break;
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                }
+                expect(
+                    (await service.listQuestions(corpusId)).maintenanceError,
+                ).toBeUndefined();
+                expect(
+                    service.getMaintenanceStatus().failures,
+                ).not.toContainEqual(
+                    expect.objectContaining({ key: `${corpusId}:schema` }),
+                );
+                expect(modelCalls).toBeGreaterThan(calls);
+            }
+            await expect(service.close()).resolves.toBeUndefined();
+        },
+        60000,
+    );
+
     test("paged inventories omit evidence and frozen inputs; detail and bulk publication remain authoritative", async () => {
         const corpus = await service.createCorpus("Inventory contracts");
         const corpusId = corpus.corpusId;
@@ -923,6 +997,10 @@ describe("ordinary-source schema lifecycle", () => {
             await new Promise((resolve) => setTimeout(resolve, 500));
             expect(rebuildPlans).toBe(4);
             expectedCloseFailure = failure;
+            expect(service.getMaintenanceStatus().failures).toContainEqual({
+                key: `${corpus.corpusId}:schema`,
+                error: failure,
+            });
         },
         60000,
     );
diff --git a/ts/packages/memory/service/test/viewIndexConcurrency.spec.ts b/ts/packages/memory/service/test/viewIndexConcurrency.spec.ts
index 369bb29bd2..257ecf07d2 100644
--- a/ts/packages/memory/service/test/viewIndexConcurrency.spec.ts
+++ b/ts/packages/memory/service/test/viewIndexConcurrency.spec.ts
@@ -11,7 +11,13 @@ import type {
     ViewBuildJob,
     ViewPublishRequest,
     ViewSynthesisOutput,
+    ViewMergeConflict,
 } from "../src/viewTypes.js";
+import {
+    viewReadProjection,
+    viewReadProjectionEntry,
+    type ViewReadProjection,
+} from "../src/viewReadProjection.js";
 import type { IndexedDocument } from "../src/types.js";
 import { FakeSemanticCorpusIndex } from "./fakeSemanticCorpusIndex.js";
 import { inventoryTestAnswer } from "./viewInventoryTestModel.js";
@@ -280,41 +286,108 @@ describe("detached view index preparation", () => {
         });
     }
 
-    test("legacy view history receives one committed read projection on restart", async () => {
-        await service.close();
-        const history = new ViewHistory(
-            path.join(root, corpusId, "views"),
-            () => ({ views: {} }),
-        );
-        const { head, state } = await history.read();
-        const legacyHead = await history.commit(
-            head,
-            state,
-            {},
-            "fixture",
-            "Legacy state without read entries",
-        );
-        expect(
-            (await new TypedViewStore(root).getViewVersions(request)).map(
-                (version) => version.revisionId,
-            ),
-        ).toContain(request.revisionId);
-        service = open();
-        expect(await service.getView(request)).toBeDefined();
-        const projection = await history.readEntry<{
-            views: Array<{ viewId: string }>;
-        }>("view-read-projection.json");
-        expect(projection.head).not.toBe(legacyHead);
-        expect(projection.value?.views.map((view) => view.viewId)).toEqual([
-            "guide",
-        ]);
-        await service.close();
-        service = open();
-        expect(await service.getView(request)).toBeDefined();
-        expect(
-            (await history.readEntry("view-read-projection.json")).head,
-        ).toBe(projection.head);
-    });
+    test.each(["missing", "unversioned"])(
+        "%s legacy view history receives one committed read projection on restart",
+        async (legacy) => {
+            await service.close();
+            const history = new ViewHistory(
+                path.join(root, corpusId, "views"),
+                () => ({ views: {} }),
+            );
+            const { head, state } = await history.read();
+            const oldProjection = {
+                ...(
+                    await history.readEntry<ViewReadProjection>(
+                        viewReadProjectionEntry,
+                    )
+                ).value,
+            };
+            delete oldProjection.version;
+            const legacyHead = await history.commit(
+                head,
+                state,
+                legacy === "missing"
+                    ? {}
+                    : {
+                          [viewReadProjectionEntry]:
+                              JSON.stringify(oldProjection),
+                      },
+                "fixture",
+                "Legacy state without read entries",
+            );
+            if (legacy === "missing")
+                expect(
+                    (
+                        await new TypedViewStore(root).getViewVersions(request)
+                    ).map((version) => version.revisionId),
+                ).toContain(request.revisionId);
+            service = open();
+            expect(await service.getView(request)).toBeDefined();
+            expect(
+                (await new TypedViewStore(root).getViewVersions(request)).map(
+                    (version) => version.revisionId,
+                ),
+            ).toContain(request.revisionId);
+            const projection = await history.readEntry<{
+                views: Array<{ viewId: string }>;
+            }>("view-read-projection.json");
+            expect(projection.head).not.toBe(legacyHead);
+            expect(projection.value?.views.map((view) => view.viewId)).toEqual([
+                "guide",
+            ]);
+            await service.close();
+            service = open();
+            expect(await service.getView(request)).toBeDefined();
+            expect(
+                (await history.readEntry("view-read-projection.json")).head,
+            ).toBe(projection.head);
+        },
+    );
+
+    test.each(["pending", "resolved", "missing"] as const)(
+        "build projections expose %s conflict status without conflict evidence",
+        async (state) => {
+            const job = (await service.listViewBuilds(corpusId))[0];
+            const human = (await service.listViews(corpusId)).views[0];
+            const conflictId = "conflict";
+            job.results[0].conflictId = conflictId;
+            job.results[0].state = "conflicted";
+            const conflict: ViewMergeConflict = {
+                conflictId,
+                identity: "fixture",
+                corpusId,
+                viewId: human.viewId,
+                jobId: job.jobId,
+                createdAt: job.createdAt,
+                actor: "fixture",
+                state: state === "missing" ? "pending" : state,
+                expectedRevisionId: human.revisionId,
+                input: job.results[0].snapshot,
+                human,
+                candidate: {
+                    content: human.content,
+                    relationships: [],
+                    outcome: "diagnosticOnly",
+                    missingEvidence: [],
+                },
+                targets: [],
+                reason: "Fixture conflict",
+                event: { kind: "viewMergeConflict", editIds: [], evidence: [] },
+            };
+            const projection = viewReadProjection({
+                views: { [human.viewId]: [human] },
+                builds: { [job.jobId]: job },
+                ...(state === "missing"
+                    ? {}
+                    : { conflicts: { [conflictId]: conflict } }),
+            });
+            expect(projection.builds[0].results[0].conflictState).toBe(state);
+            expect(JSON.stringify(projection.builds)).not.toContain(
+                human.content.title,
+            );
+            expect(projection.conflicts).toBeUndefined();
+        },
+    );
 
     test("detail and inventory reads do not wait for the delayed full-history adapter", async () => {
         const entered = deferred();

From 741a986010c8c9385dee9c77cd693e7f6516125c Mon Sep 17 00:00:00 2001
From: Hillary Mutisya <150286414+hillary-mutisya@users.noreply.github.com>
Date: Tue, 27 Oct 2026 15:15:21 -0700
Subject: [PATCH 2/4] Fix question reader safeguards and accessible review
 flows

Clear stale question controls before route loads, keep reader concurrency heads independent of list scope, block navigation during mutations, and preserve drafts during polling. Retain unchanged Inbox details using stable identities and state fingerprints. Add a lazy keyboard-accessible graph item picker without restoring graph-page clutter.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ts/packages/agents/browser/README.md          |  14 ++
 .../src/views/client/library/memoryHub.ts     |   2 +
 .../views/client/library/memoryHubGraph.css   |  11 ++
 .../client/library/memoryHubGraph.test.ts     |  75 +++++++++-
 .../views/client/library/memoryHubGraph.ts    |  73 ++++++++++
 .../client/library/memoryHubInbox.test.ts     |  46 +++++-
 .../views/client/library/memoryHubInbox.ts    |  35 ++++-
 .../client/library/memoryHubQuestions.test.ts | 136 +++++++++++++++++-
 .../client/library/memoryHubQuestions.ts      |  73 ++++++----
 .../client/library/memoryHubViewActivity.ts   |  21 +++
 10 files changed, 451 insertions(+), 35 deletions(-)

diff --git a/ts/packages/agents/browser/README.md b/ts/packages/agents/browser/README.md
index 0fc40d48a2..1e03bb217d 100644
--- a/ts/packages/agents/browser/README.md
+++ b/ts/packages/agents/browser/README.md
@@ -118,6 +118,20 @@ retry, history and exact evidence. Back returns to the previous scoped inventory
 with its filters and paging; direct links can load slots outside the current page
 without scanning every collection.
 
+Question route transitions clear old controls before fetching. Reader edit heads
+are refreshed for the exact reader corpus/view independently of the preserved
+inventory scope. Pending operations block navigation, and background polling
+does not reload an unsaved reader draft.
+
+Graph toolbars include an on-demand, keyboard-accessible item picker for the
+displayed nodes and relationships. It reuses the bounded graph projection and
+generation-qualified evidence flow without fetching a separate inventory or
+restoring the removed graph coverage and browse disclosures.
+
+Inbox detail panels survive unchanged and unrelated count refreshes. Stable item
+identities and state fingerprints close a panel only when its selected item
+changes or disappears; category navigation and scope resets still close it.
+
 The Memory hub's Questions workspace is a complete projection of versioned
 schema-view slots, including proposed and rejected slots. The inspector reviews
 candidates and exact source revisions, records schema-validated user assertions,
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHub.ts b/ts/packages/agents/browser/src/views/client/library/memoryHub.ts
index 2f96c222de..a2fc520382 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHub.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHub.ts
@@ -523,6 +523,8 @@ function renderInbox(): void {
     list.replaceChildren(
         ...items.slice(inboxPage * 25, (inboxPage + 1) * 25).map((item) =>
             inboxPanel.present({
+                id: item.id,
+                fingerprint: item.fingerprint,
                 title: item.title,
                 summary: `${inboxKinds[item.kind].label} · ${item.reason}`,
                 detail: inboxCard(item, dismissed),
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css
index 6f40bc59e7..5513d41b25 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.css
@@ -57,3 +57,14 @@
   white-space: pre-wrap;
   overflow-wrap: anywhere;
 }
+.hub-graph-item-picker {
+  display: grid;
+  gap: 12px;
+}
+
+.hub-graph-item-picker select,
+.hub-graph-item-picker input {
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+}
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts
index f8ddccdd56..68d3e4f368 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.test.ts
@@ -151,6 +151,7 @@ test.each(["entities", "topics"] as const)(
             ["Refresh graph", "fa-rotate"],
             ["Global graph", "fa-globe"],
             ["Fit graph", "fa-expand"],
+            ["Browse graph items", "fa-list"],
         ]) {
             const control = button(label);
             expect(control.title).toBe(label);
@@ -180,7 +181,7 @@ test.each(["entities", "topics"] as const)(
         expect(host.querySelector('[aria-label="Graph controls"]')).toBe(
             toolbar,
         );
-        expect(toolbar.querySelectorAll("button")).toHaveLength(3);
+        expect(toolbar.querySelectorAll("button")).toHaveLength(4);
         expect(onError).not.toHaveBeenCalled();
     },
 );
@@ -195,6 +196,78 @@ test("opaque graph routes retain node identity instead of becoming label searche
     expect(invoke.mock.calls[0][1]).not.toHaveProperty("search");
     expect(onRouteChanged).toHaveBeenCalledWith("entities", nodeId);
 });
+test.each(["entities", "topics"] as const)(
+    "%s offers lazy keyboard-accessible node and relationship selection from the displayed projection",
+    async (view) => {
+        const edgeId = "graph:a:edge:one";
+        invoke.mockResolvedValueOnce({
+            ...sample,
+            corpora: [
+                {
+                    ...sample.corpora[0],
+                    graph: {
+                        ...sample.corpora[0].graph,
+                        edges: [
+                            {
+                                id: edgeId,
+                                source: nodeId,
+                                target: nodeId,
+                                type: "related",
+                                count: 1,
+                                supportCount: 1,
+                            },
+                        ],
+                    },
+                },
+            ],
+        });
+        await mounted.show({ view });
+        expect(
+            host.querySelector('[aria-label="Graph nodes and relationships"]'),
+        ).toBeNull();
+        button("Browse graph items").focus();
+        button("Browse graph items").click();
+        const search = host.querySelector<HTMLInputElement>(
+            '[aria-label="Find graph items"]',
+        )!;
+        const items = select("Graph nodes and relationships");
+        expect(document.activeElement).toBe(search);
+        expect(items.options).toHaveLength(2);
+        expect(items.options[0].textContent).toContain("Node · Alpha · Casey");
+        expect(items.options[1].textContent).toContain(
+            "Relationship · Alpha · Casey",
+        );
+        expect(items.value).toBe(nodeId);
+        expect(invoke.mock.calls).toHaveLength(1);
+        search.value = "not in graph";
+        search.dispatchEvent(new Event("input"));
+        expect(button("Inspect graph item").disabled).toBe(true);
+        expect(host.textContent).toContain("No graph items match");
+        search.value = "relationship";
+        search.dispatchEvent(new Event("input"));
+        expect(items.options).toHaveLength(1);
+        expect(items.value).toBe(edgeId);
+        button("Inspect graph item").click();
+        await settle();
+        expect(
+            host.querySelector('dialog[aria-label="Graph items"]'),
+        ).toBeNull();
+        expect(invoke).toHaveBeenLastCalledWith(
+            "memoryHubGraphSupport",
+            expect.objectContaining({
+                corpusId: "a",
+                generation: "g1",
+                edgeId,
+            }),
+        );
+        button("Browse graph items").click();
+        mounted.scopeChanged();
+        expect(
+            host.querySelector('dialog[aria-label="Graph items"]'),
+        ).toBeNull();
+        expect(button("Browse graph items").disabled).toBe(true);
+    },
+);
 
 test.each(["entities", "topics"] as const)(
     "%s shows the graph without coverage, collection inventory or browse disclosures",
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts
index 0c767f8b78..0646542246 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubGraph.ts
@@ -14,6 +14,8 @@ import { TopicGraphVisualizer } from "./topicGraphVisualizer";
 import { graphText, mountGraphDetails } from "./memoryHubGraphDetails";
 import { mountGraphControls } from "./memoryHubGraphControls";
 import { iconButton } from "./memoryHubUi";
+import { rbButton } from "./memoryHubDocumentUi";
+import { viewSheet } from "./memoryHubViewUi";
 import { invokeView } from "./viewClient";
 import "./memoryHubGraph.css";
 
@@ -73,11 +75,80 @@ export function mountMemoryHubGraph(
     let kind: GraphKind = "entities";
     let result: MemoryHubGraphResult | undefined;
     let renderer: EntityGraphVisualizer | TopicGraphVisualizer | undefined;
+    let picker: ReturnType<typeof viewSheet> | undefined;
+    const browse = iconButton("fa-list", "Browse graph items", () => {
+        if (result) showPicker(result);
+    });
+    browse.disabled = true;
+
+    function showPicker(data: MemoryHubGraphResult) {
+        picker?.close();
+        picker = viewSheet(host, "Graph items");
+        picker.body.classList.add("hub-graph-item-picker");
+        const search = graphText("input");
+        search.type = "search";
+        search.setAttribute("aria-label", "Find graph items");
+        const items = graphText("select");
+        items.setAttribute("aria-label", "Graph nodes and relationships");
+        items.size = 8;
+        const entries = data.corpora.flatMap((corpus) => [
+            ...corpus.graph.nodes.map((node) => ({
+                id: node.id,
+                label: `Node · ${corpus.corpusName} · ${node.label}`,
+            })),
+            ...corpus.graph.edges.map((edge) => ({
+                id: edge.id,
+                label: `Relationship · ${corpus.corpusName} · ${corpus.graph.nodes.find((node) => node.id === edge.source)?.label ?? edge.source} - ${edge.label ?? edge.type} -> ${corpus.graph.nodes.find((node) => node.id === edge.target)?.label ?? edge.target}`,
+            })),
+        ]);
+        const note = graphText("p");
+        note.setAttribute("role", "status");
+        const inspect = rbButton("Inspect graph item", () => {
+            const id = items.value;
+            picker?.close();
+            picker = undefined;
+            openSelection(id);
+        });
+        const filter = () => {
+            const matching = entries.filter((entry) =>
+                entry.label.toLowerCase().includes(search.value.toLowerCase()),
+            );
+            items.replaceChildren(
+                ...matching.map((entry) => {
+                    const option = graphText("option", entry.label);
+                    option.value = entry.id;
+                    return option;
+                }),
+            );
+            items.selectedIndex = matching.length ? 0 : -1;
+            items.disabled = !matching.length;
+            inspect.disabled = !matching.length;
+            note.textContent = matching.length
+                ? ""
+                : "No graph items match this search.";
+        };
+        search.addEventListener("input", filter);
+        picker.body.append(
+            graphText(
+                "p",
+                "Choose from nodes and relationships in the displayed graph. Use the arrow keys to select an item, then inspect its evidence.",
+            ),
+            search,
+            items,
+            note,
+            inspect,
+        );
+        filter();
+        search.focus();
+    }
 
     function topicKind(): "topics" | "hierarchy" {
         return controls.mode.value === "topics" ? "topics" : "hierarchy";
     }
     function release() {
+        picker?.close();
+        picker = undefined;
+        browse.disabled = true;
         if (renderer && "destroy" in renderer) renderer.destroy();
         else renderer?.dispose();
         renderer = undefined;
@@ -191,6 +262,7 @@ export function mountMemoryHubGraph(
             const nodes = data.corpora.flatMap((corpus) => corpus.graph.nodes);
             if (nodes.length) await renderGraph(data, ticket);
             if (ticket !== version || disposed) return;
+            browse.disabled = !nodes.length;
             status.textContent = nodes.length
                 ? ""
                 : "No nodes in the available projection.";
@@ -221,6 +293,7 @@ export function mountMemoryHubGraph(
             if (renderer instanceof EntityGraphVisualizer) renderer.fitToView();
             else renderer?.fitToView();
         }),
+        browse,
     );
     return {
         async show(request: {
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
index cb2a7010a3..ebb568e1ae 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
@@ -14,7 +14,12 @@ function setup() {
         { id: "views", label: "Views", host: views },
         { id: "operations", label: "Sources & operations", host: operations },
     ]);
-    function add(target: HTMLElement, title: string, summary = "Needs review") {
+    function add(
+        target: HTMLElement,
+        title: string,
+        summary = "Needs review",
+        fingerprint = summary,
+    ) {
         const detail = document.createElement("article");
         detail.textContent = `${title}: Full explanation, corpus-opaque-id and provenance. ${"Long evidence. ".repeat(150)}`;
         const action = document.createElement("button");
@@ -22,7 +27,9 @@ function setup() {
         const inspect = jest.fn();
         action.onclick = inspect;
         detail.append(action);
-        target.append(inbox.present({ title, summary, detail }));
+        target.append(
+            inbox.present({ id: title, fingerprint, title, summary, detail }),
+        );
         return { detail, inspect };
     }
     return { host, inbox, questions, views, operations, add };
@@ -161,6 +168,41 @@ test("supports arrow, Home and End navigation with one tabbable category", () =>
         ).toBe(false);
     }
 });
+test("count refreshes retain unchanged details but changed or removed selected items invalidate them", () => {
+    const { host, inbox, views, add } = setup();
+    const { detail, inspect } = add(views, "Blocked view");
+    inbox.setCount("views", 1);
+    button(
+        host.querySelector("#inbox-panel-all")!,
+        "Review: Blocked view",
+    ).click();
+    const panel = host.querySelector<HTMLElement>(
+        'aside[aria-label="Inbox details"]',
+    )!;
+    inbox.setCount("questions", 2);
+    inbox.setCount("views", 1);
+    inbox.fail("operations", new Error("Unrelated failure"));
+    expect(panel.hidden).toBe(false);
+    expect(panel.contains(detail)).toBe(true);
+    views.replaceChildren();
+    add(views, "Blocked view");
+    inbox.setCount("views", 1);
+    expect(panel.hidden).toBe(false);
+    expect(panel.contains(detail)).toBe(true);
+    button(panel, "Inspect operation").click();
+    expect(inspect).toHaveBeenCalledTimes(1);
+    views.replaceChildren();
+    add(views, "Blocked view", "Needs review", "changed-version");
+    inbox.setCount("views", 1);
+    expect(panel.hidden).toBe(true);
+    button(
+        host.querySelector("#inbox-panel-all")!,
+        "Review: Blocked view",
+    ).click();
+    views.replaceChildren();
+    inbox.setCount("views", 0);
+    expect(panel.hidden).toBe(true);
+});
 
 test("distinguishes loading and errors from empty counts and resets details on scope changes", () => {
     const { host, inbox, views, add } = setup();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
index 3509108891..37bfa9f026 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
@@ -7,6 +7,8 @@ import { setTabLabel } from "./memoryHubUi";
 
 export type InboxCategory = "questions" | "views" | "operations";
 export interface InboxAttentionCard {
+    id: string;
+    fingerprint: string;
     title: string;
     summary: string;
     detail: HTMLElement;
@@ -41,6 +43,9 @@ export function mountMemoryHubInbox(
     const cards = new WeakMap<HTMLElement, InboxAttentionCard>();
     const inspector = mountFlyout(host, "Inbox details");
     let selected = "all";
+    let active:
+        | { card: InboxAttentionCard; category?: InboxCategory }
+        | undefined;
 
     root.append(tabs, overview);
     for (const section of sections) {
@@ -125,14 +130,25 @@ export function mountMemoryHubInbox(
         const review = rbIconButton(
             "fa-file-lines",
             `Review: ${card.title}`,
-            () =>
+            () => {
+                active = {
+                    card,
+                    category: sections.find((section) =>
+                        [
+                            ...section.host.querySelectorAll<HTMLElement>(
+                                ".hub-inbox-item",
+                            ),
+                        ].some((row) => cards.get(row) === card),
+                    )?.id,
+                };
                 inspector.open({
                     title: card.title,
                     render(body) {
                         body.append(card.detail);
                         return () => card.detail.remove();
                     },
-                }),
+                });
+            },
         );
         item.append(content, review);
         cards.set(item, card);
@@ -224,16 +240,27 @@ export function mountMemoryHubInbox(
     }
     select("all");
     render();
+    function invalidateDetails(id: InboxCategory) {
+        if (!inspector.isOpen() || active?.category !== id) return;
+        const section = sections.find((section) => section.id === id)!;
+        const current = [
+            ...section.host.querySelectorAll<HTMLElement>(".hub-inbox-item"),
+        ]
+            .map((item) => cards.get(item))
+            .find((card) => card?.id === active?.card.id);
+        if (!current || current.fingerprint !== active.card.fingerprint)
+            inspector.close();
+    }
     return {
         present: row,
         setCount(id: InboxCategory, count: number, more = false) {
-            inspector.close();
+            invalidateDetails(id);
             counts.set(id, { count, more });
             errors.delete(id);
             render();
         },
         fail(id: InboxCategory, error: unknown) {
-            inspector.close();
+            if (active?.category === id) inspector.close();
             errors.set(
                 id,
                 error instanceof Error ? error.message : String(error),
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
index f7e5ee9621..f0c7768b82 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
@@ -29,6 +29,7 @@ function click(label: string) {
 function setup(
     scope: () => string | undefined = () => "corpus",
     onNavigate?: Parameters<typeof mountMemoryHubQuestions>[2]["onNavigate"],
+    corpora = [{ corpusId: "corpus", name: "Corpus" }],
 ) {
     document.body.innerHTML = "<main></main><aside></aside>";
     const onError = jest.fn();
@@ -39,7 +40,7 @@ function setup(
             document.querySelector("aside")!,
             {
                 scope,
-                corpora: () => [{ corpusId: "corpus", name: "Corpus" }],
+                corpora: () => corpora,
                 hidden: {},
                 persistHidden: jest.fn(),
                 onError,
@@ -179,6 +180,139 @@ test("Back invalidates pending question details and operation errors stay visibl
         document.querySelector(".hub-qdetail [role=alert]")!.textContent,
     ).toContain("Edit rejected");
 });
+test("a new slot route removes old edit controls before loading and after a detail failure", async () => {
+    const original = invoke.getMockImplementation()!;
+    invoke.mockImplementation((method, params) =>
+        method === "memoryGetQuestion"
+            ? Promise.resolve(question(params.slotId))
+            : original(method, params),
+    );
+    const { panel, onError } = setup();
+    await panel.show("view", "corpus", "first");
+    expect(document.querySelector(".hub-qdetail textarea")).not.toBeNull();
+    let reject!: (error: Error) => void;
+    invoke.mockImplementation((method, params) =>
+        method === "memoryGetQuestion"
+            ? new Promise((_resolve, fail) => {
+                  reject = fail;
+              })
+            : original(method, params),
+    );
+    const pending = panel.show("view", "corpus", "second");
+    expect(document.querySelector(".hub-qdetail")!.textContent).toContain(
+        "Loading question details",
+    );
+    expect(document.querySelector(".hub-qdetail textarea")).toBeNull();
+    expect(document.querySelectorAll(".hub-qdetail h2")).toHaveLength(1);
+    reject(new Error("Second slot unavailable"));
+    await pending;
+    expect(document.querySelector(".hub-qdetail")!.textContent).toContain(
+        "Second slot unavailable",
+    );
+    expect(document.querySelector(".hub-qdetail textarea")).toBeNull();
+    expect(document.querySelector(".hub-qdetail")!.textContent).not.toContain(
+        "Save user assertion",
+    );
+    expect(document.querySelectorAll(".hub-qdetail h2")).toHaveLength(1);
+    expect(onError).toHaveBeenCalledTimes(1);
+});
+
+test("cross-collection readers refresh their own edit head independently of the list scope", async () => {
+    const original = invoke.getMockImplementation()!;
+    let version = 2;
+    invoke.mockImplementation((method, params) => {
+        if (method === "memoryGetQuestion")
+            return Promise.resolve({
+                ...question("slot", "view-b"),
+                corpusId: "b",
+                viewVersion: version,
+            });
+        if (method === "memoryListQuestionSummaries" && params.corpusId === "b")
+            return Promise.resolve({
+                head: `b-head-${version}`,
+                items: [],
+                total: 0,
+            });
+        if (method === "memoryEditQuestion") {
+            version++;
+            return Promise.resolve({});
+        }
+        return original(method, params);
+    });
+    const navigate = jest.fn();
+    const { panel, onError } = setup(() => "a", navigate, [
+        { corpusId: "a", name: "Alpha" },
+        { corpusId: "b", name: "Beta" },
+    ]);
+    await panel.show("view-b", "b", "slot");
+    for (const answer of ['"First"', '"Second"']) {
+        const editor = document.querySelector<HTMLTextAreaElement>(
+            ".hub-qdetail textarea",
+        )!;
+        editor.value = answer;
+        editor.dispatchEvent(new Event("input"));
+        click("Save user assertion");
+        await settle();
+    }
+    expect(
+        invoke.mock.calls
+            .filter(([method]) => method === "memoryEditQuestion")
+            .map(([, params]) => ({
+                corpusId: params.corpusId,
+                head: params.expectedHead,
+                version: params.expectedVersion,
+            })),
+    ).toEqual([
+        { corpusId: "b", head: "b-head-2", version: 2 },
+        { corpusId: "b", head: "b-head-3", version: 3 },
+    ]);
+    expect(
+        invoke.mock.calls
+            .filter(([method]) => method === "memoryListQuestionSummaries")
+            .every(
+                ([, params]) =>
+                    params.corpusId === "b" && params.pageSize === 1,
+            ),
+    ).toBe(true);
+    click("Back to questions");
+    expect(navigate).toHaveBeenCalledWith({ page: "questions" });
+    expect(onError).not.toHaveBeenCalled();
+});
+
+test("busy question operations reject navigation and background refresh preserves unsaved drafts", async () => {
+    const { panel, onError } = setup();
+    await panel.show("view", "corpus", "slot");
+    const editor = document.querySelector<HTMLTextAreaElement>(
+        ".hub-qdetail textarea",
+    )!;
+    editor.value = '"Draft"';
+    editor.dispatchEvent(new Event("input"));
+    const confirm = jest.spyOn(window, "confirm").mockReturnValue(false);
+    await panel.refresh();
+    expect(confirm).not.toHaveBeenCalled();
+    expect(document.querySelector(".hub-qdetail textarea")).toBe(editor);
+    expect(editor.value).toBe('"Draft"');
+    const original = invoke.getMockImplementation()!;
+    let finish!: () => void;
+    invoke.mockImplementation((method, params) =>
+        method === "memoryEditQuestion"
+            ? new Promise<void>((resolve) => {
+                  finish = resolve;
+              })
+            : original(method, params),
+    );
+    click("Save user assertion");
+    expect(panel.discardChanges()).toBe(false);
+    expect(confirm).not.toHaveBeenCalled();
+    await panel.refresh();
+    expect(document.querySelector(".hub-qdetail textarea")).toBe(editor);
+    expect(confirm).not.toHaveBeenCalled();
+    finish();
+    await settle();
+    expect(panel.discardChanges()).toBe(true);
+    expect(onError).not.toHaveBeenCalled();
+    confirm.mockRestore();
+});
 test("questions put tabs after the title, totals and paging inside the list card, and preparation last", async () => {
     const original = invoke.getMockImplementation()!;
     invoke.mockImplementation(async (method, params) => {
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
index 3153dc8d05..32298f1f65 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
@@ -65,6 +65,7 @@ export function mountMemoryHubQuestions(
     type Filter = "all" | "open" | "answered";
     let selectedKey: string | undefined;
     let selectedQuestion: QuestionTarget | undefined;
+    let readerHead: QuestionSummaryPage["head"] | undefined;
     let filter: Filter = "all";
     let search = "";
     let loadedAt = 0;
@@ -304,8 +305,10 @@ export function mountMemoryHubQuestions(
     }
     async function edit(question: MemoryQuestion, edit: QuestionEdit) {
         const current = detailSequence;
-        const inventory = inventories.get(question.corpusId);
-        if (!inventory)
+        if (
+            readerHead === undefined ||
+            selectedKey !== questionIdentity(question)
+        )
             throw new Error(
                 "Question inventory is unavailable. Reload the question before editing.",
             );
@@ -313,15 +316,17 @@ export function mountMemoryHubQuestions(
             corpusId: question.corpusId,
             viewId: question.viewId,
             slotId: question.slot.id,
-            expectedHead: inventory.head,
+            expectedHead: readerHead,
             expectedVersion: question.viewVersion,
             edit,
         });
         dirty = false;
-        await refreshInventory();
-        if (current !== detailSequence || reader.hidden) return;
+        loadedAt = 0;
         const updated = await fetchQuestion(question);
-        if (current === detailSequence && !reader.hidden) inspect(updated);
+        if (current !== detailSequence || reader.hidden) return;
+        readerHead = updated.head;
+        selectedQuestion = updated.detail;
+        inspect(updated.detail);
     }
     function originLabel(question: QuestionListItem) {
         return (
@@ -372,13 +377,20 @@ export function mountMemoryHubQuestions(
         return row;
     }
     async function fetchQuestion(question: QuestionTarget) {
-        const detail = await invokeMemory("memoryGetQuestion", {
-            corpusId: question.corpusId,
-            viewId: question.viewId,
-            slotId: question.slot.id,
-        });
+        const [detail, page] = await Promise.all([
+            invokeMemory("memoryGetQuestion", {
+                corpusId: question.corpusId,
+                viewId: question.viewId,
+                slotId: question.slot.id,
+            }),
+            invokeMemory("memoryListQuestionSummaries", {
+                corpusId: question.corpusId,
+                viewId: question.viewId,
+                pageSize: 1,
+            }),
+        ]);
         if (!detail) throw new Error("This question is no longer available.");
-        return detail;
+        return { detail, head: page.head };
     }
     let detailSequence = 0;
     function select(question: QuestionListItem) {
@@ -400,6 +412,7 @@ export function mountMemoryHubQuestions(
         const key = questionIdentity(question);
         selectedKey = key;
         selectedQuestion = question;
+        readerHead = undefined;
         setDetailMode(true);
         readerActions.replaceChildren(back);
         const isCurrent = () =>
@@ -407,7 +420,7 @@ export function mountMemoryHubQuestions(
             selectedKey === key &&
             scope === options.scope();
         inspector.setAttribute("aria-busy", "true");
-        inspector.append(
+        inspector.replaceChildren(
             rbNode("h2", question.slot.question ?? "Question"),
             rbNode("p", "Loading question details..."),
         );
@@ -426,19 +439,11 @@ export function mountMemoryHubQuestions(
                         "Schema-defined questions capability is unavailable.",
                     );
             }
-            const detail = await fetchQuestion(question);
+            const loaded = await fetchQuestion(question);
             if (!isCurrent()) return;
-            if (!inventories.has(question.corpusId)) {
-                const page = await invokeMemory("memoryListQuestionSummaries", {
-                    corpusId: question.corpusId,
-                    viewId: question.viewId,
-                    pageSize: 1,
-                });
-                if (!isCurrent()) return;
-                inventories.set(question.corpusId, page);
-                loadedAt = 0;
-            }
-            inspect(detail);
+            readerHead = loaded.head;
+            selectedQuestion = loaded.detail;
+            inspect(loaded.detail);
         } catch (error: unknown) {
             if (!isCurrent()) return;
             const alert = rbNode(
@@ -446,7 +451,7 @@ export function mountMemoryHubQuestions(
                 `Question details unavailable: ${rbError(error)}`,
             );
             alert.setAttribute("role", "alert");
-            inspector.append(
+            inspector.replaceChildren(
                 rbNode("h2", question.slot.question ?? "Question"),
                 alert,
                 rbButton("Retry question details", () => {
@@ -1022,6 +1027,19 @@ export function mountMemoryHubQuestions(
             }
             attentionHost.append(
                 options.presentAttention?.({
+                    id: JSON.stringify([
+                        "questions",
+                        reason,
+                        members.map((group) => group.id),
+                    ]),
+                    fingerprint: JSON.stringify(
+                        members.flatMap((group) =>
+                            group.questions.map((item) => [
+                                questionIdentity(item),
+                                item.fingerprint,
+                            ]),
+                        ),
+                    ),
                     title: reason,
                     summary: members.map((group) => group.title).join(", "),
                     entries: members.length,
@@ -1312,7 +1330,7 @@ export function mountMemoryHubQuestions(
         },
         async refresh() {
             await refresh();
-            if (!reader.hidden && selectedQuestion)
+            if (!reader.hidden && selectedQuestion && !dirty && !busy)
                 await loadDetail(selectedQuestion);
         },
         hide() {
@@ -1333,6 +1351,7 @@ export function mountMemoryHubQuestions(
             }
         },
         discardChanges() {
+            if (busy) return false;
             if (!dirty) return true;
             if (!confirm("Discard unsaved question edits?")) return false;
             dirty = false;
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts
index 7c4a547a33..1d5746e822 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViewActivity.ts
@@ -158,6 +158,7 @@ export function mountMemoryHubViewActivity(
                         ? "Retry indexing"
                         : "Preview update";
                 Object.assign(card.dataset, {
+                    fingerprint: JSON.stringify([view, target]),
                     group: `${corpusName} · ${reason}`,
                     summary: reason,
                     title: view.content.title,
@@ -374,6 +375,13 @@ export function mountMemoryHubViewActivity(
         );
         attentionHost.append(
             options.presentAttention?.({
+                id: JSON.stringify([
+                    "view-result",
+                    corpus.corpusId,
+                    job.jobId,
+                    result.viewId,
+                ]),
+                fingerprint: JSON.stringify([job.updatedAt, result]),
                 title: `${resultTitle(result)} · ${states[result.state]}`,
                 summary: result.reason,
                 detail: item,
@@ -402,6 +410,10 @@ export function mountMemoryHubViewActivity(
             if (collapsed.has(bucket[0])) continue;
             bucket.forEach((entry) => collapsed.add(entry));
             const card = rbNode("article", undefined, "card");
+            card.dataset.group = key;
+            card.dataset.fingerprint = JSON.stringify(
+                bucket.map((entry) => entry.dataset.fingerprint),
+            );
             card.dataset.entries = String(bucket.length);
             card.dataset.summary = alert.dataset.summary;
             const rows = rbNode("div", undefined, "hub-rows");
@@ -447,6 +459,15 @@ export function mountMemoryHubViewActivity(
                 ...collapseAlerts(alerts).map(
                     (card) =>
                         options.presentAttention?.({
+                            id: JSON.stringify([
+                                "view-alert",
+                                corpus.corpusId,
+                                card.dataset.viewId ?? card.dataset.group,
+                            ]),
+                            fingerprint: JSON.stringify([
+                                card.dataset.fingerprint,
+                                card.outerHTML,
+                            ]),
                             title:
                                 card.querySelector("h4")?.textContent ??
                                 "View attention",

From 667d6ab48412fa204d9f4d481e6e5cb088e4e0f0 Mon Sep 17 00:00:00 2001
From: Hillary Mutisya <150286414+hillary-mutisya@users.noreply.github.com>
Date: Tue, 27 Oct 2026 15:18:12 -0700
Subject: [PATCH 3/4] Remove obsolete question inventory refresh helper

Reader metadata now refreshes independently of the landing inventory; remove the unused previous edit-time helper caught by the committed-diff lint ratchet.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../src/views/client/library/memoryHubQuestions.ts    | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
index 32298f1f65..b085736ee6 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
@@ -1214,17 +1214,6 @@ export function mountMemoryHubQuestions(
             .corpora()
             .filter((corpus) => !corpusId || corpus.corpusId === corpusId);
     }
-    // Reloads the inventory only. Acquisition progress loads
-    // when their panel is opened, not on every question edit.
-    async function refreshInventory() {
-        const version = ++sequence;
-        const corpora = scopedCorpora().filter((corpus) =>
-            pager.includes(corpus.corpusId),
-        );
-        const results = await loadQuestions(corpora);
-        if (version !== sequence) return;
-        applyInventory(results, corpora, options.scope());
-    }
     async function refresh() {
         const version = ++sequence;
         status.textContent = "Loading questions…";

From ae2993ddd534418b9eec22f6e8c77c793a294bc4 Mon Sep 17 00:00:00 2001
From: Hillary Mutisya <150286414+hillary-mutisya@users.noreply.github.com>
Date: Tue, 27 Oct 2026 16:14:05 -0700
Subject: [PATCH 4/4] Exclude question views from gallery queries and fix
 reader review flows

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ts/packages/agents/browser/README.md          | 11 ++-
 .../views/client/library/memoryHubFlyout.ts   |  3 +
 .../client/library/memoryHubInbox.test.ts     | 28 ++++++++
 .../views/client/library/memoryHubInbox.ts    | 10 +++
 .../library/memoryHubInventoryTestData.ts     |  6 +-
 .../client/library/memoryHubQuestions.test.ts | 69 +++++++++++++++++++
 .../client/library/memoryHubQuestions.ts      | 25 ++++---
 .../client/library/memoryHubViews.test.ts     | 59 ++++++++++++++++
 .../views/client/library/memoryHubViews.ts    |  1 +
 .../memory/client/src/inventoryProtocol.ts    | 26 +++----
 .../client/test/schemaViewProtocol.spec.mjs   | 26 +++++++
 ts/packages/memory/service/README.md          |  3 +
 .../memory/service/src/fileMemoryService.ts   |  3 +
 .../memory/service/src/inventoryTypes.ts      |  1 +
 .../memory/service/test/schemaViews.spec.ts   | 15 ++++
 15 files changed, 258 insertions(+), 28 deletions(-)

diff --git a/ts/packages/agents/browser/README.md b/ts/packages/agents/browser/README.md
index 1e03bb217d..7e161abbf9 100644
--- a/ts/packages/agents/browser/README.md
+++ b/ts/packages/agents/browser/README.md
@@ -80,6 +80,11 @@ and Troubleshooting Guide. Questions has its own left-navigation entry rather
 than a duplicate Views filter tab. Collection-maintenance entry points use the
 screwdriver-and-wrench icon.
 
+The Views gallery sends `excludeKinds: ["schemaView"]` to the view-summary query,
+including on subsequent pages. The service excludes question views before
+pagination and totals; the dedicated Questions workspace and
+explicit schema-view reader links remain supported.
+
 Views and Questions place those tabs directly after the page title. Their lists,
 search controls and bottom pagination live in Sources-style surface cards with
 server-reported totals in the upper-right corner, not loaded-page counts.
@@ -118,9 +123,10 @@ retry, history and exact evidence. Back returns to the previous scoped inventory
 with its filters and paging; direct links can load slots outside the current page
 without scanning every collection.
 
-Question route transitions clear old controls before fetching. Reader edit heads
+Question route transitions clear old controls before fetching. Reader mutation heads
 are refreshed for the exact reader corpus/view independently of the preserved
-inventory scope. Pending operations block navigation, and background polling
+inventory scope, including direct-link discovery and discovery after an edit.
+Discovery refreshes reader metadata before another mutation. Pending operations block navigation, and background polling
 does not reload an unsaved reader draft.
 
 Graph toolbars include an on-demand, keyboard-accessible item picker for the
@@ -131,6 +137,7 @@ restoring the removed graph coverage and browse disclosures.
 Inbox detail panels survive unchanged and unrelated count refreshes. Stable item
 identities and state fingerprints close a panel only when its selected item
 changes or disappears; category navigation and scope resets still close it.
+Retained panels restore focus to the replacement Review button after a refresh.
 
 The Memory hub's Questions workspace is a complete projection of versioned
 schema-view slots, including proposed and rejected slots. The inspector reviews
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubFlyout.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubFlyout.ts
index aec94aa6c8..5ca3d935c7 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubFlyout.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubFlyout.ts
@@ -67,6 +67,9 @@ export function mountFlyout(host: HTMLElement, label: string) {
     });
     return {
         isOpen: () => !panel.hidden,
+        setReturnFocus(target: HTMLElement) {
+            opener = target;
+        },
         open(view: FlyoutView) {
             if (panel.hidden && document.activeElement instanceof HTMLElement)
                 opener = document.activeElement;
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
index ebb568e1ae..adc254c10b 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.test.ts
@@ -203,6 +203,34 @@ test("count refreshes retain unchanged details but changed or removed selected i
     inbox.setCount("views", 0);
     expect(panel.hidden).toBe(true);
 });
+test.each(["all", "views"])(
+    "retained details restore focus to the replacement Review button in %s",
+    (category) => {
+        const { host, inbox, views, add } = setup();
+        add(views, "Retained view");
+        inbox.setCount("views", 1);
+        if (category === "views") button(host, "Views (1)").click();
+        const currentPanel = host.querySelector<HTMLElement>(
+            `#inbox-panel-${category}`,
+        )!;
+        const original = button(currentPanel, "Review: Retained view");
+        original.focus();
+        original.click();
+        const details = host.querySelector<HTMLElement>(
+            'aside[aria-label="Inbox details"]',
+        )!;
+        inbox.setCount("operations", 2);
+        views.replaceChildren();
+        add(views, "Retained view");
+        inbox.setCount("views", 1);
+        expect(details.hidden).toBe(false);
+        const replacement = button(currentPanel, "Review: Retained view");
+        expect(replacement).not.toBe(original);
+        expect(original.isConnected).toBe(false);
+        button(details, "Close").click();
+        expect(document.activeElement).toBe(replacement);
+    },
+);
 
 test("distinguishes loading and errors from empty counts and resets details on scope changes", () => {
     const { host, inbox, views, add } = setup();
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
index 37bfa9f026..681abc25fe 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInbox.ts
@@ -236,6 +236,16 @@ export function mountMemoryHubInbox(
                 : "All (...)",
         );
         overview.replaceChildren(...sections.map(renderCategory));
+        if (inspector.isOpen() && active) {
+            const replacement = [
+                ...panels
+                    .get(selected)!
+                    .querySelectorAll<HTMLElement>(".hub-inbox-item"),
+            ].find((item) => cards.get(item)?.id === active?.card.id);
+            const review =
+                replacement?.querySelector<HTMLButtonElement>("button");
+            if (review) inspector.setReturnFocus(review);
+        }
         if (restoreTabFocus) buttons.get(selected)!.focus();
     }
     select("all");
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubInventoryTestData.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubInventoryTestData.ts
index 79595235f2..a5b4445f59 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubInventoryTestData.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubInventoryTestData.ts
@@ -6,6 +6,7 @@ import type {
     ViewVersion,
     ViewBuildJob,
     InventoryPageRequest,
+    ViewSummaryRequest,
 } from "@typeagent/memory-service";
 
 type Fixture = (method: string, params?: unknown) => unknown | Promise<unknown>;
@@ -28,6 +29,7 @@ export function inventoryFixture(legacy: Fixture): Fixture {
         const request = params as InventoryPageRequest;
         const corpus = { corpusId: request?.corpusId };
         if (method === "memoryListViewSummaries") {
+            const filters = params as ViewSummaryRequest;
             const snapshot = (await legacy("memoryListViews", corpus)) as {
                 head: string | null;
                 views: ViewVersion[];
@@ -68,7 +70,9 @@ export function inventoryFixture(legacy: Fixture): Fixture {
                 ...page(
                     items.filter(
                         (item) =>
-                            !request.viewId || item.viewId === request.viewId,
+                            (!filters.viewId ||
+                                item.viewId === filters.viewId) &&
+                            !filters.excludeKinds?.includes(item.content.kind),
                     ),
                     request,
                 ),
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
index f0c7768b82..f069b5ae22 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.test.ts
@@ -217,6 +217,75 @@ test("a new slot route removes old edit controls before loading and after a deta
     expect(onError).toHaveBeenCalledTimes(1);
 });
 
+test.each([false, true])(
+    "direct reader discovery uses the current reader head and refreshes it afterward (edited first: %s)",
+    async (editedFirst) => {
+        const original = invoke.getMockImplementation()!;
+        let version = 2;
+        invoke.mockImplementation((method, params) => {
+            if (method === "memoryGetQuestion")
+                return Promise.resolve({
+                    ...question("slot", "view"),
+                    viewVersion: version,
+                });
+            if (method === "memoryListQuestionSummaries")
+                return Promise.resolve({
+                    head: `head-${version}`,
+                    items: [],
+                    total: 0,
+                });
+            if (
+                method === "memoryEditQuestion" ||
+                method === "memoryDiscoverSchemaQuestions"
+            ) {
+                version++;
+                return Promise.resolve({});
+            }
+            return original(method, params);
+        });
+        const { panel, onError } = setup();
+        await panel.show("view", "corpus", "slot");
+        if (editedFirst) {
+            const editor = document.querySelector<HTMLTextAreaElement>(
+                ".hub-qdetail textarea",
+            )!;
+            editor.value = '"Updated answer"';
+            editor.dispatchEvent(new Event("input"));
+            click("Save user assertion");
+            await settle();
+        }
+        for (let count = 0; count < 2; count++) {
+            const expectedVersion = version;
+            click("More question actions");
+            click("Discover question proposals");
+            await settle();
+            expect(invoke).toHaveBeenLastCalledWith(
+                "memoryListQuestionSummaries",
+                {
+                    corpusId: "corpus",
+                    viewId: "view",
+                    pageSize: 1,
+                },
+            );
+            expect(invoke).toHaveBeenCalledWith(
+                "memoryDiscoverSchemaQuestions",
+                {
+                    corpusId: "corpus",
+                    viewId: "view",
+                    expectedHead: `head-${expectedVersion}`,
+                    expectedVersion,
+                },
+            );
+            expect(document.querySelector(".hub-view-infobox")).not.toBeNull();
+        }
+        expect(
+            invoke.mock.calls.filter(
+                ([method]) => method === "memoryDiscoverSchemaQuestions",
+            ),
+        ).toHaveLength(2);
+        expect(onError).not.toHaveBeenCalled();
+    },
+);
 test("cross-collection readers refresh their own edit head independently of the list scope", async () => {
     const original = invoke.getMockImplementation()!;
     let version = 2;
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
index b085736ee6..28db765b74 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubQuestions.ts
@@ -303,24 +303,31 @@ export function mountMemoryHubQuestions(
         }
         return section;
     }
-    async function edit(question: MemoryQuestion, edit: QuestionEdit) {
-        const current = detailSequence;
+    function questionHead(question: QuestionTarget) {
         if (
             readerHead === undefined ||
-            selectedKey !== questionIdentity(question)
+            selectedKey !== questionIdentity(question) ||
+            reader.hidden
         )
             throw new Error(
-                "Question inventory is unavailable. Reload the question before editing.",
+                "Question inventory is unavailable. Reload the question before modifying it.",
             );
+        return readerHead;
+    }
+    async function edit(question: MemoryQuestion, edit: QuestionEdit) {
+        const current = detailSequence;
         await invokeMemory("memoryEditQuestion", {
             corpusId: question.corpusId,
             viewId: question.viewId,
             slotId: question.slot.id,
-            expectedHead: readerHead,
+            expectedHead: questionHead(question),
             expectedVersion: question.viewVersion,
             edit,
         });
         dirty = false;
+        await refreshReader(question, current);
+    }
+    async function refreshReader(question: QuestionTarget, current: number) {
         loadedAt = 0;
         const updated = await fetchQuestion(question);
         if (current !== detailSequence || reader.hidden) return;
@@ -697,15 +704,15 @@ export function mountMemoryHubQuestions(
                 icon: "fa-wand-magic-sparkles",
                 action: () =>
                     action(async () => {
+                        const current = detailSequence;
                         await invokeMemory("memoryDiscoverSchemaQuestions", {
                             corpusId: question.corpusId,
                             viewId: question.viewId,
-                            expectedHead: inventories.get(question.corpusId)!
-                                .head,
+                            expectedHead: questionHead(question),
                             expectedVersion: question.viewVersion,
                         });
-                        await refresh();
-                        inspector.replaceChildren(
+                        await refreshReader(question, current);
+                        inspector.prepend(
                             rbNode(
                                 "p",
                                 "Discovery completed. Review proposals in the inventory; they are not approved facts.",
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts
index 7b47998550..b2f5f92d75 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.test.ts
@@ -280,6 +280,64 @@ describe("Memory Center preview-first views", () => {
         click(host, "Compare and resolve conflict");
         await settle();
     }
+    test("All excludes question views in every inventory request before totals and paging", async () => {
+        const original = invoke.getMockImplementation()!;
+        invoke.mockImplementation(
+            inventoryFixture(async (method, params) => {
+                if (method === "memoryListViews")
+                    return {
+                        head,
+                        views: [
+                            ...Array.from({ length: 25 }, (_, index) => ({
+                                ...view,
+                                viewId: `question-${index}`,
+                                content: {
+                                    ...content,
+                                    kind: "schemaView",
+                                    title: `Hidden question ${index}`,
+                                },
+                            })),
+                            ...Array.from({ length: 30 }, (_, index) => ({
+                                ...view,
+                                viewId: `guide-${index}`,
+                                content: {
+                                    ...content,
+                                    title: `Visible guide ${index}`,
+                                },
+                            })),
+                        ],
+                    };
+                return original(method, params);
+            }),
+        );
+        await panel.refresh();
+        let card = host.querySelector('[aria-label="Views list"]')!;
+        expect(card.querySelector(".hub-list-total")!.textContent).toBe(
+            "30 total",
+        );
+        expect(card.querySelectorAll(".hub-view-card")).toHaveLength(25);
+        expect(card.textContent).not.toContain("Hidden question");
+        click(host, "Next views page");
+        await settle();
+        card = host.querySelector('[aria-label="Views list"]')!;
+        expect(card.querySelectorAll(".hub-view-card")).toHaveLength(5);
+        expect(card.querySelector(".hub-list-total")!.textContent).toBe(
+            "30 total",
+        );
+        expect(card.textContent).not.toContain("Hidden question");
+        const requests = invoke.mock.calls
+            .filter(([method]) => method === "memoryListViewSummaries")
+            .map(([, request]) => request);
+        expect(requests).toEqual([
+            { corpusId: "c", pageSize: 25, excludeKinds: ["schemaView"] },
+            {
+                corpusId: "c",
+                pageSize: 25,
+                continuationToken: "25",
+                excludeKinds: ["schemaView"],
+            },
+        ]);
+    });
     test("gallery puts tabs before its white list card and shows the server total, not the loaded count", async () => {
         const original = invoke.getMockImplementation()!;
         invoke.mockImplementation(async (method, params) => {
@@ -791,6 +849,7 @@ describe("Memory Center preview-first views", () => {
         expect(invoke).toHaveBeenCalledWith("memoryListViewSummaries", {
             corpusId: "c",
             pageSize: 25,
+            excludeKinds: ["schemaView"],
         });
         expect(
             invoke.mock.calls.filter(([method]) =>
diff --git a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts
index 0fc88379ce..c52335375b 100644
--- a/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts
+++ b/ts/packages/agents/browser/src/views/client/library/memoryHubViews.ts
@@ -449,6 +449,7 @@ export function mountMemoryHubViews(
                     ...(route
                         ? { viewId: route.viewId, pageSize: 1 }
                         : {
+                              excludeKinds: ["schemaView"],
                               ...(searchQuery ? { query: searchQuery } : {}),
                               ...(selectedKind ? { kind: selectedKind } : {}),
                           }),
diff --git a/ts/packages/memory/client/src/inventoryProtocol.ts b/ts/packages/memory/client/src/inventoryProtocol.ts
index 362c3fea53..5b2dfc1664 100644
--- a/ts/packages/memory/client/src/inventoryProtocol.ts
+++ b/ts/packages/memory/client/src/inventoryProtocol.ts
@@ -22,16 +22,16 @@ export const inventoryPageRequestSchema = z.strictObject({
     query: z.string().max(1000).optional(),
     viewId: id.optional(),
 });
+const viewKindSchema = z.enum([
+    "wiki",
+    "projectBrief",
+    "timeline",
+    "schemaView",
+    "troubleshootingGuide",
+]);
 export const viewSummaryRequestSchema = inventoryPageRequestSchema.extend({
-    kind: z
-        .enum([
-            "wiki",
-            "projectBrief",
-            "timeline",
-            "schemaView",
-            "troubleshootingGuide",
-        ])
-        .optional(),
+    kind: viewKindSchema.optional(),
+    excludeKinds: viewKindSchema.array().max(5).optional(),
 });
 export const questionSummaryRequestSchema = inventoryPageRequestSchema.extend({
     viewId: id.optional(),
@@ -68,13 +68,7 @@ export const viewSummarySchema = viewVersionSchema
     })
     .extend({
         content: z.strictObject({
-            kind: z.enum([
-                "wiki",
-                "projectBrief",
-                "timeline",
-                "schemaView",
-                "troubleshootingGuide",
-            ]),
+            kind: viewKindSchema,
             title: z.string(),
         }),
         maintained: z.boolean(),
diff --git a/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs b/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs
index 2e8b8266c6..dc552fb109 100644
--- a/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs
+++ b/ts/packages/memory/client/test/schemaViewProtocol.spec.mjs
@@ -23,6 +23,7 @@ import {
     projectAcquisitionProgress,
     safeAcquisitionOperation,
     viewBuildSummarySchema,
+    viewSummaryRequestSchema,
 } from "../dist/index.js";
 
 const view = JSON.parse(
@@ -34,6 +35,31 @@ const base = {
     expectedHead: null,
     expectedVersion: 1,
 };
+test("view inventory queries accept bounded kind exclusions without changing default discovery", () => {
+    const request = {
+        corpusId: "corpus",
+        pageSize: 1,
+        excludeKinds: ["schemaView"],
+    };
+    assert.deepEqual(viewSummaryRequestSchema.parse(request), request);
+    assert.deepEqual(viewSummaryRequestSchema.parse({ corpusId: "corpus" }), {
+        corpusId: "corpus",
+    });
+    assert.equal(
+        viewSummaryRequestSchema.safeParse({
+            ...request,
+            excludeKinds: ["unknown"],
+        }).success,
+        false,
+    );
+    assert.equal(
+        viewSummaryRequestSchema.safeParse({
+            ...request,
+            excludeKinds: Array(6).fill("schemaView"),
+        }).success,
+        false,
+    );
+});
 test("build summaries preserve lightweight conflict state and accept legacy responses", () => {
     const summary = {
         jobId: "00000000-0000-4000-8000-000000000001",
diff --git a/ts/packages/memory/service/README.md b/ts/packages/memory/service/README.md
index 7d9b3b5856..9a0e75812a 100644
--- a/ts/packages/memory/service/README.md
+++ b/ts/packages/memory/service/README.md
@@ -31,6 +31,9 @@ View, build and publication summary operations avoid loading full evidence bodie
 for list navigation. A committed read projection preserves historical conflict
 fallback and source eligibility checks. View/event index preparation can release
 the writer lease, then revalidates captured evidence before installation.
+View-summary requests support optional `excludeKinds` filtering before paging
+and totals. Callers without this filter still receive every eligible kind;
+explicit question/schema-view lookups and question inventories are unchanged.
 Build-result summaries include optional `conflictState` metadata (`pending`,
 `resolved`, or `missing`) so attention lists need not fetch full conflict
 snapshots. Older clients may ignore this field; clients connected to older
diff --git a/ts/packages/memory/service/src/fileMemoryService.ts b/ts/packages/memory/service/src/fileMemoryService.ts
index 0eb5a59c98..57b97a1a41 100644
--- a/ts/packages/memory/service/src/fileMemoryService.ts
+++ b/ts/packages/memory/service/src/fileMemoryService.ts
@@ -14431,6 +14431,9 @@ export class FileMemoryService
                                 view.viewId === request.viewId) &&
                             (!request.kind ||
                                 view.content.kind === request.kind) &&
+                            !request.excludeKinds?.includes(
+                                view.content.kind,
+                            ) &&
                             view.content.title.toLowerCase().includes(query),
                     )
                     .sort((a, b) => a.viewId.localeCompare(b.viewId));
diff --git a/ts/packages/memory/service/src/inventoryTypes.ts b/ts/packages/memory/service/src/inventoryTypes.ts
index fb9b1514cc..c8ba50ae19 100644
--- a/ts/packages/memory/service/src/inventoryTypes.ts
+++ b/ts/packages/memory/service/src/inventoryTypes.ts
@@ -23,6 +23,7 @@ export interface InventoryPageRequest {
 }
 export interface ViewSummaryRequest extends InventoryPageRequest {
     kind?: ViewDefinition["kind"];
+    excludeKinds?: ViewDefinition["kind"][];
 }
 export interface QuestionSummaryRequest extends InventoryPageRequest {
     viewId?: string;
diff --git a/ts/packages/memory/service/test/schemaViews.spec.ts b/ts/packages/memory/service/test/schemaViews.spec.ts
index 40c1b19e56..d18b9d2f6e 100644
--- a/ts/packages/memory/service/test/schemaViews.spec.ts
+++ b/ts/packages/memory/service/test/schemaViews.spec.ts
@@ -736,6 +736,21 @@ describe("ordinary-source schema lifecycle", () => {
             targets,
         });
         await settled(job);
+        const views = await service.listViewSummaries({
+            corpusId,
+            pageSize: 1,
+        });
+        expect(views.total).toBe(2);
+        expect(views.items[0].content.kind).toBe("schemaView");
+        expect(views.nextContinuationToken).toBe("1");
+        const gallery = await service.listViewSummaries({
+            corpusId,
+            pageSize: 1,
+            excludeKinds: ["schemaView"],
+        });
+        expect(gallery.items).toEqual([]);
+        expect(gallery.total).toBe(0);
+        expect(gallery.nextContinuationToken).toBeUndefined();
         const first = await service.listQuestionSummaries({ corpusId });
         expect(first.items).toHaveLength(25);
         expect(first.total).toBe(30);