fix(node-ui): round-3 Codex — SWM assertionGraph guard + VM/discarded empty-state copy

Round-3 review fixes on the S4 assertion detail view (kept as a focused
4th commit rather than folded into C1 — the fixup's helpers.ts hunk
overlaps C2's breadcrumb helpers + C3's primarySubGraphOf, so an
autosquash into C1 conflicts mechanically; a standalone commit is the
clean, conflict-free shape team-lead OK'd).

- Finding 2 (api.ts fetchAssertionState): the assertionGraph fallback
  was URI-shape-unsafe. For an SWM input (a `urn:dkg:assertion:…`
  lifecycle URN) whose `dkg:assertionGraph` did NOT resolve
  (legacy/partial `_meta` row), echoing the URN made fetchAssertionTriples
  query `GRAPH <urn:…>` (a graph that never holds triples) → bogus render.
  Now: urn-input + unresolved → assertionGraph: undefined (Triples/Entities
  fall to their empty-state). WM data-graph-URI input still echoes itself.

- Finding 3 (assertionEmptyStateCopy, ux §4.7.1 locked): the empty-state
  copy now keys off `dkg:state` (4 branches) instead of special-casing
  promoted only — published/finalized show the VM / Knowledge-Assets line
  ("entities → Knowledge Assets" at the VM boundary, §4.8), discarded is
  terminal, created/promoted unchanged. Plain text, no links.

- Finding 1 (remote SWM state) reply-not-valid (no replicated state
  source); finding-1 round-2 discarded-neutral badge + finding-2 round-2
  literal-display decode already shipped earlier in C1.

Tests: SWM-legacy-no-assertionGraph guard + WM-echo counterpart
(use-assertion-state); assertionEmptyStateCopy 4-branch truth table
(assertion-detail-helpers); published empty-state DOM render
(assertion-detail-view). Finding-2 guard negative-proofed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Jurij Skornik

packages/node-ui/src/ui/api.ts

@@ -841,10 +841,22 @@ export async function fetchAssertionState(
   const metaGraph = `did:dkg:context-graph:${contextGraphId}/_meta`;
   // UNION admits both `graphUri` shapes (WM data-graph URI via the
   // inverse `dkg:assertionGraph` link; SWM lifecycle URN directly).
+  //
+  // Codex round-4 — branch A binds the input AS `?lifecycle`
+  // UNCONDITIONALLY and resolves `dkg:assertionGraph` only OPTIONALLY, so
+  // a legacy/partial SWM row whose lifecycle URN carries `dkg:state` but
+  // NOT `dkg:assertionGraph` still resolves its state (pre-fix, branch A
+  // required the assertionGraph triple to bind `?lifecycle`, so such a
+  // row read no state → "state unavailable" though the state exists).
+  // The outer `?lifecycle dkg:state` then gates the row: for a WM
+  // data-graph-URI input, branch A binds `?lifecycle = <data-graph URI>`
+  // but `<data-graph URI> dkg:state` never matches (state lives on the
+  // lifecycle URN), so branch A contributes nothing and branch B handles
+  // WM exactly as before. So WM→B, SWM→A, SWM-no-assertionGraph→A.
   const sparql = `SELECT ?state ?layer ?createdBy ?assertionGraph WHERE {
     GRAPH <${metaGraph}> {
-      { <${graphUri}> <${DKG}assertionGraph> ?assertionGraph .
-        BIND(<${graphUri}> AS ?lifecycle) }
+      { BIND(<${graphUri}> AS ?lifecycle)
+        OPTIONAL { <${graphUri}> <${DKG}assertionGraph> ?assertionGraph } }
       UNION
       { ?lifecycle <${DKG}assertionGraph> <${graphUri}> .
         BIND(<${graphUri}> AS ?assertionGraph) }
@@ -871,13 +883,23 @@ export async function fetchAssertionState(
     state === 'created' ? 'wm' :
     state === 'promoted' ? 'swm' :
     'vm';
+  // The data graph to read triples from. Prefer the resolved
+  // `dkg:assertionGraph`. Codex round-3 — the fallback to `graphUri`
+  // itself is only safe when the INPUT is already a data-graph URI (the
+  // WM shape). For an SWM input (a `urn:dkg:assertion:…` lifecycle URN)
+  // whose `dkg:assertionGraph` did NOT resolve (legacy/partial `_meta`
+  // row), echoing the URN would make `fetchAssertionTriples` query
+  // `GRAPH <urn:dkg:assertion:…>` — a graph that never holds triples —
+  // and render a bogus "data" set. In that case return `undefined` so
+  // the Triples/Entities panes fall to their empty-state instead.
+  const resolvedAssertionGraph = bv(first.assertionGraph);
+  const inputIsLifecycleUrn = graphUri.startsWith('urn:dkg:assertion:');
+  const assertionGraph = resolvedAssertionGraph
+    ?? (inputIsLifecycleUrn ? undefined : graphUri);
   return {
     state,
     layer,
-    // The data graph to read triples from: the resolved
-    // `dkg:assertionGraph` (correct for the SWM lifecycle-URN input),
-    // falling back to the input itself (the WM data-graph URI input).
-    assertionGraph: bv(first.assertionGraph) ?? graphUri,
+    assertionGraph,
     createdBy: bv(first.createdBy),
   };
 }
@@ -961,6 +983,12 @@ function rawBindingValue(v: unknown): string | undefined {
       if (datatype) return `"${escaped}"^^<${datatype}>`;
       return `"${escaped}"`;
     }
+    // Codex round-5 — a blank node must come back as `_:<id>`, not the
+    // bare identifier; otherwise downstream (buildMemoryEntities + the
+    // graph) misclassify it (a bare id is neither a leading-`"` literal
+    // nor a recognisable resource → bnode RDF structure disappears /
+    // mislabels). Branch BEFORE the generic fallthrough.
+    if (node.type === 'bnode') return `_:${String(node.value)}`;
     return String(node.value);
   }
   if (typeof v === 'string') return v;

packages/node-ui/src/ui/views/ProjectView.tsx

@@ -865,7 +865,12 @@ export function ProjectView({ contextGraphId }: ProjectViewProps) {
         <AssertionDetailView
           assertion={selectedAssertion}
           contextGraphId={contextGraphId}
-          onNavigate={handleNavigate}
+          // Codex round-5 — forward the assertion's layer into
+          // handleNavigate's existing `layerContext` (3rd) param so the
+          // follow-on entity detail stays scoped to the assertion's layer.
+          // AssertionDetailView passes `layer` as the 2nd arg; map it to
+          // the 3rd param (originScrollKey stays undefined).
+          onNavigate={(uri, layer) => handleNavigate(uri, undefined, layer)}
           onComplete={rawMemory.refresh}
           onOpenAgent={openAgent}
         />

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

@@ -67,7 +67,7 @@ import {
   filterTriplesToEntities, admitTripleForScope,
   entityTimestamp, formatRelativeTime, formatTimelineBucket, formatTrailTimestamp,
   canPromoteAssertion, assertionSubgraphLine, buildAssertionTrail,
-  buildBreadcrumbHops,
+  assertionEmptyStateCopy, buildBreadcrumbHops,
   type LayerView, type LayerContentTab, type KAPane,
   type SubGraphTab, type SubGraphEntitySort,
 } from './helpers.js';
@@ -4082,8 +4082,13 @@ export function AssertionDetailView({
 }: {
   assertion: AssertionInfo;
   contextGraphId: string;
-  /** Open an entity from this assertion in the entity-detail view. */
-  onNavigate: (uri: string) => void;
+  /** Open an entity from this assertion in the entity-detail view.
+   *  Codex round-5 — forwards the assertion's resolved `layer` so the
+   *  follow-on entity detail stays scoped to the assertion's layer
+   *  (a WM-assertion entity that ALSO exists in SWM/VM would otherwise
+   *  open the global/canonical detail). Feeds M2's existing
+   *  `handleNavigate(uri, _, layerContext)` channel; no contract reshape. */
+  onNavigate: (uri: string, layer?: 'wm' | 'swm' | 'vm') => void;
   /** Refresh the underlying memory after a successful promote. */
   onComplete: () => void;
   onOpenAgent?: (uri: string) => void;
@@ -4266,20 +4271,27 @@ export function AssertionDetailView({
               {triplesLoading && rootEntities.length === 0 ? (
                 <div className="v10-graph-placeholder">Loading assertion entities...</div>
               ) : rootEntities.length === 0 ? (
-                <EmptyState
-                  compact
-                  tone={toneForLayer(layer)}
-                  icon={layerConfig.icon}
-                  title="No entities in this assertion."
-                  description={stateInfo?.state === 'promoted'
-                    ? 'This assertion was promoted — its entities now live in Shared Working Memory. Open the Shared Working Memory tab to view them.'
-                    : 'This assertion has no extracted entities.'}
-                />
+                (() => {
+                  // ux §4.7.1 locked copy — keyed off the lifecycle state
+                  // so the noun + forward path match the destination layer
+                  // (created / promoted→SWM / published|finalized→VM /
+                  // discarded). See `assertionEmptyStateCopy`.
+                  const copy = assertionEmptyStateCopy(stateInfo?.state);
+                  return (
+                    <EmptyState
+                      compact
+                      tone={toneForLayer(layer)}
+                      icon={layerConfig.icon}
+                      title={copy.title}
+                      description={copy.description}
+                    />
+                  );
+                })()
               ) : (
                 rootEntities.map(e => {
                   const { icon, type } = entityMeta(e, profile);
                   return (
-                    <button key={e.uri} className="v10-ka-conn" onClick={() => onNavigate(e.uri)}>
+                    <button key={e.uri} className="v10-ka-conn" onClick={() => onNavigate(e.uri, layer)}>
                       <span className="v10-ka-conn-target">{icon} {e.label}</span>
                       <span className="v10-ka-conn-pred" style={{ marginLeft: 'auto' }}>{type}</span>
                       <span className="v10-ka-conn-arrow">→</span>
@@ -4345,7 +4357,7 @@ export function AssertionDetailView({
                       options={graphOptions}
                       viewConfig={graphViewConfig}
                       style={{ position: 'absolute', inset: 0, width: '100%', height: '100%' }}
-                      onNodeClick={(n: any) => n?.id && onNavigate(n.id)}
+                      onNodeClick={(n: any) => n?.id && onNavigate(n.id, layer)}
                       initialFit
                     />
                   </Suspense>

packages/node-ui/src/ui/views/project/helpers.ts

@@ -1012,6 +1012,50 @@ export function buildAssertionTrail(
   }));
 }
 
+/**
+ * Empty-state copy for the assertion detail Entities pane when the
+ * assertion has zero entities, keyed off `dkg:state` (ux-lead's locked
+ * §4.7.1 copy — Codex round-3 finding 3). A single generic template was
+ * rejected because the noun changes at the VM boundary (entities →
+ * Knowledge Assets, §4.8) and because the forward path differs per state:
+ *   - created   → genuinely empty draft.
+ *   - promoted  → its entities moved to Shared Working Memory.
+ *   - published / finalized → its entities are now Knowledge Assets in
+ *     Verifiable Memory (post-publish the data graph is empty).
+ *   - discarded → terminal; no forward path (forward-safety — discarded
+ *     isn't list-reachable today, see the badge guard).
+ * Plain text, no links (S4 lock). Title is the constant "No entities in
+ * this assertion." for the live states; discarded gets a terminal title.
+ */
+export function assertionEmptyStateCopy(
+  state: AssertionState | null | undefined,
+): { title: string; description: string } {
+  switch (state) {
+    case 'promoted':
+      return {
+        title: 'No entities in this assertion.',
+        description: 'This assertion was promoted — its entities now live in Shared Working Memory. Open the Shared Working Memory tab to view them.',
+      };
+    case 'published':
+    case 'finalized':
+      return {
+        title: 'No entities in this assertion.',
+        description: 'This assertion was published — its entities are now Knowledge Assets in Verifiable Memory. Open the Verifiable Memory tab to view them.',
+      };
+    case 'discarded':
+      return {
+        title: 'This assertion was discarded.',
+        description: 'This assertion was discarded.',
+      };
+    case 'created':
+    default:
+      return {
+        title: 'No entities in this assertion.',
+        description: 'This assertion has no extracted entities.',
+      };
+  }
+}
+
 /**
  * The primary (first non-`meta`) sub-graph slug an entity has triples
  * in, or null when it lives only in the root bucket / meta. Mirrors the

packages/node-ui/test/assertion-detail-helpers.test.ts

@@ -4,6 +4,7 @@ import {
   canPromoteAssertion,
   assertionSubgraphLine,
   buildAssertionTrail,
+  assertionEmptyStateCopy,
   buildBreadcrumbHops,
   primarySubGraphOf,
 } from '../src/ui/views/project/helpers.js';
@@ -107,6 +108,43 @@ describe('buildAssertionTrail — lifecycle trail stages + is-current marker', (
   });
 });
 
+describe('assertionEmptyStateCopy — ux §4.7.1 state-keyed empty copy (Codex round-3 #3)', () => {
+  it('created → "no extracted entities" (the generalization must NOT loosen this)', () => {
+    const c = assertionEmptyStateCopy('created');
+    expect(c.title).toBe('No entities in this assertion.');
+    expect(c.description).toBe('This assertion has no extracted entities.');
+  });
+
+  it('promoted → SWM forward-path line (unchanged)', () => {
+    const c = assertionEmptyStateCopy('promoted');
+    expect(c.title).toBe('No entities in this assertion.');
+    expect(c.description).toContain('now live in Shared Working Memory');
+    expect(c.description).toContain('Open the Shared Working Memory tab');
+    expect(c.description).not.toContain('no extracted entities');
+  });
+
+  it('published AND finalized → VM / Knowledge-Assets line, NOT "no extracted entities"', () => {
+    for (const s of ['published', 'finalized'] as const) {
+      const c = assertionEmptyStateCopy(s);
+      expect(c.title).toBe('No entities in this assertion.');
+      expect(c.description).toBe('This assertion was published — its entities are now Knowledge Assets in Verifiable Memory. Open the Verifiable Memory tab to view them.');
+      expect(c.description).not.toContain('no extracted entities');
+      expect(c.description).not.toContain('Shared Working Memory');
+    }
+  });
+
+  it('discarded → terminal copy, no "open X tab" forward path', () => {
+    const c = assertionEmptyStateCopy('discarded');
+    expect(c.title).toBe('This assertion was discarded.');
+    expect(c.description).toBe('This assertion was discarded.');
+    expect(c.description).not.toContain('Open the');
+  });
+
+  it('hydrating (null) falls back to the created copy', () => {
+    expect(assertionEmptyStateCopy(null).description).toBe('This assertion has no extracted entities.');
+  });
+});
+
 describe('buildBreadcrumbHops — S5 breadcrumb hop construction (T04)', () => {
   const CG = 'Hello World';
 

packages/node-ui/test/assertion-detail-view.dom.test.ts

@@ -339,6 +339,30 @@ describe('AssertionDetailView', () => {
     );
   });
 
+  // Codex round-3 finding 3 — a published/finalized assertion (empty data
+  // graph: entities moved to VM) must show the VM / Knowledge-Assets
+  // empty-state line, NOT "no extracted entities" and NOT the SWM line.
+  it('published assertion empty-state shows the VM / Knowledge-Assets line (not "no extracted entities")', async () => {
+    stateMock.fetchAssertionState.mockResolvedValue({
+      state: 'published', layer: 'vm',
+      // post-publish the data graph is empty
+      assertionGraph: 'did:dkg:context-graph:cg-test/demo/assertion/0xabc/epcis-demo',
+    });
+    stateMock.fetchAssertionTriples.mockReset();
+    stateMock.fetchAssertionTriples.mockResolvedValue([]);
+    root = await mount(wmAssertion);
+    const body = document.body.textContent ?? '';
+    expect(body).toContain('No entities in this assertion');
+    expect(body).toContain('its entities are now Knowledge Assets in Verifiable Memory. Open the Verifiable Memory tab to view them.');
+    expect(body).not.toContain('no extracted entities');
+    // Scope the SWM-line check to the empty-state element — the lifecycle
+    // trail in the right rail always renders the static stage title
+    // "Promoted to Shared Working Memory" (the pipeline legend), so
+    // checking the whole body would false-positive.
+    const emptyStateText = document.querySelector('.v10-empty-state')?.textContent ?? body;
+    expect(emptyStateText).not.toContain('now live in Shared Working Memory');
+  });
+
   // Codex round-1 finding 1 — on assertion switch the hook must CLEAR
   // `data` so the previous assertion's state isn't briefly visible while
   // the new fetch is in flight. A → B where B's state never resolves: the

packages/node-ui/test/project-view-navigation.test.ts

@@ -314,10 +314,14 @@ vi.mock('../src/ui/views/project/components.js', () => ({
   // identity + an "open entity from assertion" button so the
   // mutually-exclusive overlay + close-to-origin behaviour can be
   // asserted without the real fetch/render path.
-  AssertionDetailView: ({ assertion, onNavigate }: { assertion: any; onNavigate: (uri: string) => void }) =>
+  AssertionDetailView: ({ assertion, onNavigate }: { assertion: any; onNavigate: (uri: string, layer?: 'wm' | 'swm' | 'vm') => void }) =>
     React.createElement('section', { 'data-testid': 'assertion-detail', 'data-assertion': assertion.graphUri, 'data-name': assertion.name, 'data-subgraph': assertion.subGraph ?? '' },
       React.createElement('div', {}, assertion.name),
-      React.createElement('button', { 'data-testid': 'assertion-open-entity', onClick: () => onNavigate('urn:entity:demo') }, 'Open entity from assertion')),
+      React.createElement('button', { 'data-testid': 'assertion-open-entity', onClick: () => onNavigate('urn:entity:demo') }, 'Open entity from assertion'),
+      // Codex round-5 — open an entity that exists in MULTIPLE layers,
+      // forwarding the assertion's layer (wm) so the follow-on detail is
+      // WM-scoped, not the canonical (shared) version.
+      React.createElement('button', { 'data-testid': 'assertion-open-overlap-wm', onClick: () => onNavigate('urn:entity:overlap', 'wm') }, 'Open overlap entity (WM-scoped)')),
   SubGraphDetailView: ({ slug, activeTab = 'items', onTabChange, onSelectEntity, initialLayer, initialEnabledLayers, onEnabledLayersChange }: {
     slug: string;
     activeTab?: string;
@@ -1404,6 +1408,28 @@ describe('ProjectView entity detail navigation', () => {
     expect(document.querySelector('[data-testid="assertion-detail"]')).toBeNull();
   });
 
+  // Codex round-5 finding 2 — navigating from a WM-assertion entity that
+  // ALSO exists in SWM must open the WM-SCOPED detail (the assertion's
+  // layer), not the canonical/global version. urn:entity:overlap lives in
+  // {working, shared} with canonical trustLevel 'shared'; opening it with
+  // layer='wm' forwarded must resolve the WM slice (trust 'working').
+  it('navigating from a WM-assertion entity (also in SWM) opens the WM-scoped detail, not canonical', async () => {
+    await click('switch-wm');
+    await click('layer-tab-assertions');
+    await flush();
+    await click('open-layer-assertion');
+    await flush();
+    expect(query('assertion-detail').dataset.name).toBe('demo-assertion');
+
+    await click('assertion-open-overlap-wm');
+    await flush();
+    expect(query('entity-detail').dataset.entity).toBe('urn:entity:overlap');
+    // WM-scoped (working), NOT the canonical 'shared' — proves the
+    // assertion's layer flowed through handleNavigate's layerContext.
+    expect(query('entity-detail').dataset.trust).toBe('working');
+    expect(query('entity-detail').textContent).toContain('Working overlap');
+  });
+
   it('switching layers from the assertion detail exits the overlay (no stranded detail)', async () => {
     await click('switch-wm');
     await click('layer-tab-assertions');