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

@@ -330,13 +330,21 @@ export function ProjectView({ contextGraphId }: ProjectViewProps) {
     setSelectedAssertion(assertion);
   }, [captureDetailOrigin]);
 
+  // Consumes a pending scroll restore once the detail overlay has
+  // actually closed. S4 — the close path is shared by the entity AND
+  // the assertion overlay (`handleDetailClose` queues `origin.scroll`
+  // for both), so the guard must wait for BOTH to clear and the deps
+  // must include `selectedAssertion`. Without it, closing an assertion
+  // back to the same layer it opened from changes none of the other
+  // listed deps, the effect never re-fires, and the queued scroll is
+  // never restored — an M2-parity gap vs the entity-close path (7-1).
   useEffect(() => {
-    if (selectedUri) return;
+    if (selectedUri || selectedAssertion) return;
     const scroll = pendingScrollRestoreRef.current;
     if (!scroll) return;
     pendingScrollRestoreRef.current = null;
     restoreScroll(scroll);
-  }, [selectedUri, activeLayer, activeSubGraph, layerContentTabs, subGraphTabs, restoreScroll]);
+  }, [selectedUri, selectedAssertion, activeLayer, activeSubGraph, layerContentTabs, subGraphTabs, restoreScroll]);
 
   // Cross-tab entity open — e.g. the agent profile page in another tab
   // fires a CustomEvent("v10:open-entity", { contextGraphId, entityUri })
@@ -696,11 +704,20 @@ export function ProjectView({ contextGraphId }: ProjectViewProps) {
     setSelectedLayerContext(prev => layerContext ?? (hadSelection ? prev : null));
     const currentSubGraph = activeSubGraphRef.current;
     if (currentSubGraph) {
-      const targetSubGraph = primarySubGraphOf(
-        entitiesRef.current.get(uri) ?? entitiesRef.current.get(canonicalEntityUri(uri)),
-      );
-      if (targetSubGraph && targetSubGraph !== currentSubGraph) {
-        setActiveSubGraphSync(targetSubGraph);
+      const entity = entitiesRef.current.get(uri) ?? entitiesRef.current.get(canonicalEntityUri(uri));
+      // Codex round-8 (8-3) — prefer the CURRENT subgraph for a multi-homed
+      // entity. M2(b) switches to `primarySubGraphOf` (first non-meta),
+      // which is arbitrary when the entity lives in several subgraphs. If
+      // the entity is ALREADY in the current subgraph, stay — don't jump to
+      // an arbitrary sibling. Only switch when the entity isn't in the
+      // current subgraph at all; then `primarySubGraphOf` is the must-move
+      // fallback (M2(b)'s reason for existing: un-strand an entity that
+      // doesn't belong to the page you're on). `subGraphs` is a Set<string>.
+      if (!entity?.subGraphs.has(currentSubGraph)) {
+        const targetSubGraph = primarySubGraphOf(entity);
+        if (targetSubGraph && targetSubGraph !== currentSubGraph) {
+          setActiveSubGraphSync(targetSubGraph);
+        }
       }
     }
   }, [openEntityDetail, setActiveSubGraphSync]);
@@ -788,6 +805,29 @@ export function ProjectView({ contextGraphId }: ProjectViewProps) {
       ? selectedAssertion.name
       : null;
 
+  // Codex round-8 (8-2) — when a detail is open the breadcrumb's middle
+  // hop must label the M2 ORIGIN (where the middle-hop click returns you),
+  // not the current location. After an M2(b) cross-subgraph follow the
+  // active subgraph diverges from the origin, so the current-scope label
+  // would name the followed-into subgraph while clicking returns to the
+  // origin. Read the origin snapshot (captured at detail-open) and resolve
+  // its subgraph display name via the profile. Only meaningful when a
+  // detail is open — `breadcrumbDetailLabel` gates the read, and the
+  // detail-open selection state drives the render, so the ref is populated
+  // by the time we read it here.
+  const breadcrumbOrigin = breadcrumbDetailLabel ? detailOriginRef.current : null;
+  const breadcrumbOriginSubGraph = breadcrumbOrigin?.activeSubGraph ?? null;
+  // Codex round-10 (10-1) — `forSubGraph` returns undefined for a subgraph
+  // with NO profile binding, so `.displayName` would throw before the
+  // breadcrumb renders (opening a detail from an unprofiled subgraph would
+  // crash). Optional-chain and degrade to the slug — the SAME fallback the
+  // no-origin-subgraph case uses. (The 9-2 chrome accesses in
+  // ProjectHeaderStrip already optional-chain `forSubGraph`; this is the one
+  // un-guarded access, which resolves only the breadcrumb label.)
+  const breadcrumbOriginSubGraphName = breadcrumbOriginSubGraph
+    ? profile.forSubGraph(breadcrumbOriginSubGraph)?.displayName ?? breadcrumbOriginSubGraph
+    : null;
+
   // Codex Bug C — gate the `entities`-driven chip-count path on a
   // fully-loaded memory snapshot. While `useMemoryEntities` is mid-
   // hydration or a layer query is in-flight, `entityList` is partial
@@ -828,6 +868,9 @@ export function ProjectView({ contextGraphId }: ProjectViewProps) {
         activeLayer={activeLayer}
         activeSubGraph={activeSubGraphBinding}
         detailLabel={breadcrumbDetailLabel}
+        originLayer={breadcrumbOrigin?.activeLayer ?? null}
+        originSubGraph={breadcrumbOriginSubGraph}
+        originSubGraphDisplayName={breadcrumbOriginSubGraphName}
         onOverview={handleBreadcrumbOverview}
         onRestoreOrigin={handleDetailClose}
       />
@@ -865,7 +908,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}
         />