fix(node-ui): canonicalize context graph layer counts

Author: Jurij Skornik

packages/node-ui/src/ui/hooks/useMemoryEntities.ts

@@ -410,11 +410,14 @@ export function useMemoryEntities(
   }, [entities]);
 
   const counts = useMemo(() => {
-    const wm = new Set(layeredTriples.filter(t => t.layer === 'working').map(t => t.subject)).size;
-    const swm = new Set(layeredTriples.filter(t => t.layer === 'shared').map(t => t.subject)).size;
-    const vm = new Set(layeredTriples.filter(t => t.layer === 'verified').map(t => t.subject)).size;
-    return { wm, swm, vm, total: entities.size };
-  }, [layeredTriples, entities]);
+    let wm = 0, swm = 0, vm = 0;
+    for (const entity of entityList) {
+      if (entity.trustLevel === 'verified') vm++;
+      else if (entity.trustLevel === 'shared') swm++;
+      else wm++;
+    }
+    return { wm, swm, vm, total: entityList.length };
+  }, [entityList]);
 
   return {
     entities,

packages/node-ui/src/ui/views/project/components.tsx

@@ -573,12 +573,13 @@ export function MemoryStrip({
     color: string;
     icon: string;
     entities: MemoryEntity[];
+    count: number;
     promoteLabel: string | null;
     viewLayer: LayerView;
   }> = [
-    { key: 'wm', label: 'Working Memory', color: '#64748b', icon: '◇', entities: layerEntities.wm, promoteLabel: 'Promote All → Shared', viewLayer: 'wm' },
-    { key: 'swm', label: 'Shared Working Memory', color: '#f59e0b', icon: '◈', entities: layerEntities.swm, promoteLabel: 'Publish to Verified Memory', viewLayer: 'swm' },
-    { key: 'vm', label: 'Verified Memory', color: '#22c55e', icon: '◉', entities: layerEntities.vm, promoteLabel: null, viewLayer: 'vm' },
+    { key: 'wm', label: 'Working Memory', color: '#64748b', icon: '◇', entities: layerEntities.wm, count: memory.counts.wm, promoteLabel: 'Promote All → Shared', viewLayer: 'wm' },
+    { key: 'swm', label: 'Shared Working Memory', color: '#f59e0b', icon: '◈', entities: layerEntities.swm, count: memory.counts.swm, promoteLabel: 'Publish to Verified Memory', viewLayer: 'swm' },
+    { key: 'vm', label: 'Verified Memory', color: '#22c55e', icon: '◉', entities: layerEntities.vm, count: memory.counts.vm, promoteLabel: null, viewLayer: 'vm' },
   ];
 
   return (
@@ -594,7 +595,7 @@ export function MemoryStrip({
             >
               <div className="v10-layer-label" style={{ color: layer.color }}>
                 <span className="v10-layer-abbr">{layer.label}</span>
-                <span className="v10-layer-count">{layer.entities.length}</span>
+                <span className="v10-layer-count">{layer.count}</span>
               </div>
               <div className="v10-layer-items">
                 <span className="v10-layer-chevron">▸</span>
@@ -754,8 +755,9 @@ export function TypeBreakdownWidget({ entities }: { entities: MemoryEntity[] })
   );
 }
 
-export function LayerStatsWidget({ entities, triples, layer }: {
+export function LayerStatsWidget({ entities, entityCount, triples, layer }: {
   entities: MemoryEntity[];
+  entityCount: number;
   triples: number;
   layer: 'wm' | 'swm' | 'vm';
 }) {
@@ -779,7 +781,7 @@ export function LayerStatsWidget({ entities, triples, layer }: {
       <div className="v10-layer-summary">
         <div className="v10-layer-summary-stat">
           <span className="v10-layer-summary-label">Knowledge Assets</span>
-          <span className="v10-layer-summary-value">{entities.length}</span>
+          <span className="v10-layer-summary-value">{entityCount}</span>
         </div>
         <div className="v10-layer-summary-stat">
           <span className="v10-layer-summary-label">Triples</span>
@@ -872,14 +874,15 @@ export function LayerActionsWidget({ layer, count, contextGraphId, onComplete }:
 
 // ─── Horizontal widget strip (stats + types + CTA) for the Entities tab ──
 
-export function LayerWidgetStrip({ layer, entities, tripleCount, contextGraphId, onComplete }: {
+export function LayerWidgetStrip({ layer, entities, entityCount, tripleCount, contextGraphId, onComplete }: {
   layer: 'wm' | 'swm' | 'vm';
   entities: MemoryEntity[];
+  entityCount: number;
   tripleCount: number;
   contextGraphId?: string;
   onComplete?: () => void;
 }) {
-  if (entities.length === 0) {
+  if (entityCount === 0) {
     return (
       <div className="v10-layer-widgets-strip empty">
         <div className="v10-canvas-empty">
@@ -894,12 +897,12 @@ export function LayerWidgetStrip({ layer, entities, tripleCount, contextGraphId,
   return (
     <div className="v10-layer-widgets-strip">
       <div className="v10-layer-widgets-strip-stats">
-        <LayerStatsWidget entities={entities} triples={tripleCount} layer={layer} />
+        <LayerStatsWidget entities={entities} entityCount={entityCount} triples={tripleCount} layer={layer} />
         <TypeBreakdownWidget entities={entities} />
       </div>
       {(layer === 'wm' || layer === 'swm') && (
         <div className="v10-layer-widgets-strip-action">
-          <LayerActionsWidget layer={layer} count={entities.length} contextGraphId={contextGraphId} onComplete={onComplete} />
+          <LayerActionsWidget layer={layer} count={entityCount} contextGraphId={contextGraphId} onComplete={onComplete} />
         </div>
       )}
     </div>
@@ -1051,6 +1054,7 @@ export function LayerContent({
   const isInitialVerifiedMemoryLoad = layer === 'vm' && vmLayerStatus === 'loading' && entities.length === 0;
   const isVerifiedMemoryUnavailable = layer === 'vm' && vmLayerStatus === 'error' && entities.length === 0;
   const isEmptyVerifiedMemory = layer === 'vm' && vmLayerStatus === 'ok' && entities.length === 0;
+  const entityCount = memory.counts[layer];
 
   const handleTab = (tab: LayerContentTab) => (e: React.MouseEvent) => {
     e.stopPropagation();
@@ -1112,6 +1116,7 @@ export function LayerContent({
               <LayerWidgetStrip
                 layer={layer}
                 entities={entities}
+                entityCount={entityCount}
                 tripleCount={tripleCount}
                 contextGraphId={contextGraphId}
                 onComplete={memory.refresh}

packages/node-ui/test/use-memory-entities-counts.test.ts

@@ -0,0 +1,125 @@
+// @vitest-environment happy-dom
+
+import React, { act } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createRoot, type Root } from 'react-dom/client';
+import { useMemoryEntities } from '../src/ui/hooks/useMemoryEntities.js';
+
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const MENTIONS = 'http://schema.org/mentions';
+
+class MockEventSource {
+  static instances: MockEventSource[] = [];
+  readonly listeners = new Map<string, Array<(e: MessageEvent) => void>>();
+  constructor(readonly url: string) { MockEventSource.instances.push(this); }
+  addEventListener(t: string, l: (e: MessageEvent) => void) {
+    const a = this.listeners.get(t) ?? [];
+    a.push(l);
+    this.listeners.set(t, a);
+  }
+  close() {}
+}
+
+function typeBinding(subject: string, graph: string) {
+  return {
+    s: { value: subject },
+    p: { value: RDF_TYPE },
+    o: { value: 'http://schema.org/Thing' },
+    g: { value: graph },
+  };
+}
+
+function uriBinding(subject: string, predicate: string, object: string, graph: string) {
+  return {
+    s: { value: subject },
+    p: { value: predicate },
+    o: { value: object },
+    g: { value: graph },
+  };
+}
+
+function Probe({ id }: { id: string }) {
+  const memory = useMemoryEntities(id);
+  return React.createElement('div', {
+    id: 'probe',
+    'data-loading': String(memory.loading),
+    'data-wm': String(memory.counts.wm),
+    'data-swm': String(memory.counts.swm),
+    'data-vm': String(memory.counts.vm),
+    'data-total': String(memory.counts.total),
+    'data-current-layers': memory.entityList.map(e => `${e.uri}:${e.trustLevel}`).join('|'),
+  });
+}
+
+async function flush() {
+  await act(async () => {
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+}
+
+describe('useMemoryEntities canonical layer counts', () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    MockEventSource.instances = [];
+    (globalThis as any).EventSource = MockEventSource;
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+    container = document.createElement('div');
+    document.body.appendChild(container);
+    root = createRoot(container);
+
+    vi.stubGlobal('fetch', vi.fn(async (_url: string, init?: RequestInit) => {
+      const { sparql = '', contextGraphId = 'cg' } =
+        JSON.parse(String(init?.body ?? '{}')) as { sparql?: string; contextGraphId?: string };
+      const isVm = sparql.includes('_verified_memory_meta');
+      const isSwm = !isVm && sparql.includes('STRENDS');
+      const graphBase = `did:dkg:context-graph:${contextGraphId}`;
+      const bindings = isVm
+        ? [
+            typeBinding('urn:test:verified', graphBase),
+            typeBinding('urn:test:full-pipeline', graphBase),
+          ]
+        : isSwm
+          ? [
+              typeBinding('urn:test:promoted', `${graphBase}/notes/_shared_memory`),
+              typeBinding('urn:test:full-pipeline', `${graphBase}/notes/_shared_memory`),
+            ]
+          : [
+              typeBinding('urn:test:promoted', `${graphBase}/notes/assertion/agent/a-1`),
+              typeBinding('urn:test:full-pipeline', `${graphBase}/notes/assertion/agent/a-1`),
+              typeBinding('urn:test:draft', `${graphBase}/notes/assertion/agent/a-2`),
+              typeBinding('urn:test:draft', `${graphBase}/docs/assertion/agent/a-3`),
+              uriBinding('urn:test:draft', MENTIONS, 'urn:test:object-only', `${graphBase}/docs/assertion/agent/a-3`),
+            ];
+      return {
+        ok: true,
+        json: async () => ({ result: { bindings } }),
+      } as Response;
+    }));
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it('counts each visible entity once in its current highest layer', async () => {
+    await act(async () => {
+      root.render(React.createElement(Probe, { id: 'cg-counts' }));
+    });
+    await flush();
+
+    const el = container.querySelector('#probe')!;
+    expect(el.getAttribute('data-loading')).toBe('false');
+    expect(el.getAttribute('data-wm')).toBe('1');
+    expect(el.getAttribute('data-swm')).toBe('1');
+    expect(el.getAttribute('data-vm')).toBe('2');
+    expect(el.getAttribute('data-total')).toBe('4');
+    expect(el.getAttribute('data-current-layers')).toContain('urn:test:promoted:shared');
+    expect(el.getAttribute('data-current-layers')).toContain('urn:test:full-pipeline:verified');
+    expect(el.getAttribute('data-current-layers')).not.toContain('urn:test:object-only');
+  });
+});

packages/node-ui/test/use-memory-entities-live-updates.test.ts

@@ -43,7 +43,9 @@ function tripleBinding(subject: string, graph: string) {
 }
 
 function bindingsForLayer(sparql: string, contextGraphId: string, revision: number) {
-  if (!sparql.includes('/assertion/')) return [];
+  const isVm = sparql.includes('_verified_memory_meta');
+  const isSwm = !isVm && sparql.includes('STRENDS');
+  if (isVm || isSwm) return [];
   return Array.from({ length: revision }, (_, i) =>
     tripleBinding(
       `urn:test:${contextGraphId}:wm-${i + 1}`,