diff --git a/packages/desktop-app/src/lib/components/query/kanban-view.svelte b/packages/desktop-app/src/lib/components/query/kanban-view.svelte
index 9bc24dda0..2bd387435 100644
--- a/packages/desktop-app/src/lib/components/query/kanban-view.svelte
+++ b/packages/desktop-app/src/lib/components/query/kanban-view.svelte
@@ -29,6 +29,7 @@
   import { untrack } from 'svelte';
   import { SvelteMap } from 'svelte/reactivity';
   import { sharedNodeStore } from '$lib/services/shared-node-store.svelte';
+  import { pluginRegistry } from '$lib/plugins/plugin-registry';
   import { createLogger } from '$lib/utils/logger';
   import type { Node } from '$lib/types';
   import type { SchemaNode } from '$lib/types/schema-node';
@@ -176,7 +177,7 @@
   }
 
   function titleOf(node: Node): string {
-    return node.title || node.content || 'Untitled';
+    return pluginRegistry.resolveDisplayTitle(node) || 'Untitled';
   }
 
   /** The column a node currently belongs to (for the move control's value). */
diff --git a/packages/desktop-app/src/lib/components/query/list-view.svelte b/packages/desktop-app/src/lib/components/query/list-view.svelte
index 3ab10a47d..11ea840f3 100644
--- a/packages/desktop-app/src/lib/components/query/list-view.svelte
+++ b/packages/desktop-app/src/lib/components/query/list-view.svelte
@@ -1,14 +1,17 @@
 <!--
   ListView - Simple title list for QueryNodeViewer
 
-  One row per result, showing the node title (prefer node.title from title_template,
-  fall back to content, then "Untitled"). Reads each node from sharedNodeStore so
-  rows stay reactive to edits made in another pane. Clicking a row opens the node
-  via onRowClick. Paginated at the same PAGE_SIZE as TableView for consistency.
+  One row per result, showing the node's current display value via
+  pluginRegistry.resolveDisplayTitle (title only for title_template-driven schemas, content
+  otherwise — see node-display-title.ts), falling back to "Untitled". Reads each node
+  from sharedNodeStore so rows stay reactive to edits made in another pane. Clicking a
+  row opens the node via onRowClick. Paginated at the same PAGE_SIZE as TableView for
+  consistency.
 -->
 
 <script lang="ts">
   import { sharedNodeStore } from '$lib/services/shared-node-store.svelte';
+  import { pluginRegistry } from '$lib/plugins/plugin-registry';
   import { Button } from '$lib/components/ui/button';
 
   let {
@@ -32,7 +35,7 @@
   {#each pageIds as id (id)}
     {@const node = sharedNodeStore.getNode(id)}
     {#if node}
-      {@const title = node.title || node.content || 'Untitled'}
+      {@const title = pluginRegistry.resolveDisplayTitle(node) || 'Untitled'}
       <li>
         <button class="list-row" onclick={() => onRowClick(id)} title={`Open ${title}`}>
           {title}
diff --git a/packages/desktop-app/src/lib/components/query/table-row.svelte b/packages/desktop-app/src/lib/components/query/table-row.svelte
index 44b33df70..f2056d702 100644
--- a/packages/desktop-app/src/lib/components/query/table-row.svelte
+++ b/packages/desktop-app/src/lib/components/query/table-row.svelte
@@ -9,6 +9,7 @@
 <script lang="ts">
   import type { SchemaField } from '$lib/types/schema-node';
   import { sharedNodeStore } from '$lib/services/shared-node-store.svelte';
+  import { pluginRegistry } from '$lib/plugins/plugin-registry';
   import { TableRow as UiTableRow, TableCell } from '$lib/components/ui/table';
 
   let {
@@ -41,17 +42,20 @@
     for (const col of columns) {
       const fieldSchema = fieldSchemaMap.get(col.field);
       // Resolution order:
-      // 1. For 'content' column: prefer node.title (computed by title_template) over raw content
+      // 1. For 'content' column: the node's current display value (pluginRegistry
+      //    .resolveDisplayTitle — title only for title_template-driven schemas, content
+      //    otherwise; see node-display-title.ts). node.title alone is stale for non-template
+      //    types, since it's only refreshed by a backend round-trip while optimistic edits
+      //    patch content directly.
       // 2. camelCase top-level (typed core fields like task.dueDate serialized from Rust)
       // 3. snake_case top-level (fallback)
       // 4. node.properties[field] (user-defined fields on custom schema nodes)
       const camelKey = toCamelCase(col.field);
       const props = node.properties as Record<string, unknown> | undefined;
       const rawValue =
-        (col.field === 'content' && node.title ? node.title : undefined) ??
-        nodeRecord[camelKey] ??
-        nodeRecord[col.field] ??
-        props?.[col.field];
+        col.field === 'content'
+          ? pluginRegistry.resolveDisplayTitle(node)
+          : (nodeRecord[camelKey] ?? nodeRecord[col.field] ?? props?.[col.field]);
 
       if (rawValue === null || rawValue === undefined) {
         map.set(col.field, '');
@@ -85,10 +89,11 @@
     return map;
   });
 
-  // For title_template nodes, prefer the computed title over raw content
+  // Current display title (title_template-driven types) or content (everything else) —
+  // see pluginRegistry.resolveDisplayTitle / node-display-title.ts.
   const nodeContent = $derived.by(() => {
     const node = sharedNodeStore.getNode(id);
-    return node?.title ?? node?.content ?? '';
+    return (node && pluginRegistry.resolveDisplayTitle(node)) ?? '';
   });
 
   // Reactive existence check — re-evaluates when the node is deleted from the store
diff --git a/packages/desktop-app/src/lib/design/components/node-type-predicates.ts b/packages/desktop-app/src/lib/design/components/node-type-predicates.ts
index f9ad2697b..80e5d549d 100644
--- a/packages/desktop-app/src/lib/design/components/node-type-predicates.ts
+++ b/packages/desktop-app/src/lib/design/components/node-type-predicates.ts
@@ -13,6 +13,7 @@
  */
 
 import { pluginRegistry } from '$lib/plugins/plugin-registry';
+import { resolveTitleOrContent } from '$lib/utils/node-display-title';
 
 /**
  * True when a plugin registers an inline node component for this type.
@@ -50,31 +51,16 @@ export function needsGenericSchemaForm(nodeType: string): boolean {
 /**
  * The value a viewer header shows while it is NOT focused.
  *
- * Which field wins depends on whether the node's schema is title_template-driven:
- *
- * - `hasTitleTemplate` — `title` is computed from the node's properties and is a genuinely
- *   different value from `content`, so it is the only valid display value. There is no
- *   fallback to `content`: an unresolved title renders empty and the read-only header shows
- *   the titleTemplate placeholder instead. A title with no word characters (e.g. the `" "`
- *   left by a `"{first_name} {last_name}"` template with both fields empty) counts as
- *   unresolved, matching the `/\w/` guard node-row.svelte applies when rendering these
- *   nodes inline — otherwise the header would render blank with no placeholder.
- * - otherwise — `content` is the source of truth. The store's cached `title` is only
- *   refreshed by a backend round-trip, while optimistic content updates leave it untouched,
- *   so preferring `title` here would surface a stale value (e.g. a title captured mid-slash
- *   command, before the node's type conversion) whenever the header loses focus.
- *
- * Markdown header syntax is stripped from content only (`## Foo` → `Foo`), for header nodes
- * whose content carries the `#` markers. A template-computed title is built from property
- * values and has no such syntax to strip.
+ * Delegates the title-vs-content decision to `resolveTitleOrContent` (see that function for
+ * the full rule and why it exists) and additionally strips markdown header syntax from a
+ * content-sourced value (`## Foo` → `Foo`), for header nodes whose content carries the `#`
+ * markers. A template-computed title is built from property values and has no such syntax
+ * to strip, so the stripping only applies on the `content` branch.
  */
 export function computeHeaderDisplayValue(
   node: { title?: string | null; content?: string | null } | null | undefined,
   hasTitleTemplate: boolean
 ): string {
-  if (hasTitleTemplate) {
-    const title = node?.title ?? '';
-    return /\w/.test(title) ? title : '';
-  }
-  return (node?.content ?? '').replace(/^#+\s*/, '');
+  const value = resolveTitleOrContent(node, hasTitleTemplate);
+  return hasTitleTemplate ? value : value.replace(/^#+\s*/, '');
 }
diff --git a/packages/desktop-app/src/lib/plugins/plugin-registry.ts b/packages/desktop-app/src/lib/plugins/plugin-registry.ts
index 5f504ea4d..76be4d637 100644
--- a/packages/desktop-app/src/lib/plugins/plugin-registry.ts
+++ b/packages/desktop-app/src/lib/plugins/plugin-registry.ts
@@ -24,6 +24,7 @@ import type {
 } from './types';
 import type { Node } from '$lib/types';
 import { createLogger } from '$lib/utils/logger';
+import { resolveTitleOrContent } from '$lib/utils/node-display-title';
 
 const log = createLogger('PluginRegistry');
 
@@ -453,20 +454,45 @@ export class PluginRegistry {
   }
 
   /**
-   * Compute a node's tab title via its plugin's getTitle, falling back to
-   * node.title || node.content when the plugin doesn't define one.
+   * The node's current display value using the title-vs-content rule alone — see
+   * `resolveTitleOrContent`'s doc comment for the full rule and the frontend/backend
+   * agreement it depends on. No `plugin.getTitle` override.
    *
-   * node.title is computed and persisted by the backend (interpolated from the node
-   * type's schema title_template, when one exists — see NodeService::compute_title in
-   * the Rust core) — it's already the right display title for any node type without
-   * type-specific title logic, so no client-side schema lookup is needed here.
+   * This is the single call site every row-based, one-node-per-line surface (query
+   * list/kanban/table views, the collections sidebar) should use rather than re-deriving
+   * title-vs-content themselves. It deliberately does NOT apply a type's `getTitle` override
+   * (e.g. the date plugin's "Today"/"Tomorrow" formatting) — those surfaces show plain node
+   * text, not a tab-specific title, and a date node's `id` is only guaranteed to parse as a
+   * date in production, not in every synthetic id these surfaces might encounter.
+   *
+   * `hasTitleTemplate` comes from `findSlashCommand`'s flag — the same one `node-row.svelte`
+   * uses for the identical purpose when rendering a custom-entity node inline.
+   *
+   * @param formatContent - Optional reformatting (e.g. `stripMarkdown`) applied ONLY when the
+   * resolved value came from `content` — never on a title_template-computed title, which is a
+   * property value assembled by the template, not raw markdown/text to reformat. A caller
+   * that unconditionally wraps this method's return value in its own formatter instead would
+   * apply that formatting to a computed title too, corrupting property values containing
+   * formatting-significant characters (underscores, asterisks, backticks).
+   */
+  resolveDisplayTitle(node: Node, formatContent?: (content: string) => string): string {
+    const hasTitleTemplate = !!this.findSlashCommand(node.nodeType)?.hasTitleTemplate;
+    const value = resolveTitleOrContent(node, hasTitleTemplate);
+    return hasTitleTemplate || !formatContent ? value : formatContent(value);
+  }
+
+  /**
+   * Compute a node's tab title. Delegates to the plugin's `getTitle` when one is registered
+   * (e.g. date nodes format "Today"/"Tomorrow" from their id, not from content) — that
+   * override is specific to the tab-title contract, unlike `resolveDisplayTitle` above.
+   * Otherwise falls back to `resolveDisplayTitle`.
    */
   getNodeTitle(node: Node): string | undefined {
     const plugin = this.plugins.get(node.nodeType);
     if (plugin && this.enabledPlugins.has(node.nodeType) && plugin.getTitle) {
       return plugin.getTitle(node);
     }
-    return node.title || node.content || undefined;
+    return this.resolveDisplayTitle(node) || undefined;
   }
 
   /**
diff --git a/packages/desktop-app/src/lib/stores/collections.svelte.ts b/packages/desktop-app/src/lib/stores/collections.svelte.ts
index 0bf0ee651..f443df3ee 100644
--- a/packages/desktop-app/src/lib/stores/collections.svelte.ts
+++ b/packages/desktop-app/src/lib/stores/collections.svelte.ts
@@ -4,6 +4,7 @@ import { createLogger } from '$lib/utils/logger';
 import { onDaemonReconnect } from '$lib/services/daemon-status';
 import { stripMarkdown } from '$lib/services/markdown-utils';
 import { databaseStore } from '$lib/stores/database.svelte';
+import { pluginRegistry } from '$lib/plugins/plugin-registry';
 
 const log = createLogger('CollectionsStore');
 
@@ -439,10 +440,15 @@ class CollectionsStore {
           .filter((node) => !NON_CONTENT_NODE_TYPES.has(node.nodeType))
           .map((node) => ({
             id: node.id,
-            // Prefer the cleaned title; fall back to the node content with its
-            // markdown stripped so an imported header root shows "ACP Integration
-            // Architecture", not the raw "# ACP Integration Architecture".
-            name: node.title || stripMarkdown(node.content),
+            // pluginRegistry.resolveDisplayTitle already picks title vs. content correctly
+            // (title only for title_template-driven schemas — a plain node.title fallback is
+            // stale for everything else, since it's only refreshed by a backend round-trip).
+            // stripMarkdown is passed in as the content formatter, not wrapped around the
+            // whole call, so it cleans an imported header root ("# ACP Integration
+            // Architecture" -> "ACP Integration Architecture") WITHOUT also running over a
+            // title_template-computed name, which is a property value, not markdown — a name
+            // containing an underscore or asterisk would otherwise get silently mangled.
+            name: pluginRegistry.resolveDisplayTitle(node, stripMarkdown),
             nodeType: node.nodeType,
           }))
       );
diff --git a/packages/desktop-app/src/lib/utils/node-display-title.ts b/packages/desktop-app/src/lib/utils/node-display-title.ts
new file mode 100644
index 000000000..24baf3e2e
--- /dev/null
+++ b/packages/desktop-app/src/lib/utils/node-display-title.ts
@@ -0,0 +1,45 @@
+/**
+ * The single rule for choosing between a node's `title` and `content` as its current
+ * display value.
+ *
+ * `sharedNodeStore`'s cached `title` is refreshed only by a backend round-trip. Optimistic
+ * content edits patch `content` and leave `title` untouched, so `title` is stale for any
+ * node whose schema doesn't compute it — e.g. a title captured mid-slash-command, before a
+ * node's type conversion, or simply the last-synced value for a node whose content has since
+ * changed. `node.title || node.content` (the pattern this replaces) surfaces that stale value
+ * on every surface using it.
+ *
+ * The correct rule: prefer `title` only when the node's schema is genuinely title_template-
+ * driven — there `title` is computed from properties and is a legitimately different value
+ * from `content`, so it's the only valid display value (an unresolved template renders empty,
+ * not a fallback to content). Every other type has `content` as its source of truth.
+ *
+ * Callers determine `hasTitleTemplate` themselves, since the answer comes from different
+ * places depending on context (a `SchemaFormLoader` instance inside a node viewer;
+ * `pluginRegistry.findSlashCommand(nodeType)?.hasTitleTemplate` outside one — see
+ * `schema-form-loader.svelte.ts`'s `hasTitleTemplate` getter for why the two agree: the
+ * frontend's notion of "title_template-driven" is custom-schema-scoped, while the backend's
+ * `compute_title()` applies a title_template to any schema carrying one, core or not; they
+ * agree only because no core type ships a template today).
+ */
+/**
+ * Matches any Unicode letter or number. Used (not the ASCII-only `\w`) so a fully-resolved
+ * title in a non-Latin script (e.g. a `{first_name} {last_name}` template evaluating to a
+ * CJK or Arabic name) is correctly recognized as resolved, not misclassified as empty
+ * alongside a genuinely-unresolved separator-only value like `" — "` — see the guard below.
+ */
+const HAS_RESOLVED_CHARACTER_RE = /[\p{L}\p{N}]/u;
+
+export function resolveTitleOrContent(
+  node: { title?: string | null; content?: string | null } | null | undefined,
+  hasTitleTemplate: boolean
+): string {
+  if (hasTitleTemplate) {
+    const title = node?.title ?? '';
+    // A title with no letters or numbers in any script (e.g. the `" "` left by a
+    // `"{first} {last}"` template with both fields empty, or `" — "` left by a template
+    // whose only literal text is a separator) counts as unresolved.
+    return HAS_RESOLVED_CHARACTER_RE.test(title) ? title : '';
+  }
+  return node?.content ?? '';
+}
diff --git a/packages/desktop-app/src/tests/components/kanban-view-title.test.ts b/packages/desktop-app/src/tests/components/kanban-view-title.test.ts
new file mode 100644
index 000000000..952980259
--- /dev/null
+++ b/packages/desktop-app/src/tests/components/kanban-view-title.test.ts
@@ -0,0 +1,125 @@
+/**
+ * KanbanView — stale-title regression (issue #2012).
+ *
+ * See list-view.test.ts for the full root-cause explanation. KanbanView's `titleOf` used
+ * `node.title || node.content`, so a card for a node whose title went stale showed the wrong
+ * text. It must now show current content for non-template types, and still show the computed
+ * title for title_template-driven custom entities.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { render, cleanup } from '@testing-library/svelte';
+import type { SchemaNode } from '$lib/types/schema-node';
+import type { Node } from '$lib/types';
+
+import { mockTauriCore } from '../helpers/mock-tauri-core';
+
+vi.mock('@tauri-apps/api/core', () => mockTauriCore());
+
+import KanbanView from '$lib/components/query/kanban-view.svelte';
+import { sharedNodeStore } from '$lib/services/shared-node-store.svelte';
+import { pluginRegistry } from '$lib/plugins/index';
+
+function schema(): SchemaNode {
+  return {
+    id: 'widget',
+    content: 'Widget',
+    createdAt: '2026-01-01T00:00:00Z',
+    modifiedAt: '2026-01-01T00:00:00Z',
+    version: 1,
+    isCore: false,
+    schemaVersion: 1,
+    fields: [
+      {
+        name: 'status',
+        friendlyName: 'Status',
+        type: 'enum',
+        protection: 'user',
+        indexed: false,
+        coreValues: [{ value: 'open', label: 'Open' }],
+        userValues: []
+      }
+    ]
+  };
+}
+
+function baseNode(overrides: Partial<Node> = {}): Node {
+  return {
+    id: 'n1',
+    nodeType: 'task',
+    content: 'current content',
+    createdAt: '2026-01-01T00:00:00Z',
+    modifiedAt: '2026-01-01T00:00:00Z',
+    version: 1,
+    properties: { status: 'open' },
+    mentions: [],
+    ...overrides
+  };
+}
+
+describe('KanbanView — stale title regression', () => {
+  beforeEach(() => {
+    sharedNodeStore.clearAll();
+  });
+
+  afterEach(() => {
+    cleanup();
+    sharedNodeStore.clearAll();
+    pluginRegistry.unregister('widget-entity');
+  });
+
+  it('shows current content, not a stale cached title, for a non-template type', () => {
+    const node = baseNode({ title: '/', content: 'Another Task' });
+    sharedNodeStore.setNode(node, { type: 'database', reason: 'seed' });
+
+    const { container } = render(KanbanView, {
+      props: {
+        nodeIds: [node.id],
+        schema: schema(),
+        groupBy: 'status',
+        onGroupByChange: () => {},
+        onRowClick: () => {}
+      }
+    });
+
+    const card = container.querySelector('.kanban-card-title');
+    expect(card?.textContent?.trim()).toBe('Another Task');
+  });
+
+  it('still shows the computed title for a title_template-driven custom entity', () => {
+    pluginRegistry.register({
+      id: 'widget-entity',
+      name: 'Widget',
+      description: 'Custom entity with a title template',
+      version: '1.0.0',
+      config: {
+        slashCommands: [
+          {
+            id: 'widget-entity',
+            name: 'Widget',
+            description: 'Create Widget',
+            contentTemplate: '',
+            nodeType: 'widget-entity',
+            hasTitleTemplate: true,
+            titleTemplate: '{first_name} {last_name}'
+          }
+        ]
+      }
+    });
+
+    const node = baseNode({ nodeType: 'widget-entity', content: 'raw', title: 'Jane Doe' });
+    sharedNodeStore.setNode(node, { type: 'database', reason: 'seed' });
+
+    const { container } = render(KanbanView, {
+      props: {
+        nodeIds: [node.id],
+        schema: schema(),
+        groupBy: 'status',
+        onGroupByChange: () => {},
+        onRowClick: () => {}
+      }
+    });
+
+    const card = container.querySelector('.kanban-card-title');
+    expect(card?.textContent?.trim()).toBe('Jane Doe');
+  });
+});
diff --git a/packages/desktop-app/src/tests/components/list-view.test.ts b/packages/desktop-app/src/tests/components/list-view.test.ts
new file mode 100644
index 000000000..a6b761eaf
--- /dev/null
+++ b/packages/desktop-app/src/tests/components/list-view.test.ts
@@ -0,0 +1,93 @@
+/**
+ * ListView — stale-title regression (issue #2012).
+ *
+ * `sharedNodeStore`'s cached `title` only refreshes via a backend round-trip; optimistic
+ * content updates patch `content` and leave `title` untouched. ListView used to render
+ * `node.title || node.content`, so a node whose title went stale (e.g. captured while it
+ * was still `text`, before conversion to `task`) showed the wrong row text. It must now
+ * show current content for non-template types, and still show the computed title for
+ * title_template-driven custom entities.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { render, cleanup } from '@testing-library/svelte';
+import type { Node } from '$lib/types';
+
+import { mockTauriCore } from '../helpers/mock-tauri-core';
+
+vi.mock('@tauri-apps/api/core', () => mockTauriCore());
+
+import ListView from '$lib/components/query/list-view.svelte';
+import { sharedNodeStore } from '$lib/services/shared-node-store.svelte';
+import { pluginRegistry } from '$lib/plugins/index';
+
+function baseNode(overrides: Partial<Node> = {}): Node {
+  return {
+    id: 'n1',
+    nodeType: 'task',
+    content: 'current content',
+    createdAt: '2026-01-01T00:00:00Z',
+    modifiedAt: '2026-01-01T00:00:00Z',
+    version: 1,
+    properties: {},
+    mentions: [],
+    ...overrides
+  };
+}
+
+describe('ListView — stale title regression', () => {
+  beforeEach(() => {
+    sharedNodeStore.clearAll();
+  });
+
+  afterEach(() => {
+    cleanup();
+    sharedNodeStore.clearAll();
+    // Idempotent no-op if a test didn't register it.
+    pluginRegistry.unregister('widget-entity');
+  });
+
+  it('shows current content, not a stale cached title, for a non-template type', () => {
+    const node = baseNode({ title: '/', content: 'Another Task' });
+    sharedNodeStore.setNode(node, { type: 'database', reason: 'seed' });
+
+    const { container } = render(ListView, {
+      props: { nodeIds: [node.id], onRowClick: () => {} }
+    });
+
+    const row = container.querySelector('.list-row');
+    expect(row?.textContent?.trim()).toBe('Another Task');
+  });
+
+  it('still shows the computed title for a title_template-driven custom entity', () => {
+    expect(pluginRegistry.hasPlugin('widget-entity')).toBe(false);
+    pluginRegistry.register({
+      id: 'widget-entity',
+      name: 'Widget',
+      description: 'Custom entity with a title template',
+      version: '1.0.0',
+      config: {
+        slashCommands: [
+          {
+            id: 'widget-entity',
+            name: 'Widget',
+            description: 'Create Widget',
+            contentTemplate: '',
+            nodeType: 'widget-entity',
+            hasTitleTemplate: true,
+            titleTemplate: '{first_name} {last_name}'
+          }
+        ]
+      }
+    });
+
+    const node = baseNode({ nodeType: 'widget-entity', content: 'raw', title: 'Jane Doe' });
+    sharedNodeStore.setNode(node, { type: 'database', reason: 'seed' });
+
+    const { container } = render(ListView, {
+      props: { nodeIds: [node.id], onRowClick: () => {} }
+    });
+
+    const row = container.querySelector('.list-row');
+    expect(row?.textContent?.trim()).toBe('Jane Doe');
+  });
+});
diff --git a/packages/desktop-app/src/tests/components/table-row.test.ts b/packages/desktop-app/src/tests/components/table-row.test.ts
new file mode 100644
index 000000000..11248adec
--- /dev/null
+++ b/packages/desktop-app/src/tests/components/table-row.test.ts
@@ -0,0 +1,95 @@
+/**
+ * TableRow — stale-title regression (issue #2012).
+ *
+ * See list-view.test.ts for the full root-cause explanation. The 'content' column used to
+ * prefer `node.title` unconditionally, so a row for a node whose title went stale showed the
+ * wrong text. It must now show current content for non-template types, and still show the
+ * computed title for title_template-driven custom entities. The row's tooltip (built from the
+ * same source) is covered too.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { render, cleanup } from '@testing-library/svelte';
+import type { SchemaField } from '$lib/types/schema-node';
+import type { Node } from '$lib/types';
+
+import { mockTauriCore } from '../helpers/mock-tauri-core';
+
+vi.mock('@tauri-apps/api/core', () => mockTauriCore());
+
+import TableRow from '$lib/components/query/table-row.svelte';
+import { sharedNodeStore } from '$lib/services/shared-node-store.svelte';
+import { pluginRegistry } from '$lib/plugins/index';
+
+function baseNode(overrides: Partial<Node> = {}): Node {
+  return {
+    id: 'n1',
+    nodeType: 'task',
+    content: 'current content',
+    createdAt: '2026-01-01T00:00:00Z',
+    modifiedAt: '2026-01-01T00:00:00Z',
+    version: 1,
+    properties: {},
+    mentions: [],
+    ...overrides
+  };
+}
+
+const columns = [{ field: 'content', label: 'Content' }];
+const emptyFieldSchemaMap = new Map<string, SchemaField>();
+
+describe('TableRow — stale title regression', () => {
+  beforeEach(() => {
+    sharedNodeStore.clearAll();
+  });
+
+  afterEach(() => {
+    cleanup();
+    sharedNodeStore.clearAll();
+    pluginRegistry.unregister('widget-entity');
+  });
+
+  it('shows current content, not a stale cached title, for a non-template type', () => {
+    const node = baseNode({ title: '/', content: 'Another Task' });
+    sharedNodeStore.setNode(node, { type: 'database', reason: 'seed' });
+
+    const { container, getByRole } = render(TableRow, {
+      props: { id: node.id, columns, fieldSchemaMap: emptyFieldSchemaMap, onRowClick: () => {} }
+    });
+
+    const cell = container.querySelector('td');
+    expect(cell?.textContent?.trim()).toBe('Another Task');
+    expect(getByRole('button', { name: /Another Task/ })).toBeTruthy();
+  });
+
+  it('still shows the computed title for a title_template-driven custom entity', () => {
+    pluginRegistry.register({
+      id: 'widget-entity',
+      name: 'Widget',
+      description: 'Custom entity with a title template',
+      version: '1.0.0',
+      config: {
+        slashCommands: [
+          {
+            id: 'widget-entity',
+            name: 'Widget',
+            description: 'Create Widget',
+            contentTemplate: '',
+            nodeType: 'widget-entity',
+            hasTitleTemplate: true,
+            titleTemplate: '{first_name} {last_name}'
+          }
+        ]
+      }
+    });
+
+    const node = baseNode({ nodeType: 'widget-entity', content: 'raw', title: 'Jane Doe' });
+    sharedNodeStore.setNode(node, { type: 'database', reason: 'seed' });
+
+    const { container } = render(TableRow, {
+      props: { id: node.id, columns, fieldSchemaMap: emptyFieldSchemaMap, onRowClick: () => {} }
+    });
+
+    const cell = container.querySelector('td');
+    expect(cell?.textContent?.trim()).toBe('Jane Doe');
+  });
+});
diff --git a/packages/desktop-app/src/tests/plugins/plugin-registry.test.ts b/packages/desktop-app/src/tests/plugins/plugin-registry.test.ts
index 390957ab2..5f724457c 100644
--- a/packages/desktop-app/src/tests/plugins/plugin-registry.test.ts
+++ b/packages/desktop-app/src/tests/plugins/plugin-registry.test.ts
@@ -1551,7 +1551,11 @@ describe('PluginRegistry - Core Functionality', () => {
       expect(plugin.getTitle).toHaveBeenCalledWith(node);
     });
 
-    it('falls back to node.title when plugin has no getTitle', () => {
+    it('prefers content over a stale node.title for a non-template type (issue #2012)', () => {
+      // Regression: a node without a title_template (e.g. task) has its `title` refreshed
+      // only by a backend round-trip, while optimistic content edits patch `content`
+      // directly. A stale title left over from an earlier state (e.g. a slash command typed
+      // before the node converted type) must not win over current content.
       const plugin: PluginDefinition = {
         id: 'task',
         name: 'Task',
@@ -1563,12 +1567,46 @@ describe('PluginRegistry - Core Functionality', () => {
 
       // createTestNode() doesn't copy `title` from options, so set it directly.
       const node = {
-        ...createTestNode({ nodeType: 'task', content: 'raw content' }),
-        title: 'Interpolated Title'
+        ...createTestNode({ nodeType: 'task', content: 'current content' }),
+        title: 'Stale Title'
       };
       const title = registry.getNodeTitle(node);
 
-      expect(title).toBe('Interpolated Title');
+      expect(title).toBe('current content');
+    });
+
+    it('prefers node.title for a title_template-driven custom entity type', () => {
+      // A custom entity schema with a title_template registers hasTitleTemplate on its
+      // slash command (schema-plugin-loader.ts) — that's the signal getNodeTitle uses to
+      // know title is computed and legitimately distinct from content.
+      const plugin: PluginDefinition = {
+        id: 'person',
+        name: 'Person',
+        description: 'Person plugin',
+        version: '1.0.0',
+        config: {
+          slashCommands: [
+            {
+              id: 'person',
+              name: 'Person',
+              description: 'Create Person',
+              contentTemplate: '',
+              nodeType: 'person',
+              hasTitleTemplate: true,
+              titleTemplate: '{first_name} {last_name}'
+            }
+          ]
+        }
+      };
+      registry.register(plugin);
+
+      const node = {
+        ...createTestNode({ nodeType: 'person', content: '' }),
+        title: 'Jane Doe'
+      };
+      const title = registry.getNodeTitle(node);
+
+      expect(title).toBe('Jane Doe');
     });
 
     it('falls back to node.content when node.title is absent', () => {
@@ -1587,7 +1625,7 @@ describe('PluginRegistry - Core Functionality', () => {
       expect(title).toBe('raw content');
     });
 
-    it('falls back to node.title || node.content for an unregistered nodeType', () => {
+    it('falls back to content (no title_template signal) for an unregistered nodeType', () => {
       const node = createTestNode({ nodeType: 'unregistered-type', content: 'some content' });
       const title = registry.getNodeTitle(node);
 
@@ -1616,6 +1654,124 @@ describe('PluginRegistry - Core Functionality', () => {
     });
   });
 
+  describe('resolveDisplayTitle (issue #2012)', () => {
+    // Used by row-based surfaces (query list/kanban/table views, the collections sidebar)
+    // instead of getNodeTitle: same title-vs-content rule, but never applies a plugin's
+    // getTitle override (e.g. date's "Today"/"Tomorrow" formatting) — those surfaces show
+    // plain node text, not a tab-specific title.
+
+    it('returns content over a stale title for a non-template type', () => {
+      const plugin: PluginDefinition = {
+        id: 'task',
+        name: 'Task',
+        description: 'Task plugin',
+        version: '1.0.0',
+        config: { slashCommands: [] }
+      };
+      registry.register(plugin);
+
+      const node = {
+        ...createTestNode({ nodeType: 'task', content: 'current content' }),
+        title: 'Stale Title'
+      };
+
+      expect(registry.resolveDisplayTitle(node)).toBe('current content');
+    });
+
+    it('returns title for a title_template-driven custom entity type', () => {
+      const plugin: PluginDefinition = {
+        id: 'person',
+        name: 'Person',
+        description: 'Person plugin',
+        version: '1.0.0',
+        config: {
+          slashCommands: [
+            {
+              id: 'person',
+              name: 'Person',
+              description: 'Create Person',
+              contentTemplate: '',
+              nodeType: 'person',
+              hasTitleTemplate: true,
+              titleTemplate: '{first_name} {last_name}'
+            }
+          ]
+        }
+      };
+      registry.register(plugin);
+
+      const node = { ...createTestNode({ nodeType: 'person', content: '' }), title: 'Jane Doe' };
+
+      expect(registry.resolveDisplayTitle(node)).toBe('Jane Doe');
+    });
+
+    it('ignores a plugin getTitle override, unlike getNodeTitle', () => {
+      const plugin: PluginDefinition = {
+        id: 'date',
+        name: 'Date',
+        description: 'Date plugin',
+        version: '1.0.0',
+        config: { slashCommands: [] },
+        getTitle: vi.fn().mockReturnValue('Today')
+      };
+      registry.register(plugin);
+
+      const node = createTestNode({ nodeType: 'date', content: '2026-07-07' });
+
+      expect(registry.resolveDisplayTitle(node)).toBe('2026-07-07');
+      expect(registry.getNodeTitle(node)).toBe('Today');
+    });
+
+    it('applies formatContent to a content-sourced value', () => {
+      const plugin: PluginDefinition = {
+        id: 'text',
+        name: 'Text',
+        description: 'Text plugin',
+        version: '1.0.0',
+        config: { slashCommands: [] }
+      };
+      registry.register(plugin);
+
+      const node = createTestNode({ nodeType: 'text', content: '# Heading' });
+      const formatContent = vi.fn((c: string) => c.replace(/^#+\s*/, ''));
+
+      expect(registry.resolveDisplayTitle(node, formatContent)).toBe('Heading');
+      expect(formatContent).toHaveBeenCalledWith('# Heading');
+    });
+
+    it('does NOT apply formatContent to a title_template-computed title', () => {
+      // Regression: a caller that wraps the whole return value in a formatter (instead of
+      // passing it through this parameter) would run the formatter over a computed property
+      // value too — e.g. stripMarkdown mangling a name containing an underscore or asterisk.
+      const plugin: PluginDefinition = {
+        id: 'person',
+        name: 'Person',
+        description: 'Person plugin',
+        version: '1.0.0',
+        config: {
+          slashCommands: [
+            {
+              id: 'person',
+              name: 'Person',
+              description: 'Create Person',
+              contentTemplate: '',
+              nodeType: 'person',
+              hasTitleTemplate: true,
+              titleTemplate: '{first_name}_{last_name}'
+            }
+          ]
+        }
+      };
+      registry.register(plugin);
+
+      const node = { ...createTestNode({ nodeType: 'person', content: '' }), title: 'Jane_Doe' };
+      const formatContent = vi.fn((c: string) => c.replace(/_/g, ''));
+
+      expect(registry.resolveDisplayTitle(node, formatContent)).toBe('Jane_Doe');
+      expect(formatContent).not.toHaveBeenCalled();
+    });
+  });
+
   describe('Content Merge Acceptance', () => {
     it('should return false for plugins with acceptsContentMerge: false', () => {
       const plugin: PluginDefinition = {
diff --git a/packages/desktop-app/src/tests/stores/collections.test.ts b/packages/desktop-app/src/tests/stores/collections.test.ts
index b106d952b..120900b84 100644
--- a/packages/desktop-app/src/tests/stores/collections.test.ts
+++ b/packages/desktop-app/src/tests/stores/collections.test.ts
@@ -2,7 +2,7 @@
  * Unit tests for collections store - Collection browser state management
  */
 
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   collectionsState,
   collectionsData,
@@ -17,6 +17,7 @@ import {
 import type { CollectionInfo } from '$lib/services/collection-service';
 import type { Node } from '$lib/types';
 import { mockCollections, mockMembers } from '../fixtures/collections-fixtures';
+import { pluginRegistry } from '$lib/plugins/index';
 
 // Convert mock data to CollectionInfo format for testing
 function createTestCollectionInfo(item: CollectionItem, parentId?: string): CollectionInfo {
@@ -450,6 +451,140 @@ describe('Collections Store', () => {
     });
   });
 
+  describe('selectedCollectionMembers title-vs-content (issue #2012)', () => {
+    afterEach(() => {
+      pluginRegistry.unregister('widget-entity');
+    });
+
+    it('shows current content, not a stale cached title, for a non-template type', () => {
+      // sharedNodeStore's cached `title` only refreshes via a backend round-trip; optimistic
+      // content edits patch `content` directly. A member row must reflect current content,
+      // not a title computed for an earlier state.
+      const members = new Map<string, Node[]>([
+        [
+          'col-1',
+          [
+            {
+              id: 'node-1',
+              content: 'Another Task',
+              title: '/',
+              nodeType: 'task',
+              createdAt: new Date().toISOString(),
+              modifiedAt: new Date().toISOString(),
+              version: 1,
+              properties: {}
+            }
+          ]
+        ]
+      ]);
+      collectionsData._setTestData(flattenCollections(mockCollections), members);
+
+      collectionsState.selectCollection('col-1');
+
+      expect(collectionsState.selectedCollectionMembers).toEqual([
+        { id: 'node-1', name: 'Another Task', nodeType: 'task' }
+      ]);
+    });
+
+    it('still shows the computed title for a title_template-driven custom entity', () => {
+      pluginRegistry.register({
+        id: 'widget-entity',
+        name: 'Widget',
+        description: 'Custom entity with a title template',
+        version: '1.0.0',
+        config: {
+          slashCommands: [
+            {
+              id: 'widget-entity',
+              name: 'Widget',
+              description: 'Create Widget',
+              contentTemplate: '',
+              nodeType: 'widget-entity',
+              hasTitleTemplate: true,
+              titleTemplate: '{first_name} {last_name}'
+            }
+          ]
+        }
+      });
+
+      const members = new Map<string, Node[]>([
+        [
+          'col-1',
+          [
+            {
+              id: 'node-1',
+              content: 'raw',
+              title: 'Jane Doe',
+              nodeType: 'widget-entity',
+              createdAt: new Date().toISOString(),
+              modifiedAt: new Date().toISOString(),
+              version: 1,
+              properties: {}
+            }
+          ]
+        ]
+      ]);
+      collectionsData._setTestData(flattenCollections(mockCollections), members);
+
+      collectionsState.selectCollection('col-1');
+
+      expect(collectionsState.selectedCollectionMembers).toEqual([
+        { id: 'node-1', name: 'Jane Doe', nodeType: 'widget-entity' }
+      ]);
+    });
+
+    it('does not run a template-computed title through markdown stripping', () => {
+      // Regression: stripMarkdown must apply only to a content-sourced value, never to a
+      // title_template-computed title — that's a property value, not markdown, and
+      // stripMarkdown's bold/italic/code regexes would otherwise mangle any paired `_`/`*`/
+      // backtick in it (e.g. a name or slug containing an underscore).
+      pluginRegistry.register({
+        id: 'widget-entity',
+        name: 'Widget',
+        description: 'Custom entity with a title template',
+        version: '1.0.0',
+        config: {
+          slashCommands: [
+            {
+              id: 'widget-entity',
+              name: 'Widget',
+              description: 'Create Widget',
+              contentTemplate: '',
+              nodeType: 'widget-entity',
+              hasTitleTemplate: true,
+              titleTemplate: '{first_name}_{last_name}'
+            }
+          ]
+        }
+      });
+
+      const members = new Map<string, Node[]>([
+        [
+          'col-1',
+          [
+            {
+              id: 'node-1',
+              content: 'raw',
+              title: 'Jane_Doe',
+              nodeType: 'widget-entity',
+              createdAt: new Date().toISOString(),
+              modifiedAt: new Date().toISOString(),
+              version: 1,
+              properties: {}
+            }
+          ]
+        ]
+      ]);
+      collectionsData._setTestData(flattenCollections(mockCollections), members);
+
+      collectionsState.selectCollection('col-1');
+
+      expect(collectionsState.selectedCollectionMembers).toEqual([
+        { id: 'node-1', name: 'Jane_Doe', nodeType: 'widget-entity' }
+      ]);
+    });
+  });
+
   describe('collectionsTree hide-empty filter', () => {
     it('hides top-level collections with no visible members', () => {
       // Fixtures include col-3 "Research Papers" with memberCount: 0 (leaf).
diff --git a/packages/desktop-app/src/tests/utils/node-display-title.test.ts b/packages/desktop-app/src/tests/utils/node-display-title.test.ts
new file mode 100644
index 000000000..86f83286f
--- /dev/null
+++ b/packages/desktop-app/src/tests/utils/node-display-title.test.ts
@@ -0,0 +1,67 @@
+/**
+ * Unit tests for resolveTitleOrContent — the shared title-vs-content rule.
+ *
+ * Consolidation for issue #2012: computeHeaderDisplayValue (design/node-type-predicates.ts)
+ * and PluginRegistry.resolveDisplayTitle/getNodeTitle both delegate here, so these tests
+ * pin the core rule once rather than being re-verified per call site.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { resolveTitleOrContent } from '$lib/utils/node-display-title';
+
+describe('resolveTitleOrContent', () => {
+  describe('non-template types (content is the source of truth)', () => {
+    it('returns content, ignoring a stale title', () => {
+      // e.g. a node whose title was computed while it was still `text` (content "/"),
+      // then converted to `task` with new content — title was never refreshed.
+      expect(resolveTitleOrContent({ title: '/', content: 'Another Task' }, false)).toBe(
+        'Another Task'
+      );
+    });
+
+    it('returns empty string, not a stale title, when content is empty', () => {
+      expect(resolveTitleOrContent({ title: '/', content: '' }, false)).toBe('');
+    });
+
+    it('does not strip markdown syntax from content', () => {
+      // Stripping is a presentation concern for specific callers (e.g. header markdown
+      // syntax, formatTabTitle, stripMarkdown) — this function returns the raw value.
+      expect(resolveTitleOrContent({ content: '## Heading' }, false)).toBe('## Heading');
+    });
+  });
+
+  describe('title_template-driven schemas (title is property-computed)', () => {
+    it('returns the computed title, ignoring content', () => {
+      expect(resolveTitleOrContent({ title: 'Acme Corp — Invoice', content: 'raw' }, true)).toBe(
+        'Acme Corp — Invoice'
+      );
+    });
+
+    it('returns empty rather than falling back to content when title has not resolved', () => {
+      expect(resolveTitleOrContent({ title: '', content: 'raw content' }, true)).toBe('');
+    });
+
+    it('treats a title with no letters or numbers as unresolved', () => {
+      // e.g. "{first_name} {last_name}" with both fields empty resolves to " ".
+      expect(resolveTitleOrContent({ title: ' ', content: 'raw' }, true)).toBe('');
+      // A template whose only literal text is a separator (e.g. "{first} — {last}" with
+      // both fields empty) resolves to punctuation and whitespace only — still unresolved.
+      expect(resolveTitleOrContent({ title: ' — ', content: 'raw' }, true)).toBe('');
+    });
+
+    it('recognizes a resolved title in a non-Latin script, not just ASCII word characters', () => {
+      // A regression an ASCII-only `\w` guard would get wrong: these are fully-resolved
+      // template values (e.g. a Person's {first_name} {last_name}) containing no ASCII
+      // letters at all, not unresolved templates — they must NOT render empty.
+      expect(resolveTitleOrContent({ title: '田中太郎', content: 'raw' }, true)).toBe('田中太郎');
+      expect(resolveTitleOrContent({ title: 'محمد', content: 'raw' }, true)).toBe('محمد');
+    });
+  });
+
+  it('handles a missing node', () => {
+    expect(resolveTitleOrContent(undefined, false)).toBe('');
+    expect(resolveTitleOrContent(undefined, true)).toBe('');
+    expect(resolveTitleOrContent(null, false)).toBe('');
+    expect(resolveTitleOrContent(null, true)).toBe('');
+  });
+});