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),
   };
 }
@@ -945,14 +967,38 @@ export async function fetchAssertionTriples(
  * N-Triples string form is already fully encoded by the daemon, so it
  * passes through verbatim.
  */
+/**
+ * Escape a literal body for the N-Triples `"…"` form: backslash + quote,
+ * the canonical short escapes for tab/newline/carriage-return, and any
+ * other C0 control char as `\\uXXXX`. Order matters — backslash first so
+ * the escapes we add aren't re-escaped.
+ */
+function escapeNTriplesLiteral(value: string): string {
+  let out = "";
+  for (const ch of value) {
+    const code = ch.codePointAt(0)!;
+    if (ch === '\\') out += '\\\\';
+    else if (ch === '"') out += '\\"';
+    else if (code === 0x09) out += '\\t';
+    else if (code === 0x0a) out += '\\n';
+    else if (code === 0x0d) out += '\\r';
+    else if (code < 0x20) out += '\\u' + code.toString(16).padStart(4, '0').toUpperCase();
+    else out += ch;
+  }
+  return out;
+}
+
 function rawBindingValue(v: unknown): string | undefined {
   if (v == null) return undefined;
   if (typeof v === 'object' && 'value' in (v as any)) {
     const node = v as any;
     if (node.type === 'literal' || node.type === 'typed-literal') {
-      // Escape per N-Triples so embedded quotes/backslashes don't break
-      // the leading-`"` classification or the renderers.
-      const escaped = String(node.value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+      // Escape per N-Triples so embedded quotes/backslashes/control chars
+      // don't break the leading-`"` classification or the renderers.
+      // Codex round-6 — control chars (raw \n/\r/\t in a multiline
+      // extracted value, plus other C0 controls) were previously left
+      // raw → invalid N-Triples → broke the graph/triple parsers.
+      const escaped = escapeNTriplesLiteral(String(node.value));
       // Standard SPARQL JSON carries the datatype on `.datatype` and the
       // language on `.xml:lang` (some serialisers use `.language`).
       const lang = node['xml:lang'] ?? node.language;
@@ -961,6 +1007,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/hooks/useMemoryEntities.ts

@@ -2,6 +2,7 @@ import { useState, useEffect, useMemo, useRef, useCallback } from 'react';
 import { postQueryDeduped } from '../api.js';
 import { useMemoryGraphEvents } from './useNodeEvents.js';
 import { MEMORY_LABEL_PREDICATES } from '../lib/memoryLabels.js';
+import { decodeRdfStringLiteral } from '../../rdf-literal.js';
 
 export type TrustLevel = 'working' | 'shared' | 'verified';
 export type MemoryLayerKey = 'wm' | 'swm' | 'vm';
@@ -107,7 +108,11 @@ export function canonicalEntityUri(uri: string): string {
 
 function shortLabel(uri: string): string {
   if (!uri) return '—';
-  if (uri.startsWith('"')) return uri.replace(/^"|"$/g, '');
+  // Codex round-6 — decode RDF literals (drop the `^^<type>`/`@lang`
+  // suffix + unescape the body) instead of a bare outer-quote strip, so
+  // `"Hola"@es` renders `Hola`, not `Hola"@es`. Idempotent for a
+  // suffix-free `"Hola"` and a no-op for non-literal IRIs.
+  if (uri.startsWith('"')) return decodeRdfStringLiteral(uri);
   const hash = uri.lastIndexOf('#');
   const slash = uri.lastIndexOf('/');
   const cut = Math.max(hash, slash);
@@ -487,7 +492,11 @@ export function buildEntities(layered: LayeredTriple[]): Map<string, MemoryEntit
       }
     } else {
       const existing = entity.properties.get(t.predicate) ?? [];
-      const val = t.object.startsWith('"') ? t.object.replace(/^"|"$/g, '') : t.object;
+      // Codex round-6 — decode the literal (drop datatype/lang suffix +
+      // unescape) rather than a bare outer-quote strip, so property
+      // values used as labels (deriveEntityLabel) render `Hola`, not
+      // `Hola"@es`. Idempotent for suffix-free / plain values.
+      const val = t.object.startsWith('"') ? decodeRdfStringLiteral(t.object) : t.object;
       if (!existing.includes(val)) {
         existing.push(val);
         entity.properties.set(t.predicate, existing);

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;
@@ -4138,6 +4143,12 @@ export function AssertionDetailView({
   const assertionGraph = stateInfo?.assertionGraph;
   const [triples, setTriples] = useState<Triple[]>([]);
   const [triplesLoading, setTriplesLoading] = useState(false);
+  // Codex round-6 — a triple-FETCH failure must be DISTINCT from a
+  // genuinely-empty assertion (loading / error / empty are three states,
+  // not two — mirrors the lifecycle state's hydrating/error edge).
+  // Previously the `.catch` collapsed to `[]`, so a backend/query error
+  // showed the same empty-state copy as valid-but-empty data.
+  const [triplesError, setTriplesError] = useState(false);
   useEffect(() => {
     if (!assertionGraph) {
       // No data graph to read (promoted assertion — its triples moved to
@@ -4150,13 +4161,15 @@ export function AssertionDetailView({
       // renders.
       setTriples([]);
       setTriplesLoading(false);
+      setTriplesError(false);
       return;
     }
     let cancelled = false;
     setTriplesLoading(true);
+    setTriplesError(false);
     fetchAssertionTriples(contextGraphId, assertionGraph)
-      .then(rows => { if (!cancelled) setTriples(rows); })
-      .catch(() => { if (!cancelled) setTriples([]); })
+      .then(rows => { if (!cancelled) { setTriples(rows); setTriplesError(false); } })
+      .catch(() => { if (!cancelled) { setTriples([]); setTriplesError(true); } })
       .finally(() => { if (!cancelled) setTriplesLoading(false); });
     return () => { cancelled = true; };
     // `refreshNonce` re-runs the triples fetch after a promote (the data
@@ -4265,21 +4278,40 @@ export function AssertionDetailView({
             <div className="v10-ka-section" style={{ marginTop: 12 }}>
               {triplesLoading && rootEntities.length === 0 ? (
                 <div className="v10-graph-placeholder">Loading assertion entities...</div>
-              ) : rootEntities.length === 0 ? (
+              ) : triplesError ? (
+                // Codex round-6 — a fetch ERROR is DISTINCT from an empty
+                // assertion: an operational failure must not masquerade as
+                // valid-but-empty data. Mirrors the lifecycle state's
+                // error edge (quiet, explicit "couldn't load").
                 <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.'}
+                  title="Couldn't load this assertion's contents."
+                  description="The assertion data couldn't be read right now. Refresh and try again."
                 />
+              ) : rootEntities.length === 0 ? (
+                (() => {
+                  // 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 +4377,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';