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),
   };
 }

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';
@@ -4266,15 +4266,22 @@ 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);

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/use-assertion-state.test.ts

@@ -260,4 +260,55 @@ describe('listAssertions(wm) partition graphUri → fetchAssertionState resolves
     expect(body.sparql).toContain('UNION');
     expect(body.sparql).toContain('assertionGraph');
   });
+
+  // Codex round-3 finding 2 — an SWM input (lifecycle URN) whose
+  // dkg:assertionGraph did NOT resolve (legacy/partial _meta row) must
+  // NOT echo the URN as assertionGraph (that would make
+  // fetchAssertionTriples query `GRAPH <urn:dkg:assertion:…>` — a bogus
+  // empty render). Return undefined → the panes show their empty-state.
+  it('SWM lifecycle-URN with UNRESOLVED dkg:assertionGraph → assertionGraph undefined (not the URN)', async () => {
+    const LIFECYCLE = 'urn:dkg:assertion:cg-A:0xabc:legacy-no-graph';
+    fetchMock.mockResolvedValueOnce(jsonResponse({
+      result: { bindings: [{ state: { value: 'promoted' }, layer: { value: 'SWM' } }] }, // no assertionGraph
+    }));
+    const stateInfo = await fetchAssertionState('cg-A', LIFECYCLE);
+    expect(stateInfo).not.toBeNull();
+    expect(stateInfo!.state).toBe('promoted');
+    // Must NOT be the lifecycle URN; undefined so the triples pane is empty.
+    expect(stateInfo!.assertionGraph).toBeUndefined();
+  });
+
+  // Counterpart — a WM data-graph-URI input with no resolved
+  // dkg:assertionGraph (it IS the data graph) keeps echoing itself.
+  it('WM data-graph-URI input with no resolved dkg:assertionGraph echoes the input (it IS the data graph)', async () => {
+    const PARTITION = 'did:dkg:context-graph:cg-A/assertion/0xabc/notes';
+    fetchMock.mockResolvedValueOnce(jsonResponse({
+      result: { bindings: [{ state: { value: 'created' }, layer: { value: 'WM' } }] }, // no assertionGraph binding
+    }));
+    const stateInfo = await fetchAssertionState('cg-A', PARTITION);
+    expect(stateInfo!.assertionGraph).toBe(PARTITION);
+  });
+
+  // Codex round-4 — branch A must bind ?lifecycle UNCONDITIONALLY with the
+  // dkg:assertionGraph match OPTIONAL, so an SWM lifecycle-URN row whose
+  // _meta carries dkg:state but NOT dkg:assertionGraph (legacy/partial)
+  // still resolves its state. Pin the SPARQL shape so it can't regress to
+  // requiring the assertionGraph triple to bind the lifecycle subject.
+  it('SPARQL: branch A binds the input AS ?lifecycle unconditionally + OPTIONAL assertionGraph (round-4)', async () => {
+    const LIFECYCLE = 'urn:dkg:assertion:cg-A:0xabc:legacy-no-graph';
+    fetchMock.mockResolvedValueOnce(jsonResponse({
+      result: { bindings: [{ state: { value: 'promoted' }, layer: { value: 'SWM' } }] },
+    }));
+    const stateInfo = await fetchAssertionState('cg-A', LIFECYCLE);
+    // State still resolves (the round-4 outcome) and assertionGraph stays
+    // undefined (round-3 guard composes).
+    expect(stateInfo!.state).toBe('promoted');
+    expect(stateInfo!.assertionGraph).toBeUndefined();
+    const sparql = JSON.parse(fetchMock.mock.calls[0][1].body).sparql as string;
+    // Unconditional BIND of the input as the lifecycle subject…
+    expect(sparql).toContain(`BIND(<${LIFECYCLE}> AS ?lifecycle)`);
+    // …with the assertionGraph match OPTIONAL (branch A no longer REQUIRES
+    // `<input> dkg:assertionGraph ?assertionGraph` to bind ?lifecycle).
+    expect(sparql).toMatch(/OPTIONAL\s*\{\s*<urn:dkg:assertion:cg-A:0xabc:legacy-no-graph>\s*<http:\/\/dkg\.io\/ontology\/assertionGraph>\s*\?assertionGraph\s*\}/);
+  });
 });