diff --git a/app/src/utils/__tests__/routeUtils.test.ts b/app/src/utils/__tests__/routeUtils.test.ts
new file mode 100644
index 000000000..c3563644a
--- /dev/null
+++ b/app/src/utils/__tests__/routeUtils.test.ts
@@ -0,0 +1,94 @@
+import {
+  stripNeighbourhoodPrefix,
+  restoreNeighbourhoodPrefix,
+  stripChannelPrefix,
+  restoreChannelPrefix,
+} from '../routeUtils';
+
+describe('stripNeighbourhoodPrefix', () => {
+  it('strips neighbourhood:// prefix', () => {
+    expect(stripNeighbourhoodPrefix('neighbourhood://abc123')).toBe('abc123');
+  });
+
+  it('strips private:// prefix', () => {
+    expect(stripNeighbourhoodPrefix('private://abc123')).toBe('abc123');
+  });
+
+  it('returns bare strings unchanged', () => {
+    expect(stripNeighbourhoodPrefix('abc123')).toBe('abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(stripNeighbourhoodPrefix(undefined as unknown as string)).toBe('');
+    expect(stripNeighbourhoodPrefix('')).toBe('');
+  });
+});
+
+describe('restoreNeighbourhoodPrefix', () => {
+  it('prepends neighbourhood:// to bare IDs', () => {
+    expect(restoreNeighbourhoodPrefix('abc123')).toBe('neighbourhood://abc123');
+  });
+
+  it('passes through neighbourhood:// IDs unchanged', () => {
+    expect(restoreNeighbourhoodPrefix('neighbourhood://abc123')).toBe('neighbourhood://abc123');
+  });
+
+  it('passes through private:// IDs unchanged', () => {
+    expect(restoreNeighbourhoodPrefix('private://abc123')).toBe('private://abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(restoreNeighbourhoodPrefix(undefined as unknown as string)).toBe('');
+    expect(restoreNeighbourhoodPrefix('')).toBe('');
+  });
+});
+
+describe('stripChannelPrefix', () => {
+  it('strips literal:string: prefix', () => {
+    expect(stripChannelPrefix('literal:string:abc123')).toBe('abc123');
+  });
+
+  it('passes through ad4m://obj/ IDs unchanged', () => {
+    expect(stripChannelPrefix('ad4m://obj/abc123')).toBe('ad4m://obj/abc123');
+  });
+
+  it('passes through bare strings unchanged', () => {
+    expect(stripChannelPrefix('abc123')).toBe('abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(stripChannelPrefix(undefined as unknown as string)).toBe('');
+    expect(stripChannelPrefix('')).toBe('');
+  });
+});
+
+describe('restoreChannelPrefix', () => {
+  it('prepends literal:string: to bare IDs', () => {
+    expect(restoreChannelPrefix('abc123')).toBe('literal:string:abc123');
+  });
+
+  it('passes through ad4m://obj/ IDs unchanged', () => {
+    expect(restoreChannelPrefix('ad4m://obj/abc123')).toBe('ad4m://obj/abc123');
+  });
+
+  it('passes through any :// scheme unchanged', () => {
+    expect(restoreChannelPrefix('neighbourhood://abc123')).toBe('neighbourhood://abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(restoreChannelPrefix(undefined as unknown as string)).toBe('');
+    expect(restoreChannelPrefix('')).toBe('');
+  });
+});
+
+describe('round-trip: stripChannelPrefix → restoreChannelPrefix', () => {
+  it('round-trips legacy literal:string: IDs', () => {
+    const original = 'literal:string:abc123';
+    expect(restoreChannelPrefix(stripChannelPrefix(original))).toBe(original);
+  });
+
+  it('round-trips ad4m://obj/ IDs', () => {
+    const original = 'ad4m://obj/abc123';
+    expect(restoreChannelPrefix(stripChannelPrefix(original))).toBe(original);
+  });
+});
diff --git a/app/src/utils/routeUtils.ts b/app/src/utils/routeUtils.ts
index 56f616521..796d9efc2 100644
--- a/app/src/utils/routeUtils.ts
+++ b/app/src/utils/routeUtils.ts
@@ -5,6 +5,7 @@
 
 // Strips neighbourhood URL prefix to get clean community ID
 export function stripNeighbourhoodPrefix(neighbourhoodUrl: string): string {
+  if (!neighbourhoodUrl) return '';
   const prefix = 'neighbourhood://';
   const privatePrefix = 'private://';
   if (neighbourhoodUrl.startsWith(prefix)) return neighbourhoodUrl.slice(prefix.length);
@@ -20,13 +21,20 @@ export function restoreNeighbourhoodPrefix(communityId: string): string {
   return `neighbourhood://${communityId}`;
 }
 
-// Strips literal:string: prefix from channel ID
+// Strips the legacy literal:string: prefix from a channel ID for use in route params.
+// New ad4m://obj/ IDs pass through unchanged — they round-trip via restoreChannelPrefix
+// which detects the :// scheme and returns them as-is.
 export function stripChannelPrefix(channelId: string): string {
+  if (!channelId) return '';
   if (channelId.startsWith('literal:string:')) return channelId.slice('literal:string:'.length);
   return channelId;
 }
 
-// Restores literal:string: prefix to channel ID
+// Restores the instance-ID prefix from a clean route param.
+// IDs that already carry a scheme (ad4m://, literal:, neighbourhood://) pass through unchanged.
+// Bare IDs get the legacy literal:string: prefix for backwards compatibility.
 export function restoreChannelPrefix(channelId: string): string {
+  if (!channelId) return '';
+  if (channelId.includes('://')) return channelId;
   return `literal:string:${channelId}`;
 }
diff --git a/app/src/views/main/community/channel/Header.vue b/app/src/views/main/community/channel/Header.vue
index f8cbd0e63..7ab9c270a 100644
--- a/app/src/views/main/community/channel/Header.vue
+++ b/app/src/views/main/community/channel/Header.vue
@@ -86,8 +86,9 @@ import { useAppStore, useModalStore, useUiStore, useWebrtcStore } from '@/stores
 import { stripChannelPrefix } from '@/utils/routeUtils';
 import { App, Channel, ChannelSummary } from '@coasys/flux-api';
 import { useLiveQuery } from '@coasys/ad4m-vue-hooks';
+import { fluxDebug, fluxDebugWarn } from '@coasys/flux-utils';
 import { storeToRefs } from 'pinia';
-import { computed, onActivated, onMounted } from 'vue';
+import { computed, onActivated, onMounted, watch } from 'vue';
 import { useRouter } from 'vue-router';
 
 defineOptions({ name: 'Header' });
@@ -124,6 +125,31 @@ const { data: views } = useLiveQuery(App, perspective, {
   parent: { model: Channel, id: channel.value?.id ?? '' },
 });
 
+// Debug: trace every state transition on the channel-view (plugin tabs) query.
+// Symptom we're chasing: on the AD4M typed-RDF-literals branch, the plugin
+// tabs disappear silently — the header renders no <label class="tab"> entries
+// because `views` is empty, and there is no error surfaced to the user. This
+// lets us see whether App.parent=Channel resolution is returning [] and why.
+watch(
+  [() => channel.value?.id, () => views.value?.length ?? -1],
+  ([channelId, count]) => {
+    fluxDebug('ChannelHeader.plugins', 'query.state', {
+      channelId,
+      perspectiveUuid: perspective?.uuid,
+      viewCount: count,
+      firstViewPkg: views.value?.[0]?.pkg,
+      firstViewName: views.value?.[0]?.name,
+    });
+    if (channelId && count === 0) {
+      fluxDebugWarn('ChannelHeader.plugins', 'query.empty', {
+        channelId,
+        hint: 'useLiveQuery(App, parent=Channel) returned no plugin views — check that App @Property/@HasMany resolves through the has_child predicate and the SDNA subject class is loaded.',
+      });
+    }
+  },
+  { immediate: true },
+);
+
 function manageChannelPlugins() {
   modalStore.showManageChannelPluginsModal = true;
 }
diff --git a/app/src/views/main/community/channel/view/ViewView.vue b/app/src/views/main/community/channel/view/ViewView.vue
index 3302ae615..170c32f24 100644
--- a/app/src/views/main/community/channel/view/ViewView.vue
+++ b/app/src/views/main/community/channel/view/ViewView.vue
@@ -90,7 +90,7 @@ async function onViewClick(e: any) {
     if (!url.startsWith('http')) e.preventDefault();
     if (url.startsWith('neighbourhood://')) onNeighbourhoodClick(url);
     if (url.startsWith('did:')) onAgentClick(url);
-    if (url.startsWith('literal:')) {
+    if (url.startsWith('literal:') || url.startsWith('ad4m://obj/')) {
       const isChannel = await perspective.isSubjectInstance(url, Channel);
       if (isChannel) {
         router.push({ name: 'channel', params: { communityId, channelId: stripChannelPrefix(url) } });
diff --git a/app/src/views/main/community/modals/__tests__/createChannelLinks.test.ts b/app/src/views/main/community/modals/__tests__/createChannelLinks.test.ts
index 2a7a1df16..546854ce6 100644
--- a/app/src/views/main/community/modals/__tests__/createChannelLinks.test.ts
+++ b/app/src/views/main/community/modals/__tests__/createChannelLinks.test.ts
@@ -2,21 +2,31 @@ import { buildChannelParentLink } from '../createChannelLinks';
 
 describe('buildChannelParentLink', () => {
   it('uses flux://has_channel for a nested channel', () => {
-    const link = buildChannelParentLink('literal:string:parent-channel', 'literal:string:new-channel');
+    const link = buildChannelParentLink('ad4m://obj/parent-channel', 'ad4m://obj/new-channel');
 
     expect(link).toMatchObject({
-      source: 'literal:string:parent-channel',
+      source: 'ad4m://obj/parent-channel',
       predicate: 'flux://has_channel',
-      target: 'literal:string:new-channel',
+      target: 'ad4m://obj/new-channel',
     });
   });
 
   it('uses ad4m://self as the top-level source with flux://has_channel', () => {
-    const link = buildChannelParentLink(undefined, 'literal:string:new-channel');
+    const link = buildChannelParentLink(undefined, 'ad4m://obj/new-channel');
 
     expect(link).toMatchObject({
       source: 'ad4m://self',
       predicate: 'flux://has_channel',
+      target: 'ad4m://obj/new-channel',
+    });
+  });
+
+  it('handles legacy literal:string: IDs', () => {
+    const link = buildChannelParentLink('literal:string:parent-channel', 'literal:string:new-channel');
+
+    expect(link).toMatchObject({
+      source: 'literal:string:parent-channel',
+      predicate: 'flux://has_channel',
       target: 'literal:string:new-channel',
     });
   });
diff --git a/packages/api/src/channel/index.ts b/packages/api/src/channel/index.ts
index 3e19a8885..0129bb73d 100644
--- a/packages/api/src/channel/index.ts
+++ b/packages/api/src/channel/index.ts
@@ -1,7 +1,7 @@
 import { Ad4mModel, HasMany, HasManyMethods, Flag, Literal, LinkQuery, Model, Property, PerspectiveProxy, parseLit, parseSparqlCount, CountBinding } from '@coasys/ad4m';
 import { community } from '@coasys/flux-constants';
 import { EntryType } from '@coasys/flux-types';
-import { SynergyGroup, SynergyItem, ItemType, icons } from '@coasys/flux-utils';
+import { SynergyGroup, SynergyItem, ItemType, icons, fluxDebug, fluxDebugWarn } from '@coasys/flux-utils';
 import App from '../app';
 import Conversation from '../conversation';
 import Message from '../message';
@@ -117,26 +117,50 @@ export class Channel extends Ad4mModel {
 
       const sparqlResult = await this.perspective.querySparql<ChannelItemBinding[]>(sparqlQuery);
 
+      // Debug: log raw SPARQL binding shape. The typed-RDF-literals refactor
+      // in coasys/ad4m#874 changed wire form for scalar values; if body still
+      // arrives as a `literal:string:*` envelope, storage-vs-decode is mismatched.
+      fluxDebug('Channel.allItems', 'sparql.result', {
+        channelId: this.id,
+        rowCount: (sparqlResult || []).length,
+        firstRow: sparqlResult?.[0],
+        types: [...new Set((sparqlResult || []).map((r) => r.type))],
+      });
+      if (sparqlResult?.length) {
+        const envelope = sparqlResult.find((r) => typeof r.body === 'string' && r.body.startsWith('literal:'));
+        if (envelope) {
+          fluxDebugWarn('Channel.allItems', 'sparql.body-is-envelope', {
+            channelId: this.id,
+            sampleBody: envelope.body?.slice(0, 120),
+            hint: 'Message.body arrives as a `literal:*` envelope URI — parseLit() decode is required.',
+          });
+        }
+      }
+
       const mapped = (sparqlResult || []).map((binding) => {
         let text = '';
         let type: ItemType = 'Message';
         const itemType = binding.type;
 
+        // title / taskName / transcriptStart are typed XSD literals — SPARQL
+        // binding returns their lexical form directly, no decode.
+        // Only Message.body is an envelope literal (resolveLanguage: 'literal')
+        // so it still needs parseLit() to unwrap the `.data` field.
         if (itemType === 'flux://has_message') {
           text = parseLit(binding.body);
           type = 'Message';
         } else if (itemType === 'flux://has_post') {
-          text = parseLit(binding.title);
+          text = binding.title ?? '';
           type = 'Post';
         } else if (itemType === 'flux://has_task') {
-          text = parseLit(binding.taskName);
+          text = binding.taskName ?? '';
           type = 'Task';
         }
 
         return {
           id: binding.id,
           author: binding.author,
-          timestamp: new Date(parseLit(binding.transcriptStart) || binding.timestamp).toISOString(),
+          timestamp: new Date(binding.transcriptStart || binding.timestamp).toISOString(),
           text,
           type,
           icon: icons[type] || 'question',
@@ -228,21 +252,23 @@ export class Channel extends Ad4mModel {
         let type: ItemType = 'Message';
         const itemType = binding.type;
 
+        // Only Message.body needs parseLit() (envelope literal). All other
+        // scalar fields are typed XSD literals and used as-is.
         if (itemType === 'flux://has_message') {
           text = parseLit(binding.body);
           type = 'Message';
         } else if (itemType === 'flux://has_post') {
-          text = parseLit(binding.title);
+          text = binding.title ?? '';
           type = 'Post';
         } else if (itemType === 'flux://has_task') {
-          text = parseLit(binding.taskName);
+          text = binding.taskName ?? '';
           type = 'Task';
         }
 
         return {
           id: binding.id,
           author: binding.author,
-          timestamp: new Date(parseLit(binding.transcriptStart) || binding.timestamp).toISOString(),
+          timestamp: new Date(binding.transcriptStart || binding.timestamp).toISOString(),
           text,
           type,
           icon: icons[type] || 'question',
@@ -310,8 +336,9 @@ export class Channel extends Ad4mModel {
       for (const r of results || []) {
         const cid = r.channelId;
         if (!cid || channelMap.has(cid)) continue;
-        const parsed = parseLit(r.isConv);
-        if (String(parsed) !== 'true') continue;
+        // CHANNEL_IS_CONVERSATION is a boolean typed literal; SPARQL binding
+        // returns its lexical form directly.
+        if (r.isConv !== 'true') continue;
         channelMap.set(cid, {
           channelId: cid,
           conversationId: r.conversationId || undefined,
diff --git a/packages/api/src/conversation-subgroup/index.ts b/packages/api/src/conversation-subgroup/index.ts
index ff71ab27e..d13654726 100644
--- a/packages/api/src/conversation-subgroup/index.ts
+++ b/packages/api/src/conversation-subgroup/index.ts
@@ -102,7 +102,8 @@ export default class ConversationSubgroup extends Ad4mModel {
         if (topicBase && !uniqueTopics.has(topicBase)) {
           uniqueTopics.set(topicBase, {
             topicBase,
-            topicName: parseLit(binding.topicNameRaw),
+            // Typed XSD literal — SPARQL binding gives lexical form directly.
+            topicName: binding.topicNameRaw ?? '',
           });
         }
       }
@@ -155,24 +156,27 @@ export default class ConversationSubgroup extends Ad4mModel {
         if (!id) continue;
 
         // Coalesce OPTIONAL fields from multiple SPARQL rows for same id
+        // body/title/taskName/transcriptStart are typed XSD literals; SPARQL
+        // binding returns their lexical form directly, no decode needed.
         if (seen.has(id)) {
           // Merge optional fields from this binding into the existing item
           const existing = seen.get(id)!;
-          const transcriptStart = parseLit(binding.transcriptStart);
+          const transcriptStart = binding.transcriptStart ?? '';
           const channelTs = binding.channelTs;
           const fallbackTs = binding.timestamp;
           if (!existing.channelTimestamp) {
             existing.channelTimestamp = transcriptStart || channelTs || fallbackTs;
           }
+          // Message.body is envelope-encoded (resolveLanguage: 'literal'); decode via parseLit.
           if (!existing.messageBody) existing.messageBody = parseLit(binding.body);
-          if (!existing.postTitle) existing.postTitle = parseLit(binding.title);
-          if (!existing.taskName) existing.taskName = parseLit(binding.taskName);
+          if (!existing.postTitle) existing.postTitle = binding.title ?? '';
+          if (!existing.taskName) existing.taskName = binding.taskName ?? '';
           if (!existing.type) existing.type = binding.type;
           if (!existing.author) existing.author = binding.author;
           continue;
         }
 
-        const transcriptStart = parseLit(binding.transcriptStart);
+        const transcriptStart = binding.transcriptStart ?? '';
         const channelTs = binding.channelTs;
         const fallbackTs = binding.timestamp;
         const channelTimestamp = transcriptStart || channelTs || fallbackTs;
@@ -182,9 +186,10 @@ export default class ConversationSubgroup extends Ad4mModel {
           type: binding.type,
           author: binding.author,
           channelTimestamp,
+          // Message.body is envelope-encoded (resolveLanguage: 'literal'); decode via parseLit.
           messageBody: parseLit(binding.body),
-          postTitle: parseLit(binding.title),
-          taskName: parseLit(binding.taskName),
+          postTitle: binding.title ?? '',
+          taskName: binding.taskName ?? '',
         };
         seen.set(id, item);
         items.push(item);
@@ -249,8 +254,9 @@ export default class ConversationSubgroup extends Ad4mModel {
         if (topicBase && !uniqueTopics.has(topicBase)) {
           uniqueTopics.set(topicBase, {
             topicBase,
-            topicName: parseLit(binding.topicNameRaw),
-            relevance: parseLit(binding.relevanceRaw),
+            // Typed XSD literals — no decode needed.
+            topicName: binding.topicNameRaw ?? '',
+            relevance: binding.relevanceRaw ?? '',
           });
         }
       }
diff --git a/packages/api/src/conversation/index.ts b/packages/api/src/conversation/index.ts
index 99c581c1b..8046cf1e1 100644
--- a/packages/api/src/conversation/index.ts
+++ b/packages/api/src/conversation/index.ts
@@ -1,4 +1,4 @@
-import { Ad4mModel, Ad4mClient, Flag, HasMany, HasManyMethods, Link, Literal, Model, Property, parseLit } from '@coasys/ad4m';
+import { Ad4mModel, Ad4mClient, Flag, HasMany, HasManyMethods, Link, Literal, Model, Property } from '@coasys/ad4m';
 
 import { getProfile, Topic } from '@coasys/flux-api';
 import { ProcessingState, Profile } from '@coasys/flux-types';
@@ -112,7 +112,8 @@ export class Conversation extends Ad4mModel {
         if (topicBase && !uniqueTopics.has(topicBase)) {
           uniqueTopics.set(topicBase, {
             topicBase,
-            topicName: parseLit(binding.topicNameRaw),
+            // Typed XSD literal — SPARQL binding gives lexical form directly.
+            topicName: binding.topicNameRaw ?? '',
           });
         }
       }
@@ -164,8 +165,9 @@ export class Conversation extends Ad4mModel {
           subgroupMap.set(id, {
             id,
             timestamp: binding.timestamp,
-            name: parseLit(binding.nameRaw),
-            summary: parseLit(binding.summaryRaw),
+            // has_name / has_summary are typed XSD literals — no decode.
+            name: binding.nameRaw ?? '',
+            summary: binding.summaryRaw ?? '',
           });
         }
       }
@@ -196,7 +198,8 @@ export class Conversation extends Ad4mModel {
       for (const r of batchResults || []) {
         const sgId = r.sg;
         if (!sgId) continue;
-        const ts = parseLit(r.transcriptStart) || r.channelTs;
+        // transcript_started_at is a typed XSD literal string.
+        const ts = r.transcriptStart || r.channelTs;
         if (ts == null || ts === '') continue;
         const time = new Date(ts).getTime();
         if (isNaN(time)) continue;
diff --git a/packages/api/src/message/index.ts b/packages/api/src/message/index.ts
index 2e1da21dd..7b62734f5 100644
--- a/packages/api/src/message/index.ts
+++ b/packages/api/src/message/index.ts
@@ -9,7 +9,17 @@ export class Message extends Ad4mModel {
   @Flag({ through: ENTRY_TYPE, value: EntryType.Message })
   type: string;
 
-  @Property({ through: BODY })
+  // Message bodies are stored as signed-envelope literals rather than
+  // deterministic typed literals — per-message provenance matters for
+  // moderation, edit-history and cross-agent trust chains, and message text
+  // often contains rich content (JSON payloads, formatted markdown) that we
+  // want the envelope's `.data` field to unwrap on read.
+  //
+  // All other scalar `@Property` fields in this package (channel names,
+  // titles, task names, transcript timestamps, topic names, etc.) use the
+  // default deterministic typed-literal storage and are read directly from
+  // SPARQL bindings without `parseLit()`.
+  @Property({ through: BODY, resolveLanguage: 'literal' })
   body: string;
 
   @Property({ through: TRANSCRIPT_STARTED_AT })
diff --git a/packages/api/src/semantic-relationship/index.ts b/packages/api/src/semantic-relationship/index.ts
index 56aea3d79..e52ee55a4 100644
--- a/packages/api/src/semantic-relationship/index.ts
+++ b/packages/api/src/semantic-relationship/index.ts
@@ -1,5 +1,4 @@
 import { Model, Ad4mModel, Flag, Property } from '@coasys/ad4m';
-import { parseLit } from '../utils/parseLit';
 import { SynergyMatch } from '@coasys/flux-utils';
 
 const TYPE_MAP: Record<string, string> = {
@@ -72,7 +71,8 @@ export default class SemanticRelationship extends Ad4mModel {
             type: 'Conversation',
             embedding: JSON.parse(embeddingExpression.data),
             channelId: binding.channelId,
-            channelName: parseLit(binding.channelName),
+            // has_channel_name is a typed XSD literal — no decode needed.
+            channelName: binding.channelName ?? '',
           };
         }),
       );
@@ -110,7 +110,8 @@ export default class SemanticRelationship extends Ad4mModel {
             type: 'Subgroup',
             embedding: JSON.parse(embeddingExpression.data),
             channelId: binding.channelId,
-            channelName: parseLit(binding.channelName),
+            // has_channel_name is a typed XSD literal — no decode needed.
+            channelName: binding.channelName ?? '',
           };
         }),
       );
@@ -153,7 +154,8 @@ export default class SemanticRelationship extends Ad4mModel {
             type: typeNameMap[binding.type] || binding.type,
             embedding: JSON.parse(embeddingExpression.data),
             channelId: binding.channelId,
-            channelName: parseLit(binding.channelName),
+            // Typed XSD literal.
+            channelName: binding.channelName ?? '',
           };
         }),
       );
@@ -197,7 +199,8 @@ export default class SemanticRelationship extends Ad4mModel {
             type: itemType,
             embedding: JSON.parse(embeddingExpression.data),
             channelId: binding.channelId,
-            channelName: parseLit(binding.channelName),
+            // Typed XSD literal.
+            channelName: binding.channelName ?? '',
           };
         }),
       );
diff --git a/packages/api/src/topic/index.ts b/packages/api/src/topic/index.ts
index 694fd5228..a3d3677c2 100644
--- a/packages/api/src/topic/index.ts
+++ b/packages/api/src/topic/index.ts
@@ -1,5 +1,4 @@
 import { Model, Ad4mModel, Flag, Property } from '@coasys/ad4m';
-import { parseLit } from '../utils/parseLit';
 import { SynergyMatch } from '@coasys/flux-utils';
 
 export class TopicWithRelevance {
@@ -42,9 +41,10 @@ export default class Topic extends Ad4mModel {
           dedupMap.set(id, {
             id,
             type: 'Conversation',
-            relevance: parseInt(parseLit(binding.relevance), 10) || 0,
+            // Typed XSD literals — SPARQL bindings give lexical form directly.
+            relevance: parseInt(binding.relevance ?? '', 10) || 0,
             channelId: binding.channelId,
-            channelName: parseLit(binding.channelName),
+            channelName: binding.channelName ?? '',
           });
         }
       }
@@ -81,9 +81,10 @@ export default class Topic extends Ad4mModel {
           dedupMap.set(id, {
             id,
             type: 'ConversationSubgroup',
-            relevance: parseInt(parseLit(binding.relevance), 10) || 0,
+            // Typed XSD literals — no decode needed.
+            relevance: parseInt(binding.relevance ?? '', 10) || 0,
             channelId: binding.channelId,
-            channelName: parseLit(binding.channelName),
+            channelName: binding.channelName ?? '',
           });
         }
       }
diff --git a/packages/api/src/utils/parseLit.test.ts b/packages/api/src/utils/parseLit.test.ts
index e87df2603..4ab3cee25 100644
--- a/packages/api/src/utils/parseLit.test.ts
+++ b/packages/api/src/utils/parseLit.test.ts
@@ -27,13 +27,37 @@ describe('parseLit', () => {
     expect(parseLit(url)).toBe('hello world');
   });
 
-  it('extracts .data from JSON literal objects', () => {
+  // Signed-envelope literals are what the `literal` language produces on
+  // write for any property declared with `resolveLanguage: 'literal'` —
+  // Message.body is the last property in @coasys/flux-api that opts into
+  // that storage (per-message provenance / edit-history / moderation).
+  // Upstream @coasys/ad4m's parseLit unwraps `.data` when it's a string;
+  // this test locks in that contract from the Flux side so a future ad4m
+  // regression fails here loudly instead of at the chat UI.
+  //
+  // See @coasys/ad4m/core/src/perspectives/SparqlBindings.ts and its
+  // companion SparqlBindings.test.ts — the .data unwrap was reinstated in
+  // ad4m commit c48c9117c after being dropped by 3a96f73a on a false
+  // premise ("signed envelopes no longer exist for new property writes").
+  it('extracts .data from signed-envelope literals (matches @coasys/ad4m)', () => {
     const { Literal } = require('@coasys/ad4m');
     const url = Literal.from({ data: 'extracted' }).toUrl();
     expect(parseLit(url)).toBe('extracted');
   });
 
-  it('JSON-stringifies objects without .data field', () => {
+  it('extracts .data from full signed-expression envelopes', () => {
+    const { Literal } = require('@coasys/ad4m');
+    const envelope = {
+      author: 'did:key:z6MkTest',
+      timestamp: '2026-08-19T14:00:00.000Z',
+      data: '<p>hello</p>',
+      proof: { key: 'did:key:z6MkTest#z6MkTest', signature: 'deadbeef' },
+    };
+    const url = Literal.from(envelope).toUrl();
+    expect(parseLit(url)).toBe('<p>hello</p>');
+  });
+
+  it('JSON-stringifies objects without a string .data field', () => {
     const { Literal } = require('@coasys/ad4m');
     const url = Literal.from({ foo: 'bar' }).toUrl();
     expect(parseLit(url)).toBe(JSON.stringify({ foo: 'bar' }));
diff --git a/packages/utils/src/fluxDebug.ts b/packages/utils/src/fluxDebug.ts
new file mode 100644
index 000000000..902643a96
--- /dev/null
+++ b/packages/utils/src/fluxDebug.ts
@@ -0,0 +1,129 @@
+/**
+ * Flux debug logger — opt-in tracing to diagnose empty-message / empty-plugin-list
+ * regressions against the AD4M typed-RDF-literals branch (coasys/ad4m#874).
+ *
+ * Enable in browser DevTools console:
+ *
+ *   localStorage.setItem('flux_debug', '1');   // enable, then reload
+ *   localStorage.removeItem('flux_debug');     // disable, then reload
+ *
+ * Or via env at build time:  VITE_FLUX_DEBUG=1
+ *
+ * All log lines are prefixed `[flux-debug]` so they're grep-friendly in a
+ * captured console dump.  Objects are shallow-cloned + JSON-stringified so a
+ * live-updating Ad4mModel reference does not lie about its earlier state in
+ * the browser's collapsible object viewer.
+ */
+
+let cachedEnabled: boolean | null = null;
+
+function computeEnabled(): boolean {
+  // Build-time env (Vite) — takes precedence, allows shipping a debug build
+  try {
+    // Vite injects import.meta.env; older bundlers won't have it.
+    // Wrapped in try because static access to import.meta throws in CommonJS.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const env = (import.meta as any)?.env;
+    if (env && (env.VITE_FLUX_DEBUG === '1' || env.VITE_FLUX_DEBUG === 'true')) return true;
+  } catch {
+    /* not in a Vite context */
+  }
+  // Runtime toggle — localStorage in the browser
+  try {
+    if (typeof localStorage !== 'undefined' && localStorage.getItem('flux_debug') === '1') return true;
+  } catch {
+    /* SSR or restricted context */
+  }
+  // Node/Deno process env — for CI test runs
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const p = (globalThis as any).process;
+    if (p?.env?.FLUX_DEBUG === '1' || p?.env?.FLUX_DEBUG === 'true') return true;
+  } catch {
+    /* no process */
+  }
+  return false;
+}
+
+/** Whether flux-debug logging is currently active. Cached after first call for perf. */
+export function isFluxDebugEnabled(): boolean {
+  if (cachedEnabled === null) cachedEnabled = computeEnabled();
+  return cachedEnabled;
+}
+
+/**
+ * Force-refresh the cached debug flag (useful after `localStorage.setItem`
+ * without a full page reload). Call from the console:
+ *   window.__fluxDebugRefresh?.()
+ */
+function refreshFluxDebug(): boolean {
+  cachedEnabled = computeEnabled();
+  return cachedEnabled;
+}
+try {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (globalThis as any).__fluxDebugRefresh = refreshFluxDebug;
+} catch {
+  /* SSR */
+}
+
+/**
+ * Structured debug log. First argument is a short "scope" (component / module),
+ * second is a short event name, third is a payload object.  All are JSON-safe.
+ *
+ * @example
+ *   fluxDebug('MessageList', 'query.result', { channelId, count, totalCount });
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fluxDebug(scope: string, event: string, payload?: Record<string, any>): void {
+  if (!isFluxDebugEnabled()) return;
+  const safe = payload ? safeClone(payload) : undefined;
+  // eslint-disable-next-line no-console
+  console.log(`[flux-debug] ${scope}: ${event}`, safe ?? '');
+}
+
+/**
+ * Debug warn variant — for suspicious-but-not-error cases (e.g. empty result
+ * where we expected data). Always shown when debug is on.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fluxDebugWarn(scope: string, event: string, payload?: Record<string, any>): void {
+  if (!isFluxDebugEnabled()) return;
+  const safe = payload ? safeClone(payload) : undefined;
+  // eslint-disable-next-line no-console
+  console.warn(`[flux-debug] ${scope}: ${event}`, safe ?? '');
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function safeClone(obj: Record<string, any>): Record<string, any> {
+  const out: Record<string, any> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === null || v === undefined) {
+      out[k] = v;
+    } else if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+      out[k] = v;
+    } else if (Array.isArray(v)) {
+      out[k] = { __array: true, length: v.length, sample: v.slice(0, 3).map(shallowSample) };
+    } else if (typeof v === 'object') {
+      out[k] = shallowSample(v);
+    } else {
+      out[k] = String(v);
+    }
+  }
+  return out;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function shallowSample(v: any): any {
+  if (v === null || v === undefined) return v;
+  if (typeof v !== 'object') return v;
+  const out: Record<string, unknown> = {};
+  const keys = Object.keys(v).slice(0, 8);
+  for (const k of keys) {
+    const val = (v as Record<string, unknown>)[k];
+    if (val === null || val === undefined) out[k] = val;
+    else if (typeof val === 'object') out[k] = Array.isArray(val) ? `[Array(${val.length})]` : '[Object]';
+    else out[k] = val;
+  }
+  return out;
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
index e861f99af..43cbd8a5f 100644
--- a/packages/utils/src/index.ts
+++ b/packages/utils/src/index.ts
@@ -1,6 +1,7 @@
 export * from './asyncFilter';
 export * from './createNeighbourhoodMeta';
 export * from './expressionHelpers';
+export * from './fluxDebug';
 export * from './feedUtterance';
 export * from './formatString';
 export * from './getDefaultIceServers';
diff --git a/views/chat-view/src/components/MessageList/MessageList.tsx b/views/chat-view/src/components/MessageList/MessageList.tsx
index 9006c9862..86b33fc39 100644
--- a/views/chat-view/src/components/MessageList/MessageList.tsx
+++ b/views/chat-view/src/components/MessageList/MessageList.tsx
@@ -2,6 +2,7 @@ import { PerspectiveProxy } from '@coasys/ad4m';
 import { useLiveQuery } from '@coasys/ad4m-react-hooks';
 import { AgentClient } from '@coasys/ad4m/lib/src/agent/AgentClient';
 import { Channel, Message } from '@coasys/flux-api';
+import { fluxDebug, fluxDebugWarn } from '@coasys/flux-utils';
 import { useEffect, useMemo, useRef, useState } from 'preact/hooks';
 import { Virtuoso } from 'react-virtuoso';
 import MessageItem from '../MessageItem';
@@ -40,6 +41,7 @@ export default function MessageList({
   const {
     data: entries,
     loading,
+    error,
     totalCount,
     loadMore,
   } = useLiveQuery(Message, perspective, {
@@ -48,6 +50,33 @@ export default function MessageList({
     pageSize: PAGE_SIZE,
   });
 
+  // Debug: trace every state transition on the message-list query.
+  // Silent-empty results are the exact failure mode we're chasing against
+  // the AD4M typed-RDF-literals branch (coasys/ad4m#874) — messages disappear
+  // with no error. This lets us see whether entries.length went 0, whether
+  // totalCount is meaningful, and whether an error is being swallowed.
+  useEffect(() => {
+    fluxDebug('MessageList', 'query.state', {
+      source,
+      isThread: !!isThread,
+      parentModel: isThread ? 'Message.thread' : 'Channel',
+      perspectiveUuid: perspective?.uuid,
+      loading,
+      error: error || null,
+      entriesLength: entries.length,
+      totalCount,
+      firstEntryId: entries[0]?.id,
+      firstEntryBodyLen: entries[0]?.body?.length ?? null,
+    });
+    if (!loading && !error && entries.length === 0 && totalCount === 0) {
+      fluxDebugWarn('MessageList', 'query.empty-no-error', {
+        source,
+        parent: isThread ? { model: 'Message', id: source, field: 'thread' } : { model: 'Channel', id: source },
+        hint: 'useLiveQuery returned no messages and no error — check parent scope resolution, SPARQL bindings, and typed-literal storage on Message.body.',
+      });
+    }
+  }, [source, isThread, perspective?.uuid, loading, error, entries.length, totalCount]);
+
   const messages = useMemo(() => {
     // Reverse order after pagination for inverted message scrolling
     return entries.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
diff --git a/views/kanban-view/src/components/Board/TaskModel.ts b/views/kanban-view/src/components/Board/TaskModel.ts
index e9c29e780..22aa6611d 100644
--- a/views/kanban-view/src/components/Board/TaskModel.ts
+++ b/views/kanban-view/src/components/Board/TaskModel.ts
@@ -4,7 +4,6 @@ import { Ad4mModel, Model, Property, HasMany } from '@coasys/ad4m';
 export class Task extends Ad4mModel {
   @Property({
     through: 'rdf://name',
-    resolveLanguage: 'literal',
     required: true,
     writable: true,
     initial: 'New task',