diff --git a/ai/core/AIConfig.js b/ai/core/AIConfig.js
index 5ecc641..074d2c1 100644
--- a/ai/core/AIConfig.js
+++ b/ai/core/AIConfig.js
@@ -157,8 +157,8 @@ class AIConfig {
           enablePatternLearning: true,
           enableEmbeddings: true,
           enableRelationshipDiscovery: true,
-          maxTokensPerQuery: 2048,
-          temperature: 0.7,
+          graphProvider: 'gliner-glirel',
+          graphConfidence: 0.60,
           providerModels: {},
         };
       }
diff --git a/ai/graph/GLiNERExtractor.js b/ai/graph/GLiNERExtractor.js
new file mode 100644
index 0000000..cb8a73f
--- /dev/null
+++ b/ai/graph/GLiNERExtractor.js
@@ -0,0 +1,173 @@
+const fs = require('fs');
+const path = require('path');
+const { createLogger } = require('../core/logger');
+
+const log = createLogger('GLiNERExtractor');
+
+class GLiNERExtractor {
+  constructor(appDataDir) {
+    this.modelDir = path.join(appDataDir, 'notely', 'ai-model', 'gliner-glirel');
+    this.session = null;
+    this.isLoaded = false;
+    this.ort = null;
+    this.segmenter = typeof Intl !== 'undefined' && Intl.Segmenter
+      ? new Intl.Segmenter('en', { granularity: 'sentence' })
+      : null;
+  }
+
+  getModelPath() {
+    return path.join(this.modelDir, 'gliner.onnx');
+  }
+
+  isAvailable() {
+    return this.isLoaded || fs.existsSync(this.getModelPath());
+  }
+
+  async load() {
+    if (this.isLoaded) return;
+    try {
+      log.info('Loading local GLiNER ONNX session...');
+      try {
+        this.ort = require('onnxruntime-node');
+      } catch {
+        this.ort = require('onnxruntime-web');
+      }
+
+      const modelPath = this.getModelPath();
+      if (fs.existsSync(modelPath)) {
+        this.session = await this.ort.InferenceSession.create(modelPath);
+      }
+
+      this.isLoaded = true;
+      log.info('GLiNER ONNX session initialized successfully.');
+    } catch (err) {
+      this.isLoaded = false;
+      log.error('Failed to load GLiNER ONNX session:', err.message);
+    }
+  }
+
+  segmentSentences(text) {
+    if (!text || typeof text !== 'string') return [];
+    if (this.segmenter) {
+      const segments = Array.from(this.segmenter.segment(text));
+      return segments.map(s => ({
+        text: s.segment,
+        index: s.index,
+        length: s.segment.length
+      })).filter(s => s.text.trim().length > 3);
+    }
+    const sentences = [];
+    const re = /(?<=[.!?])\s+/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+      const sentText = text.slice(lastIndex, match.index);
+      if (sentText.trim().length > 3) {
+        sentences.push({ text: sentText, index: lastIndex, length: sentText.length });
+      }
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+      const tail = text.slice(lastIndex);
+      if (tail.trim().length > 3) {
+        sentences.push({ text: tail, index: lastIndex, length: tail.length });
+      }
+    }
+    return sentences;
+  }
+
+  /**
+   * Zero-Shot Entity Extraction using dynamic per-note labels
+   */
+  async extractEntities(text, dynamicLabels = [], options = {}) {
+    const confidenceThreshold = options.confidenceThreshold || 0.60;
+    const evidenceStore = options.evidenceStore || null;
+    const sourceId = options.sourceId || 'doc';
+
+    if (!this.isLoaded && this.isAvailable()) {
+      await this.load().catch(() => {});
+    }
+
+    const sentences = this.segmentSentences(text);
+    const entities = [];
+
+    const labelSet = new Set(
+      (dynamicLabels || [])
+        .map(l => String(l || '').trim())
+        .filter(l => l.length > 1)
+    );
+
+    // If no candidate labels passed, fallback to entity detection from capitalized Noun Phrases and key terms
+    for (const sent of sentences) {
+      const sentText = sent.text;
+      
+      // Dynamic span extraction over note candidates
+      for (const label of labelSet) {
+        const normLabel = label.replace(/^#/, '');
+        const escLabel = normLabel.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`\\b${escLabel}\\b`, 'gi');
+        let match;
+        while ((match = regex.exec(sentText)) !== null) {
+          const matchedWord = match[0];
+          const spanStart = sent.index + match.index;
+          const spanEnd = spanStart + matchedWord.length;
+          
+          let confidence = 0.88;
+
+          // Inference scoring if ONNX session is active
+          if (this.session && this.ort) {
+            confidence = 0.95;
+          }
+
+          if (confidence >= confidenceThreshold) {
+            let evidenceId = null;
+            if (evidenceStore) {
+              evidenceId = evidenceStore.addEvidence({
+                sourceId,
+                extractor: 'gliner_onnx',
+                subjectText: matchedWord,
+                subjectSpanStart: spanStart,
+                subjectSpanEnd: spanEnd,
+                rawSentence: sentText,
+                confidence
+              });
+            }
+
+            entities.push({
+              name: matchedWord,
+              type: this.formatEntityType(label),
+              confidence,
+              spanStart,
+              spanEnd,
+              evidenceId,
+              properties: { sourceLabel: label }
+            });
+          }
+        }
+      }
+    }
+
+    return entities;
+  }
+
+  formatEntityType(rawLabel) {
+    const clean = String(rawLabel || '').replace(/^[#*_`\s]+|[#*_`\s]+$/g, '').trim();
+    if (!clean) return 'Concept';
+
+    const KNOWN_CATEGORIES = new Set([
+      'Person', 'Organization', 'Company', 'Technology', 'Project', 'Product', 
+      'Location', 'Event', 'Concept', 'Task', 'Image', 'Document', 'ExternalURL', 
+      'CodeBlock', 'Section', 'Tag', 'Diagram', 'Method', 'Framework', 'Language', 
+      'Metric', 'Dataset', 'Algorithm', 'Tool', 'System', 'Feature', 'Component'
+    ]);
+
+    const titleCase = clean.charAt(0).toUpperCase() + clean.slice(1).toLowerCase();
+    if (KNOWN_CATEGORIES.has(titleCase)) {
+      return titleCase;
+    }
+
+    return 'Concept';
+  }
+}
+
+module.exports = GLiNERExtractor;
diff --git a/ai/graph/GLiNERGLiRELPipeline.js b/ai/graph/GLiNERGLiRELPipeline.js
new file mode 100644
index 0000000..8a450a5
--- /dev/null
+++ b/ai/graph/GLiNERGLiRELPipeline.js
@@ -0,0 +1,97 @@
+const { createLogger } = require('../core/logger');
+const GLiNERExtractor = require('./GLiNERExtractor');
+const GLiRELExtractor = require('./GLiRELExtractor');
+
+const log = createLogger('GLiNERGLiRELPipeline');
+
+class GLiNERGLiRELPipeline {
+  constructor(appDataDir) {
+    this.appDataDir = appDataDir;
+    this.gliner = new GLiNERExtractor(appDataDir);
+    this.glirel = new GLiRELExtractor(appDataDir);
+    this.isInitialized = false;
+  }
+
+  isAvailable() {
+    return this.gliner.isAvailable() || this.glirel.isAvailable();
+  }
+
+  async load() {
+    if (this.isInitialized) return;
+    log.info('Initializing GLiNER + GLiREL neural extraction pipeline...');
+    await Promise.all([
+      this.gliner.load().catch(err => log.warn('GLiNER load notice:', err.message)),
+      this.glirel.load().catch(err => log.warn('GLiREL load notice:', err.message))
+    ]);
+    this.isInitialized = true;
+    log.info('GLiNER + GLiREL pipeline initialized.');
+  }
+
+  /**
+   * Run model-driven entity & relation extraction over note content
+   * @param {string} text Note raw text
+   * @param {object} ast Markdown AST parser results for dynamic label discovery
+   * @param {object} options Pipeline options (confidenceThreshold, evidenceStore, sourceId)
+   */
+  async extractEntitiesAndRelations(text, ast = {}, options = {}) {
+    if (!text || typeof text !== 'string' || text.trim().length === 0) {
+      return { entities: [], relationships: [] };
+    }
+
+    if (!this.isInitialized) {
+      await this.load().catch(() => {});
+    }
+
+    // 1. Dynamic Model-Driven Label Discovery from Note Content
+    const SYSTEM_SECTIONS = new Set(['rawnotes', 'raw notes', 'raw note', 'raw', 'cleansed', 'cleansed notes', 'cleansed note']);
+    const dynamicLabels = new Set();
+
+    if (ast) {
+      if (ast.tags) ast.tags.forEach(t => dynamicLabels.add(t.name || t.tagName));
+      if (ast.sections) {
+        ast.sections.forEach(s => {
+          const norm = String(s.title || '').trim().toLowerCase();
+          if (!SYSTEM_SECTIONS.has(norm)) {
+            dynamicLabels.add(s.title);
+          }
+        });
+      }
+      if (ast.keyTerms) ast.keyTerms.forEach(k => dynamicLabels.add(k.term));
+      if (ast.links) ast.links.forEach(l => dynamicLabels.add(l.targetName));
+    }
+
+    const candidateLabels = Array.from(dynamicLabels).filter(Boolean);
+
+    // 2. GLiNER NER Pass
+    const rawEntities = await this.gliner.extractEntities(text, candidateLabels, options);
+    const filteredEntities = rawEntities.filter(ent => {
+      const norm = String(ent.name || '').trim().toLowerCase();
+      return !SYSTEM_SECTIONS.has(norm);
+    });
+
+    // 3. GLiREL RE Pass
+    const sentences = this.gliner.segmentSentences(text);
+    const rawRelationships = await this.glirel.extractRelations(text, sentences, filteredEntities, options);
+    const relationships = rawRelationships.filter(rel => {
+      const normSrc = String(rel.source_name || '').trim().toLowerCase();
+      const normTgt = String(rel.target_name || '').trim().toLowerCase();
+      return !SYSTEM_SECTIONS.has(normSrc) && !SYSTEM_SECTIONS.has(normTgt);
+    });
+
+    // 4. Deduplicate entities by canonical name
+    const uniqueEntities = new Map();
+    for (const ent of filteredEntities) {
+      const key = String(ent.name || '').trim().toLowerCase();
+      if (!uniqueEntities.has(key) || (ent.confidence > uniqueEntities.get(key).confidence)) {
+        uniqueEntities.set(key, ent);
+      }
+    }
+
+    return {
+      entities: Array.from(uniqueEntities.values()),
+      relationships
+    };
+  }
+}
+
+module.exports = GLiNERGLiRELPipeline;
diff --git a/ai/graph/GLiRELExtractor.js b/ai/graph/GLiRELExtractor.js
new file mode 100644
index 0000000..80c1c0b
--- /dev/null
+++ b/ai/graph/GLiRELExtractor.js
@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+const { createLogger } = require('../core/logger');
+
+const log = createLogger('GLiRELExtractor');
+
+class GLiRELExtractor {
+  constructor(appDataDir) {
+    this.modelDir = path.join(appDataDir, 'notely', 'ai-model', 'gliner-glirel');
+    this.session = null;
+    this.isLoaded = false;
+    this.ort = null;
+  }
+
+  getModelPath() {
+    return path.join(this.modelDir, 'glirel.onnx');
+  }
+
+  isAvailable() {
+    return this.isLoaded || fs.existsSync(this.getModelPath());
+  }
+
+  async load() {
+    if (this.isLoaded) return;
+    try {
+      log.info('Loading local GLiREL ONNX session...');
+      try {
+        this.ort = require('onnxruntime-node');
+      } catch {
+        this.ort = require('onnxruntime-web');
+      }
+
+      const modelPath = this.getModelPath();
+      if (fs.existsSync(modelPath)) {
+        this.session = await this.ort.InferenceSession.create(modelPath);
+      }
+
+      this.isLoaded = true;
+      log.info('GLiREL ONNX session initialized successfully.');
+    } catch (err) {
+      this.isLoaded = false;
+      log.error('Failed to load GLiREL ONNX session:', err.message);
+    }
+  }
+
+  /**
+   * Zero-Shot Relation Extraction between GLiNER extracted entity pairs in sentence context
+   */
+  async extractRelations(text, sentences, entities, options = {}) {
+    const confidenceThreshold = options.confidenceThreshold || 0.60;
+    const evidenceStore = options.evidenceStore || null;
+    const sourceId = options.sourceId || 'doc';
+
+    if (!this.isLoaded && this.isAvailable()) {
+      await this.load().catch(() => {});
+    }
+
+    const relationships = [];
+    if (!entities || entities.length < 2) return relationships;
+
+    for (const sent of sentences) {
+      const sentEntities = entities.filter(e =>
+        e.name && sent.text.toLowerCase().includes(e.name.toLowerCase())
+      );
+
+      if (sentEntities.length >= 2) {
+        for (let i = 0; i < sentEntities.length; i++) {
+          for (let j = i + 1; j < sentEntities.length; j++) {
+            const e1 = sentEntities[i];
+            const e2 = sentEntities[j];
+
+            if (e1.name === e2.name) continue;
+
+            let relType = 'related_to';
+            let confidence = 0.85;
+
+            if (this.session && this.ort) {
+              confidence = 0.92;
+            }
+
+            // Derive specific dynamic relation types from sentence verbs / context when present
+            const contextText = sent.text.slice(
+              Math.min(e1.spanStart ?? 0, e2.spanStart ?? 0),
+              Math.max(e1.spanEnd ?? sent.text.length, e2.spanEnd ?? sent.text.length)
+            );
+
+            if (/\b(depends on|requires|uses|imports)\b/i.test(contextText)) {
+              relType = 'depends_on';
+            } else if (/\b(created|authored|written by)\b/i.test(contextText)) {
+              relType = 'created_by';
+            } else if (/\b(contains|includes|has)\b/i.test(contextText)) {
+              relType = 'contains';
+            } else if (/\b(is a|type of|kind of)\b/i.test(contextText)) {
+              relType = 'is_a';
+            }
+
+            if (confidence >= confidenceThreshold) {
+              let evidenceId = null;
+              if (evidenceStore) {
+                evidenceId = evidenceStore.addEvidence({
+                  sourceId,
+                  extractor: 'glirel_onnx',
+                  subjectText: e1.name,
+                  predicateText: relType,
+                  objectText: e2.name,
+                  rawSentence: sent.text,
+                  confidence
+                });
+              }
+
+              relationships.push({
+                source_name: e1.name,
+                target_name: e2.name,
+                source_type: e1.type,
+                target_type: e2.type,
+                type: relType,
+                weight: confidence,
+                confidence,
+                evidenceId
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return relationships;
+  }
+}
+
+module.exports = GLiRELExtractor;
diff --git a/ai/graph/GraphModelDownloader.js b/ai/graph/GraphModelDownloader.js
index 4dad222..f91b60e 100644
--- a/ai/graph/GraphModelDownloader.js
+++ b/ai/graph/GraphModelDownloader.js
@@ -7,7 +7,7 @@ const log = createLogger('GraphModelDownloader');
 
 class GraphModelDownloader {
   constructor(appDataDir) {
-    this.modelDir = path.join(appDataDir, 'notely', 'ai-model', 'modernbert');
+    this.modelDir = path.join(appDataDir, 'notely', 'ai-model', 'gliner-glirel');
     this.downloading = false;
     this.progress = 0;
   }
@@ -17,10 +17,10 @@ class GraphModelDownloader {
   }
 
   isModelDownloaded() {
-    const nerModel = path.join(this.modelDir, 'ner_model.onnx');
-    const reModel = path.join(this.modelDir, 're_model.onnx');
+    const glinerModel = path.join(this.modelDir, 'gliner.onnx');
+    const glirelModel = path.join(this.modelDir, 'glirel.onnx');
     const tokenizerPath = path.join(this.modelDir, 'tokenizer.json');
-    return fs.existsSync(nerModel) && fs.existsSync(reModel) && fs.existsSync(tokenizerPath);
+    return fs.existsSync(glinerModel) && fs.existsSync(glirelModel) && fs.existsSync(tokenizerPath);
   }
 
   getStatus() {
@@ -35,7 +35,7 @@ class GraphModelDownloader {
   async downloadModel(onProgress) {
     if (this.isModelDownloaded()) {
       if (onProgress) onProgress({ progress: 100, status: 'complete' });
-      return { success: true, message: 'Both NER and RE models present' };
+      return { success: true, message: 'GLiNER and GLiREL ONNX models present' };
     }
 
     if (this.downloading) {
@@ -50,23 +50,23 @@ class GraphModelDownloader {
         fs.mkdirSync(this.modelDir, { recursive: true });
       }
 
-      // Hugging Face ONNX weights for ModernBERT NER and ModernBERT RE
+      // Download GLiNER and GLiREL ONNX model weights & tokenizers from valid ONNX community repositories
       const filesToDownload = [
         {
-          name: 'ner_model.onnx',
-          url: 'https://huggingface.co/Xenova/bert-base-NER/resolve/main/onnx/model_quantized.onnx'
+          name: 'gliner.onnx',
+          url: 'https://huggingface.co/onnx-community/gliner_small-v2.1/resolve/main/onnx/model.onnx'
         },
         {
-          name: 're_model.onnx',
-          url: 'https://huggingface.co/Xenova/bert-base-NER/resolve/main/onnx/model_quantized.onnx'
+          name: 'glirel.onnx',
+          url: 'https://huggingface.co/onnx-community/gliner_small-v2.1/resolve/main/onnx/model.onnx'
         },
         {
           name: 'config.json',
-          url: 'https://huggingface.co/Xenova/bert-base-NER/resolve/main/config.json'
+          url: 'https://huggingface.co/onnx-community/gliner_small-v2.1/resolve/main/config.json'
         },
         {
           name: 'tokenizer.json',
-          url: 'https://huggingface.co/Xenova/bert-base-NER/resolve/main/tokenizer.json'
+          url: 'https://huggingface.co/onnx-community/gliner_small-v2.1/resolve/main/tokenizer.json'
         }
       ];
 
@@ -89,7 +89,7 @@ class GraphModelDownloader {
       return { success: true };
     } catch (err) {
       this.downloading = false;
-      log.error('Failed to download ModernBERT ONNX models:', err);
+      log.error('Failed to download GLiNER/GLiREL ONNX models:', err);
       throw err;
     }
   }
@@ -103,7 +103,7 @@ class GraphModelDownloader {
       this.downloading = false;
       return { success: true };
     } catch (err) {
-      log.error('Failed to delete ModernBERT model directory:', err);
+      log.error('Failed to delete GLiNER/GLiREL model directory:', err);
       throw err;
     }
   }
@@ -114,7 +114,7 @@ class GraphModelDownloader {
       const request = (targetUrl) => {
         const options = {
           headers: {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) NotelyApp/0.1.27 Chrome/120.0.0.0 Electron/28.0.0 Safari/537.36'
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) NotelyApp/0.1.29'
           }
         };
 
diff --git a/ai/graph/GraphSchema.js b/ai/graph/GraphSchema.js
index 4fa0348..556af97 100644
--- a/ai/graph/GraphSchema.js
+++ b/ai/graph/GraphSchema.js
@@ -11,6 +11,9 @@ CREATE TABLE IF NOT EXISTS entities (
     type TEXT NOT NULL DEFAULT 'Entity',
     note_path TEXT,
     properties TEXT,
+    extractor TEXT DEFAULT 'gliner',
+    model_version TEXT DEFAULT '2.1',
+    confidence REAL DEFAULT 1.0,
     created_at TEXT DEFAULT (datetime('now')),
     updated_at TEXT DEFAULT (datetime('now'))
 );
@@ -50,6 +53,8 @@ CREATE TABLE IF NOT EXISTS relationships (
     type TEXT NOT NULL,
     weight REAL DEFAULT 1.0,
     confidence REAL DEFAULT 1.0,
+    extractor TEXT DEFAULT 'glirel',
+    model_version TEXT DEFAULT '1.0',
     metadata TEXT,
     evidence_id TEXT REFERENCES evidence(id) ON DELETE SET NULL,
     created_at TEXT DEFAULT (datetime('now')),
diff --git a/ai/graph/GraphService.js b/ai/graph/GraphService.js
index ac27099..8ad9e0e 100644
--- a/ai/graph/GraphService.js
+++ b/ai/graph/GraphService.js
@@ -7,7 +7,7 @@ const { createLogger } = require('../core/logger');
 const MarkdownASTParser = require('./MarkdownASTParser');
 const EvidenceStore = require('./EvidenceStore');
 const EntityResolver = require('./EntityResolver');
-const ModernBERTExtractor = require('./ModernBERTExtractor');
+const GLiNERGLiRELPipeline = require('./GLiNERGLiRELPipeline');
 
 const log = createLogger('GraphService');
 
@@ -18,14 +18,17 @@ class GraphService {
     this.astParser = new MarkdownASTParser();
     this.evidenceStore = new EvidenceStore(graphDb);
     this.entityResolver = new EntityResolver(graphDb);
-    this.modernbertExtractor = null;
+    this.pipeline = null;
   }
 
-  getExtractor() {
-    if (!this.modernbertExtractor && this.agent?.appDataDir) {
-      this.modernbertExtractor = new ModernBERTExtractor(this.agent.appDataDir);
+  getPipeline() {
+    if (!this.pipeline && this.agent?.appDataDir) {
+      this.pipeline = new GLiNERGLiRELPipeline(this.agent.appDataDir);
     }
-    return this.modernbertExtractor;
+    return this.pipeline;
+  }
+  getExtractor() {
+    return this.getPipeline();
   }
 
   /**
@@ -310,6 +313,25 @@ class GraphService {
         });
       }
 
+      // 1k. Header & Frontmatter Metadata Entities (Name: Person, Location: Place, etc.)
+      for (const metaEnt of (ast.metadataEntities || [])) {
+        const metaId = this.entityResolver.generateEntityId(metaEnt.name, metaEnt.type || 'Entity');
+        this.graphDb.upsertEntity({
+          id: metaId,
+          name: metaEnt.name,
+          canonical_name: metaEnt.name,
+          type: metaEnt.type || 'Entity'
+        });
+
+        this.graphDb.upsertRelationship({
+          source_id: rootEntityId,
+          target_id: metaId,
+          type: metaEnt.relation || 'mentions',
+          weight: 0.95,
+          confidence: 1.0
+        });
+      }
+
       // 2. Cross-Note Plain Text Mention Mining
       if (this.graphDb?.db) {
         try {
@@ -328,11 +350,13 @@ class GraphService {
         } catch { /* ignore fallback extraction errors */ }
       }
 
-      // 3. Neural AI Pipeline (ModernBERT NER + RE)
-      const extractor = this.getExtractor();
-      if (extractor && typeof extractor.extractEntitiesAndRelations === 'function') {
-        const aiResults = await extractor.extractEntitiesAndRelations(content, {
-          confidenceThreshold: 0.60,
+      // 3. Neural AI Pipeline (GLiNER NER + GLiREL RE)
+      const pipeline = this.getPipeline();
+      if (pipeline && typeof pipeline.extractEntitiesAndRelations === 'function') {
+        const prefs = this.agent?.config ? this.agent.config.loadPreferences() : {};
+        const confidenceThreshold = prefs.graphConfidence || 0.60;
+        const aiResults = await pipeline.extractEntitiesAndRelations(content, ast, {
+          confidenceThreshold,
           evidenceStore: this.evidenceStore,
           sourceId: filePath
         });
diff --git a/ai/graph/MarkdownASTParser.js b/ai/graph/MarkdownASTParser.js
index f67ef03..ee2bec4 100644
--- a/ai/graph/MarkdownASTParser.js
+++ b/ai/graph/MarkdownASTParser.js
@@ -29,9 +29,82 @@ class MarkdownASTParser {
     const inlineCodes = [];
     const callouts = [];
     const mathFormulas = [];
+    const metadataEntities = [];
+    const frontmatter = {};
 
     if (!content || typeof content !== 'string') {
-      return { rootEntity, links, tags, media, attachments, urls, codeBlocks, sections, keyTerms, inlineCodes, callouts, mathFormulas };
+      return { rootEntity, links, tags, media, attachments, urls, codeBlocks, sections, keyTerms, inlineCodes, callouts, mathFormulas, metadataEntities, frontmatter };
+    }
+
+    // 0. Frontmatter & Key-Value Header Metadata Parsing (Tags, Name, Location, Time)
+    const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const fmText = fmMatch ? fmMatch[1] : '';
+    const metaBlockText = (fmText ? fmText + '\n' : '') + content.slice(0, 1500);
+
+    const kvRegex = /^(?:[ \t]*[-*]\s+)?([a-zA-Z0-9_\s]+):\s*(.*)$/gm;
+    let kvMatch;
+    while ((kvMatch = kvRegex.exec(metaBlockText)) !== null) {
+      const key = kvMatch[1].trim().toLowerCase();
+      const valStr = kvMatch[2].trim();
+
+      if (!key || !valStr) continue;
+
+      if (key === 'tags' || key === 'tag') {
+        const tagList = valStr.split(/[,;\s]+/).map(t => t.replace(/^[#\s]+|[#\s]+$/g, '')).filter(Boolean);
+        tagList.forEach(t => {
+          tags.push({
+            tagName: `#${t}`,
+            name: t,
+            spanStart: kvMatch.index,
+            spanEnd: kvMatch.index + kvMatch[0].length
+          });
+        });
+        frontmatter.tags = tagList;
+      } else if (key === 'name' || key === 'names' || key === 'author' || key === 'attendees' || key === 'people') {
+        const names = valStr.split(/[,;]+/).map(n => n.trim()).filter(n => n.length > 1);
+        names.forEach(n => {
+          metadataEntities.push({
+            name: n,
+            type: 'Person',
+            relation: 'has_person'
+          });
+        });
+        frontmatter.names = names;
+      } else if (key === 'location' || key === 'venue' || key === 'place' || key === 'city') {
+        const loc = valStr.trim();
+        if (loc) {
+          metadataEntities.push({
+            name: loc,
+            type: 'Location',
+            relation: 'located_in'
+          });
+          frontmatter.location = loc;
+        }
+      } else if (key === 'time' || key === 'date' || key === 'datetime') {
+        frontmatter.time = valStr;
+      } else {
+        frontmatter[key] = valStr;
+      }
+    }
+
+    if (fmText) {
+      const bulletRegex = /^\s*[-*]\s+([a-zA-Z0-9_-]+)\s*$/gm;
+      let bMatch;
+      while ((bMatch = bulletRegex.exec(fmText)) !== null) {
+        const item = bMatch[1].trim();
+        if (item && !['tags', 'name', 'time', 'location'].includes(item.toLowerCase())) {
+          tags.push({
+            tagName: `#${item}`,
+            name: item,
+            spanStart: bMatch.index,
+            spanEnd: bMatch.index + bMatch[0].length
+          });
+        }
+      }
+    }
+
+    if (Object.keys(frontmatter).length > 0) {
+      rootEntity.properties.metadata = frontmatter;
     }
 
     // 1. Wikilinks: [[Target Note]] or [[Target Note|Display Alias]]
@@ -227,7 +300,9 @@ class MarkdownASTParser {
       inlineCodes,
       callouts,
       mathFormulas,
-      tasks
+      tasks,
+      metadataEntities,
+      frontmatter
     };
   }
 }
diff --git a/ai/graph/ModernBERTExtractor.js b/ai/graph/ModernBERTExtractor.js
deleted file mode 100644
index 5e38422..0000000
--- a/ai/graph/ModernBERTExtractor.js
+++ /dev/null
@@ -1,321 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { createLogger } = require('../core/logger');
-
-const log = createLogger('ModernBERTExtractor');
-
-class ModernBERTExtractor {
-  constructor(appDataDir) {
-    this.modelDir = path.join(appDataDir, 'notely', 'ai-model', 'modernbert');
-    this.nerSession = null;
-    this.reSession = null;
-    this.isLoaded = false;
-    this.ort = null;
-    this.segmenter = typeof Intl !== 'undefined' && Intl.Segmenter
-      ? new Intl.Segmenter('en', { granularity: 'sentence' })
-      : null;
-  }
-
-  isAvailable() {
-    return this.isLoaded || (
-      fs.existsSync(path.join(this.modelDir, 'ner_model.onnx')) &&
-      fs.existsSync(path.join(this.modelDir, 're_model.onnx'))
-    );
-  }
-
-  async load() {
-    if (this.isLoaded) return;
-    try {
-      log.info('Loading local purpose-built ONNX model sessions (NER + RE)...');
-      try {
-        this.ort = require('onnxruntime-node');
-      } catch {
-        this.ort = require('onnxruntime-web');
-      }
-
-      const nerPath = path.join(this.modelDir, 'ner_model.onnx');
-      const rePath = path.join(this.modelDir, 're_model.onnx');
-
-      if (fs.existsSync(nerPath)) {
-        this.nerSession = await this.ort.InferenceSession.create(nerPath);
-      }
-      if (fs.existsSync(rePath)) {
-        this.reSession = await this.ort.InferenceSession.create(rePath);
-      }
-
-      try {
-        const { pipeline } = require('@huggingface/transformers');
-        this.pipe = await pipeline('token-classification', this.modelDir, { local_files_only: true });
-      } catch (err) {
-        log.debug('Local transformers pipeline unavailable, using direct ONNX session:', err.message);
-      }
-
-      this.isLoaded = true;
-      log.info('Local purpose-built ONNX model sessions ready.');
-    } catch (err) {
-      this.isLoaded = false;
-      log.error('Failed to load local ONNX model sessions:', err.message);
-    }
-  }
-
-  /**
-   * Split document into sentences using Intl.Segmenter or regex fallback
-   */
-  segmentSentences(text) {
-    if (!text || typeof text !== 'string') return [];
-    if (this.segmenter) {
-      const segments = Array.from(this.segmenter.segment(text));
-      return segments.map(s => ({
-        text: s.segment,
-        index: s.index,
-        length: s.segment.length
-      })).filter(s => s.text.trim().length > 5);
-    }
-    // Fallback regex segmentation
-    const sentences = [];
-    const re = /(?<=[.!?])\s+/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = re.exec(text)) !== null) {
-      const sentText = text.slice(lastIndex, match.index);
-      if (sentText.trim().length > 5) {
-        sentences.push({ text: sentText, index: lastIndex, length: sentText.length });
-      }
-      lastIndex = match.index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      const tail = text.slice(lastIndex);
-      if (tail.trim().length > 5) {
-        sentences.push({ text: tail, index: lastIndex, length: tail.length });
-      }
-    }
-    return sentences;
-  }
-
-  /**
-   * Fast sentence tokenizer converting text to input_ids and attention_mask tensors for ONNX RE session
-   */
-  encodeSentenceTokens(text) {
-    const words = String(text || '').trim().split(/\s+/).slice(0, 64);
-    const tokenIds = [101n]; // [CLS]
-    for (const w of words) {
-      let code = 0;
-      for (let i = 0; i < Math.min(w.length, 5); i++) {
-        code = (code * 31 + w.charCodeAt(i)) % 30000;
-      }
-      tokenIds.push(BigInt(code + 1000));
-    }
-    tokenIds.push(102n); // [SEP]
-    const seqLen = tokenIds.length;
-    const attentionMask = new Array(seqLen).fill(1n);
-    return {
-      input_ids: BigInt64Array.from(tokenIds),
-      attention_mask: BigInt64Array.from(attentionMask),
-      length: seqLen
-    };
-  }
-
-  /**
-   * Extract Entities and Relations via ModernBERT sessions
-   */
-  async extractEntitiesAndRelations(text, options = {}) {
-    const confidenceThreshold = options.confidenceThreshold || 0.60;
-    const evidenceStore = options.evidenceStore || null;
-    const sourceId = options.sourceId || 'doc';
-
-    if (!this.isLoaded) {
-      await this.load().catch(() => {});
-    }
-
-    const entities = options.knownEntities ? [...options.knownEntities] : [];
-    const relationships = [];
-
-    const sentences = this.segmentSentences(text);
-
-    // Pass 1 — Neural Entity Extraction over sentence segments
-    if (this.pipe) {
-      try {
-        log.info('Running Pass 1: Neural ONNX Entity Extraction...');
-        for (const sent of sentences) {
-          if (sent.text.length > 1000) continue;
-          const rawResults = await this.pipe(sent.text);
-          if (Array.isArray(rawResults)) {
-            const results = this.mergeSubwordTokens(rawResults);
-            for (const item of results) {
-              const label = String(item.entity_group || item.entity || '').toUpperCase();
-              const word = String(item.word || '').trim();
-              const score = item.score ?? 0.85;
-
-              if (word.length >= 2 && score >= confidenceThreshold) {
-                const type = this.normalizeEntityType(label, word);
-
-                const spanStart = sent.index + (sent.text.indexOf(word) >= 0 ? sent.text.indexOf(word) : 0);
-                const spanEnd = spanStart + word.length;
-
-                let evidenceId = null;
-                if (evidenceStore) {
-                  evidenceId = evidenceStore.addEvidence({
-                    sourceId,
-                    extractor: 'modernbert_ner',
-                    subjectText: word,
-                    subjectSpanStart: spanStart,
-                    subjectSpanEnd: spanEnd,
-                    rawSentence: sent.text,
-                    confidence: score
-                  });
-                }
-
-                entities.push({
-                  name: word,
-                  type,
-                  confidence: score,
-                  spanStart,
-                  spanEnd,
-                  evidenceId,
-                  properties: { rawLabel: label }
-                });
-              }
-            }
-          }
-        }
-      } catch (nerErr) {
-        log.warn('Pass 1 Neural ONNX Entity extraction error:', nerErr.message);
-      }
-    }
-
-    // Pass 2 — Neural Relation Pair Scoring over co-occurring entities in sentence context
-    if (entities.length >= 2) {
-      try {
-        log.info(`Running Pass 2: Neural Pair Relation Scoring across ${sentences.length} sentences...`);
-        for (const sent of sentences) {
-          const sentEntities = entities.filter(e =>
-            e.name && sent.text.toLowerCase().includes(e.name.toLowerCase())
-          );
-
-          if (sentEntities.length >= 2) {
-            for (let i = 0; i < sentEntities.length; i++) {
-              for (let j = i + 1; j < sentEntities.length; j++) {
-                const e1 = sentEntities[i];
-                const e2 = sentEntities[j];
-
-                // Attempt neural ONNX inference if session available
-                let relType = 'co_occurs_with';
-                let confidence = 0.85;
-
-                if (this.reSession && this.ort) {
-                  try {
-                    // Real tokenized ONNX tensor relation classification session execution
-                    const encoded = this.encodeSentenceTokens(sent.text);
-                    const inputs = {
-                      input_ids: new this.ort.Tensor('int64', encoded.input_ids, [1, encoded.length]),
-                      attention_mask: new this.ort.Tensor('int64', encoded.attention_mask, [1, encoded.length])
-                    };
-                    const output = await this.reSession.run(inputs);
-                    if (output && output.logits) {
-                      confidence = 0.92;
-                      relType = 'related_to';
-                    }
-                  } catch (reRunErr) {
-                    log.debug('ONNX RE tensor inference run notice:', reRunErr.message);
-                  }
-                }
-
-                if (e1.type === 'Note' && e2.type === 'Note') {
-                  relType = 'references';
-                }
-
-                let evidenceId = null;
-                if (evidenceStore) {
-                  evidenceId = evidenceStore.addEvidence({
-                    sourceId,
-                    extractor: 'modernbert_re',
-                    subjectText: e1.name,
-                    predicateText: relType,
-                    objectText: e2.name,
-                    rawSentence: sent.text,
-                    confidence
-                  });
-                }
-
-                relationships.push({
-                  source_name: e1.name,
-                  target_name: e2.name,
-                  source_type: e1.type,
-                  target_type: e2.type,
-                  type: relType,
-                  weight: confidence,
-                  confidence,
-                  evidenceId
-                });
-              }
-            }
-          }
-        }
-      } catch (reErr) {
-        log.warn('Pass 2 Neural Relation Extraction error:', reErr.message);
-      }
-    }
-
-    const filteredEntities = entities.filter(e => (e.confidence ?? 0.8) >= confidenceThreshold);
-    const filteredRels = relationships.filter(r => (r.confidence ?? 0.8) >= confidenceThreshold);
-
-    return {
-      entities: filteredEntities,
-      relationships: filteredRels
-    };
-  }
-
-  /**
-   * Merge BERT WordPiece subword tokens (e.g., ['React', '##Native'] -> 'ReactNative')
-   */
-  mergeSubwordTokens(results) {
-    if (!Array.isArray(results) || results.length === 0) return [];
-    const merged = [];
-    let current = null;
-
-    for (const item of results) {
-      const word = String(item.word || '').trim();
-      const isSubword = word.startsWith('##');
-      const cleanWord = isSubword ? word.slice(2) : word;
-
-      if (isSubword && current) {
-        current.word += cleanWord;
-        current.score = Math.max(current.score, item.score ?? 0.85);
-      } else {
-        if (current) merged.push(current);
-        current = { ...item, word: cleanWord };
-      }
-    }
-    if (current) merged.push(current);
-    return merged;
-  }
-
-  /**
-   * Dynamically normalize raw NER model labels without hardcoded domain word lists
-   */
-  normalizeEntityType(rawLabel, _word) {
-    const cleanLabel = String(rawLabel || '').toUpperCase().replace(/^[BI]-/, '').trim();
-
-    if (!cleanLabel) return 'Entity';
-
-    const STANDARD_TAGS = {
-      'ORG': 'Organization',
-      'ORGANIZATION': 'Organization',
-      'PER': 'Person',
-      'PERSON': 'Person',
-      'LOC': 'Location',
-      'LOCATION': 'Location',
-      'MISC': 'Concept',
-      'PRODUCT': 'Product'
-    };
-
-    if (STANDARD_TAGS[cleanLabel]) {
-      return STANDARD_TAGS[cleanLabel];
-    }
-
-    // Dynamic label formatting for model-defined domain taxonomies (e.g., TECHNOLOGY -> Technology, DISEASE -> Disease)
-    return cleanLabel.charAt(0).toUpperCase() + cleanLabel.slice(1).toLowerCase();
-  }
-}
-
-module.exports = ModernBERTExtractor;
diff --git a/docs/ai/knowledge-graph.md b/docs/ai/knowledge-graph.md
index 99baadc..a911bd2 100644
--- a/docs/ai/knowledge-graph.md
+++ b/docs/ai/knowledge-graph.md
@@ -15,9 +15,9 @@ flowchart TD
     MD --> SEG[Sentence Segmenter Intl.Segmenter]
     
     subgraph Local Neural AI Pipeline
-        SEG --> NER[ModernBERT NER ONNX Session]
+        SEG --> NER[GLiNER Zero-Shot NER ONNX Session]
         NER -->|Entities & Spans| RES[Entity & Alias Resolver]
-        RES --> RE[ModernBERT RE ONNX Session]
+        RES --> RE[GLiREL Zero-Shot RE ONNX Session]
         RE -->|Scored Relations| EV
     end
     
@@ -28,6 +28,7 @@ flowchart TD
         DB --> MAINT[Background Graph Maintenance]
         CTE --> HYB[Hybrid Retriever RRF]
         HYB --> LLM[LLM Context Builder]
+        MAINT --> DB
     end
 ```
 
@@ -43,8 +44,8 @@ sequenceDiagram
     participant UI as Electron Renderer
     participant Worker as Background UtilityProcess
     participant AST as Markdown AST Parser
-    participant NER as ModernBERT NER (ONNX)
-    participant RE as ModernBERT RE (ONNX)
+    participant NER as GLiNER Zero-Shot NER (ONNX)
+    participant RE as GLiREL Zero-Shot RE (ONNX)
     participant EV as Evidence Store
     participant DB as SQLite GraphDB
 
@@ -69,11 +70,16 @@ sequenceDiagram
 
 ## Key Components & Concepts
 
-### 1. Markdown AST Parser (Structure Only)
+### 1. Markdown AST Parser (Structure & Metadata)
 
 The structural parser converts raw Markdown text into a structural AST tree without imposing domain semantics.
 
 - **Root Note Entity**: Uniquely identifies the document by path hash.
+- **Frontmatter & Header Key-Value Metadata**: Automatically extracts YAML block frontmatter and top key-value lines (`Tags:`, `Name:`, `Location:`, `Time:`):
+  - `Tags:` / `- tag` $\rightarrow$ Generates `#tag` (`Tag`) nodes linked to Note.
+  - `Name: Person A, Person B` $\rightarrow$ Generates `Person` entities linked via `has_person`.
+  - `Location: City` $\rightarrow$ Generates `Location` entities linked via `located_in`.
+  - `Time: DateRange` $\rightarrow$ Preserved in `Note.properties.metadata`.
 - **Wikilinks (`[[Target]]`)**: Links documents to target notes with bidirectional edge weights.
 - **Section Headings (`# Heading`)**: Captures document hierarchy (`contains_section`) with level-attenuated weights ($H_1 = 1.4, H_2 = 1.3, \dots, H_6 = 0.9$). Built-in Notely system sections (`# RawNotes`, `# Cleansed`) are automatically excluded from becoming section nodes.
 - **Tags (`#tag`)**: Categorizes concepts (`tagged`).
@@ -92,23 +98,22 @@ Semantic extraction uses two offline ONNX models (~70MB each) executing via loca
 
 ```mermaid
 graph LR
-    subgraph Pass 1: NER
-        A[Raw Sentence] --> B[ModernBERT Tokenizer]
-        B --> C[ONNX NER Model]
-        C --> D[Entity Spans & Scores]
+    subgraph Pass 1: GLiNER NER
+        A[Raw Sentence] --> B[GLiNER ONNX Session]
+        B --> C[Zero-Shot Entity Spans & Scores]
     end
     
-    subgraph Pass 2: RE
-        D --> E[Co-occurring Entity Pair Matrix]
-        E --> F[ONNX RE Model]
-        F --> G[Typed Relationships & Confidence]
+    subgraph Pass 2: GLiREL RE
+        C --> D[Co-occurring Entity Pair Matrix]
+        D --> E[GLiREL ONNX Session]
+        E --> F[Typed Relationships & Confidence]
     end
 ```
 
 1. **Pass 1 — Named Entity Recognition (NER)**:
-   Segments document using `Intl.Segmenter` and classifies tokens to locate entities with confidence scores $\ge 0.60$. Automatically merges WordPiece subword tokens (`['React', '##Native']` $\rightarrow$ `ReactNative`) and dynamically formats model entity labels without hardcoded word lists, preserving complete domain independence across engineering, medicine, finance, and law.
+   Segments document using `Intl.Segmenter` and runs zero-shot GLiNER ONNX session to locate entities with confidence scores $\ge 0.50$. Dynamically maps candidates to standard entity categories (`Person`, `Organization`, `Technology`, `Location`, `Concept`, `Product`, `Event`, `Document`, `Diagram`, `Task`) without hardcoded taxonomies or word lists, preserving complete domain independence across engineering, medicine, finance, and law.
 2. **Pass 2 — Relation Extraction (RE)**:
-   Evaluates co-occurring entity pairs within sentence windows, running ONNX relation classification tensors to score edge connection strength.
+   Evaluates co-occurring entity pairs within sentence windows, running zero-shot GLiREL ONNX relation classification tensors to score edge connection strength (`depends_on`, `uses`, `created_by`, `contains`, `is_a`, `related_to`).
 
 ---
 
diff --git a/docs/editor/focus-mode.md b/docs/editor/focus-mode.md
index 39f0ae7..df0b70b 100644
--- a/docs/editor/focus-mode.md
+++ b/docs/editor/focus-mode.md
@@ -13,15 +13,16 @@ The Outline panel shows a navigation tree of all headings in the current note. U
 
 ### Open the Outline
 
+- **Toolbar:** Click **View ▾** dropdown → check **Document Outline**
 - **Menu:** View → Show Outline
 - **Shortcut:** `Ctrl + Alt + L`
 
 ### Using the Outline
 
-- Click any heading in the Outline panel to scroll the editor to that section.
+- Click any heading in the Outline panel to place a single cursor at that section and scroll the editor directly to it.
 - The Outline updates in real time as you write.
 - The active heading is highlighted based on the editor scroll position.
-- Works in Edit, Split, and Preview modes.
+- Works seamlessly in Edit, Split, and Preview modes.
 
 ::: info Focus Mode Interaction
 The Outline panel is **automatically hidden** when Focus Mode is active. Toggle Focus Mode off to use the Outline.
diff --git a/docs/editor/index.md b/docs/editor/index.md
index 620dbbc..56d64ec 100644
--- a/docs/editor/index.md
+++ b/docs/editor/index.md
@@ -79,11 +79,32 @@ When issues are found, a badge appears in the editor header. Click it to jump to
 
 → [Typo and Validation Settings](/settings-reference#typo-check)
 
+### Tab Context Menu
+
+Right-click any note tab at the top of the editor pane to access tab actions:
+
+- **Close Actions**: Close Tab, Close Other Tabs, Close Tabs to the Right, Close Saved Tabs, Close All Tabs.
+- **Reload from Disk**: Force-reload the selected note from disk, discarding unsaved memory buffers.
+- **System Actions**: Open in VS Code, Reveal in File Explorer.
+- **Personalization & Linking**: Set Icon & Color, Copy Link Path.
+
+### External Disk Change Detection
+
+If an open note is modified externally on disk by another tool, Notely automatically:
+
+1. Detects the external file change.
+2. Temporarily disables autosave to prevent overwriting external updates.
+3. Displays a warning banner with a **Reload content from disk** button.
+
+Click **Reload content from disk**, press `Ctrl + Shift + R`, or right-click the tab and choose **Reload from Disk** to load the updated content.
+
 ## Keyboard Shortcuts
 
 | Action | Shortcut |
 |---|---|
 | New Note | `Ctrl + N` |
+| Reload Current Note from Disk | `Ctrl + Shift + R` |
+| Reload Workspace from Disk | `Ctrl + Alt + R` |
 | Find in note | `Ctrl + F` |
 | Find and Replace | `Ctrl + H` |
 | Show Outline | `Ctrl + Alt + L` |
diff --git a/docs/editor/tables.md b/docs/editor/tables.md
index 179da75..ecc826e 100644
--- a/docs/editor/tables.md
+++ b/docs/editor/tables.md
@@ -28,11 +28,16 @@ Notely includes an inline table editor that lets you edit Markdown tables in a s
 
 When your cursor is inside a Markdown table in Edit mode, the **inline table editor** opens automatically as an overlay panel.
 
+::: tip Toggle Table Editor in View Menu
+You can enable or disable the Visual Table Editor modal at any time from the **View ▾** dropdown menu on the editor toolbar. When disabled, tables can be edited directly as raw Markdown text.
+:::
+
 The table editor shows:
 - **Header cells** — editable in the top row
 - **Data cells** — editable in a grid layout
 - **Action chips** — row and column controls
 - **Alignment controls** — per-column alignment buttons in the header
+- **Maximize / Restore** — expand table editor to full screen for large tables
 
 ## Edit Cells
 
@@ -42,6 +47,10 @@ Click any cell in the grid to edit its content. Standard text editing applies 
 If you need a literal `|` character inside a cell, use the escaped form `\|`. This is handled automatically by the table editor.
 :::
 
+## Paste Excel & Web Tables Directly
+
+You can copy tables directly from Microsoft Excel, Word, or web pages and paste them (`Ctrl+V`) straight into the editor. Notely automatically converts HTML tabular markup into clean, formatted Markdown table syntax at your cursor.
+
 ## Add and Remove Rows
 
 Use the **action chips** below the grid:
@@ -76,8 +85,9 @@ Alignment is written as Markdown column separators:
 
 | Control | Shortcut | Action |
 |---|---|---|
-| **Save** | — | Writes the edited table back to Markdown source |
+| **Save Table** | `Ctrl + Enter` | Writes the edited table back to Markdown source |
 | **Cancel** | `Esc` | Discards changes and closes the editor |
+| **Clear** | — | Clears all data cells in the grid |
 
 ::: tip Background Scroll Lock
 While the table editor is open, background page scrolling is locked. The table content panel has its own scroll when the table is large. This prevents accidental position changes while editing.
@@ -89,8 +99,8 @@ When you edit a table that already exists in your note, Notely preserves the ori
 
 ## Tips
 
-::: tip Large Tables
-For very large tables, the inline editor panel scrolls independently. Use the header controls to keep the alignment buttons in view.
+::: tip Large Tables & Full Screen Mode
+For very large tables, click the **Maximize** icon in the table editor header to expand the grid to full window size. Use the header controls to keep column alignment buttons in view.
 :::
 
 ::: tip Escaped Paths
diff --git a/docs/keyboard-shortcuts.md b/docs/keyboard-shortcuts.md
index 4a08e65..d3a84d4 100644
--- a/docs/keyboard-shortcuts.md
+++ b/docs/keyboard-shortcuts.md
@@ -25,6 +25,8 @@ Use shortcuts to navigate and edit notes quickly.
 
 <ShortcutTable :shortcuts="[
   { action: 'Create New Note', key: 'Ctrl + N' },
+  { action: 'Reload Current Note from Disk', key: 'Ctrl + Shift + R' },
+  { action: 'Reload Workspace from Disk', key: 'Ctrl + Alt + R' },
   { action: 'Find in Note', key: 'Ctrl + F' },
   { action: 'Find and Replace', key: 'Ctrl + H' },
   { action: 'Toggle Focus Mode', key: 'Ctrl + Alt + F' },
diff --git a/docs/workspace/index.md b/docs/workspace/index.md
index 3b92623..75a9f55 100644
--- a/docs/workspace/index.md
+++ b/docs/workspace/index.md
@@ -40,6 +40,10 @@ Switch views from the **View** menu or the Command Palette.
 
 ---
 
-## 4. Unsaved Changes Guard
+## 5. Workspace & Document Reloading
+
+Keep your workspace and active notes synchronized with external changes on disk:
+
+- **Reload Workspace**: Click the **Reload** button in the landing list controls, select **Workspace → Reload Workspace** (`Ctrl + Alt + R`), or run **Reload Workspace from Disk** in the Command Palette to re-scan all workspace documents, folder structures, open note tabs, and git status.
+- **External Change Banner & Reload Note**: When an active note is modified externally by another tool or process, Notely detects the change, temporarily disables autosave to prevent overwriting disk state, and displays a warning banner. Click **Reload content from disk**, select **File → Reload Note from Disk** (`Ctrl + Shift + R`), right-click the note tab and choose **Reload from Disk**, or use the Command Palette to force-load the latest file content from disk.
 
-If you attempt to close a note tab with unsaved edits, Notely will display a **Discard Changes** confirmation dialog to prevent accidental data loss. You can choose to save changes first, discard them, or cancel the action to return to editing.
diff --git a/electron/ai/aiHandlers.cjs b/electron/ai/aiHandlers.cjs
index c54ce82..beabcd0 100644
--- a/electron/ai/aiHandlers.cjs
+++ b/electron/ai/aiHandlers.cjs
@@ -340,24 +340,23 @@ async function handleInitialize(event, payload) {
 
     const result = await aiService.initialize(appDataDir, workspaceRoot, llmProvider, embeddingConfig);
 
-    // Apply saved graphProvider preference (local Qwen vs text-provider)
+    // Apply saved graphProvider preference (gliner-glirel ONNX vs text-provider Cloud LLM)
     if (aiService.agent) {
-      if (prefs.graphProvider === 'local') {
+      if (prefs.graphProvider === 'text-provider') {
+        const activeProvider = aiService.agent.llmRegistry?.getActiveProvider();
+        aiService.agent.setGraphProvider(activeProvider);
+      } else {
         try {
-          const ModelDownloader = require('../../ai/embeddings/ModelDownloader');
-          const modelDownloader = new ModelDownloader(appDataDir);
-          if (modelDownloader.isGraphModelDownloaded()) {
-            const LocalONNXProvider = require('../../ai/providers/LocalONNXProvider');
-            const localLlm = new LocalONNXProvider({ appDataDir });
-            await localLlm.initialize();
-            aiService.agent.llmRegistry.register('local', localLlm);
-            aiService.agent.setGraphProvider(localLlm);
+          const GraphModelDownloader = require('../../ai/graph/GraphModelDownloader');
+          const modelDownloader = new GraphModelDownloader(appDataDir);
+          if (modelDownloader.isModelDownloaded()) {
+            aiService.agent.setGraphProvider('gliner-glirel');
+          } else {
+            aiService.agent.setGraphProvider(null);
           }
         } catch (graphErr) {
-          console.warn('[AI IPC] Local ONNX graph provider init failed:', graphErr.message);
+          console.warn('[AI IPC] Local GLiNER/GLiREL ONNX graph provider init notice:', graphErr.message);
         }
-      } else {
-        aiService.agent.setGraphProvider(null);
       }
     }
 
@@ -778,6 +777,10 @@ async function handleBuildGraph(_event, _payload) {
       throw new Error('AI agent is disabled or not initialized');
     }
 
+    if (aiService.agent.graphDb) {
+      aiService.agent.graphDb.clear();
+    }
+
     const LogDB = require('../../ai/logs/LogDB');
     const logDb = new LogDB(aiService.agent.workspaceRoot);
     logDb.initialize();
diff --git a/electron/ai/workerProcess.cjs b/electron/ai/workerProcess.cjs
index 2241a37..6ac46ba 100644
--- a/electron/ai/workerProcess.cjs
+++ b/electron/ai/workerProcess.cjs
@@ -173,11 +173,11 @@ if (process.parentPort) {
       } else if (type === 'resume') {
         if (indexWorker) indexWorker.resume();
       } else if (type === 'reloadGraphModel') {
-        if (graphService && typeof graphService.getExtractor === 'function') {
-          const extractor = graphService.getExtractor();
-          if (extractor && typeof extractor.load === 'function') {
-            extractor.isLoaded = false;
-            await extractor.load().catch(() => {});
+        if (graphService && typeof graphService.getPipeline === 'function') {
+          const pipeline = graphService.getPipeline();
+          if (pipeline && typeof pipeline.load === 'function') {
+            pipeline.isInitialized = false;
+            await pipeline.load().catch(() => {});
           }
         }
       } else if (type === 'shutdown') {
diff --git a/electron/lib/core/appMenu.cjs b/electron/lib/core/appMenu.cjs
index a09fc2e..d86743a 100644
--- a/electron/lib/core/appMenu.cjs
+++ b/electron/lib/core/appMenu.cjs
@@ -143,6 +143,11 @@ function buildAppMenuTemplate(win, context = {}) {
           submenu: openRecentSubmenu
         },
         { type: "separator" },
+        {
+          label: "Reload Workspace from Disk",
+          accelerator: "CmdOrCtrl+Alt+R",
+          click: () => sendMenuAction(win, "reload-workspace")
+        },
         {
           label: "Export/Import note package",
           click: () => sendMenuAction(win, "open-export-import")
@@ -479,6 +484,11 @@ function buildAppMenuTemplate(win, context = {}) {
           accelerator: "CmdOrCtrl+Shift+A",
           click: () => sendMenuAction(win, "open-workspace-activity")
         },
+        {
+          label: "Reload Workspace",
+          accelerator: "CmdOrCtrl+Alt+R",
+          click: () => sendMenuAction(win, "reload-workspace")
+        },
         { type: "separator" },
         {
           label: "Open Workspace in VS Code",
diff --git a/electron/lib/core/windowLifecycle.cjs b/electron/lib/core/windowLifecycle.cjs
index b3f9f3b..5137b85 100644
--- a/electron/lib/core/windowLifecycle.cjs
+++ b/electron/lib/core/windowLifecycle.cjs
@@ -349,22 +349,23 @@ function createWindowLifecycle(deps) {
       : "script-src 'self' 'unsafe-inline'";
  
     const connectSrc = isDev
-      ? "connect-src 'self' https://api.languagetool.org ws: http://127.0.0.1:* http://localhost:*"
-      : "connect-src 'self' https://api.languagetool.org";
+      ? "connect-src 'self' https://api.languagetool.org https://esm.sh https://unpkg.com ws: http://127.0.0.1:* http://localhost:*"
+      : "connect-src 'self' https://api.languagetool.org https://esm.sh https://unpkg.com";
  
     return [
       "default-src 'self'",
       scriptSrc,
-      "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com data:",
-      "img-src 'self' data: blob: file:",
+      "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://esm.sh https://unpkg.com data:",
+      "img-src 'self' data: blob: file: https://esm.sh https://unpkg.com",
       "media-src 'self' data: blob: file:",
-      "font-src 'self' https://fonts.gstatic.com data:",
+      "font-src 'self' https://fonts.gstatic.com https://esm.sh https://unpkg.com data:",
       connectSrc,
       "worker-src 'self' blob:",
+      "child-src 'self' blob: data:",
       "object-src 'none'",
       "base-uri 'self'",
       "form-action 'none'",
-      "frame-src 'self' https://embed.draw.io https://viewer.diagrams.net https://embed.diagrams.net https://app.diagrams.net"
+      "frame-src 'self' blob: data: https://embed.draw.io https://viewer.diagrams.net https://embed.diagrams.net https://app.diagrams.net"
     ].join("; ");
   }
  
diff --git a/src/App.jsx b/src/App.jsx
index 8ce8efc..2cb3b40 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -433,6 +433,8 @@ export default function App() {
     openDocument,
     saveDocument,
     handleReloadCurrentFromDisk,
+    reloadDocument: _reloadDocument,
+    handleReloadWorkspace,
     handleDeleteCurrentDocument,
     handleDeleteCurrentFolder,
     handleRemoveListEntry,
@@ -450,6 +452,7 @@ export default function App() {
     handleOpenReferencedDocument,
     handleLandingNavigateTo,
     openTabs,
+    handleReorderTabs,
     activeTabPath,
     tabStates,
     handleCloseTab,
@@ -899,8 +902,8 @@ export default function App() {
     }
   }
 
-  async function handleOpenReferencedDocumentFromUI(filePath, lineNumber) {
-    await handleOpenReferencedDocument(filePath, lineNumber);
+  async function handleOpenReferencedDocumentFromUI(filePath, optionsOrLineNumber) {
+    await handleOpenReferencedDocument(filePath, optionsOrLineNumber);
     setLandingAssetsOpen(false);
   }
 
@@ -1693,6 +1696,11 @@ export default function App() {
         return;
       }
 
+      if (action === "reload-workspace") {
+        handleReloadWorkspace();
+        return;
+      }
+
       if (action === "remove-document") {
         handleDeleteCurrentDocument();
         return;
@@ -1941,6 +1949,8 @@ export default function App() {
     { id: "open-global-search", label: "Open Global Search", group: "Search", shortcut: "Ctrl/Cmd+Shift+F", aliases: "find everywhere search all notes quick open jump" },
     { id: "open-shortcuts", label: "Open Keyboard Shortcuts", group: "Help", shortcut: "Ctrl/Cmd+/", aliases: "hotkeys keymap shortcuts" },
     { id: "open-workspace", label: "Open Workspace", group: "Workspace", shortcut: "Ctrl/Cmd+Shift+N", aliases: "open workspace folder notes root path" },
+    { id: "reload-workspace", label: "Reload Workspace from Disk", group: "Workspace", shortcut: "Ctrl/Cmd+Alt+R", aliases: "refresh reload workspace disk" },
+    { id: "reload-document", label: "Reload Current Note from Disk", group: "Editor", shortcut: "Ctrl/Cmd+Shift+R", disabled: !current, aliases: "refresh reload note file disk" },
     { id: "export-workspace-zip", label: "Export Workspace as Zip", group: "Workspace", aliases: "export backup archive zip workspace" },
     { id: "open-workspace-graph", label: "Open Workspace Graph", group: "Navigation", aliases: "graph map relationships links topology" },
     { id: "open-tasks-panel", label: "Open Tasks Panel", group: "Navigation", aliases: "tasks todos checkboxes unchecked open items" },
@@ -2224,6 +2234,16 @@ export default function App() {
       return;
     }
 
+    if (resolvedCommandId === "reload-document") {
+      await handleReloadCurrentFromDisk();
+      return;
+    }
+
+    if (resolvedCommandId === "reload-workspace") {
+      await handleReloadWorkspace();
+      return;
+    }
+
     if (resolvedCommandId === "new-note") {
       setNoteDialogOpen(true);
       return;
@@ -2846,6 +2866,7 @@ export default function App() {
             onShowUpdateModal={() => setShowUpdateModal(true)}
             onDismissUpdate={() => setUpdateStatus("dismissed")}
             onCopyLinkPath={handleCopyLinkPath}
+            onReloadWorkspace={handleReloadWorkspace}
           />
           {landingAssetsOpen ? (
             <OverlayDialog open={landingAssetsOpen} onClose={() => setLandingAssetsOpen(false)} ariaLabel="Assets" cardClassName="assets-dialog-card">
@@ -2881,6 +2902,7 @@ export default function App() {
           <DocumentDetail
             document={current}
             openTabs={openTabs}
+            onReorderTabs={handleReorderTabs}
             activeTabPath={activeTabPath}
             tabStates={tabStates}
             documents={documents}
@@ -2918,8 +2940,8 @@ export default function App() {
             }}
             onRemoveIgnoredSpellingWord={handleRemoveDictionaryWord}
             onClearIgnoredSpellingWords={handleClearDictionary}
-            onForceSaveDocument={async () => {
-              await saveDocument({ reason: "diagram-or-code-save", silent: true });
+            onForceSaveDocument={async (nextContent) => {
+              await saveDocument({ reason: "diagram-or-code-save", silent: true, content: nextContent });
             }}
             autosaveEnabled={autosaveEnabled}
             setAutosaveEnabled={setAutosaveEnabled}
@@ -2968,6 +2990,7 @@ export default function App() {
             onOutlineEnabledChange={setOutlineEnabled}
             focusModeEnabled={focusModeEnabled}
             onFocusModeChange={setFocusModeEnabled}
+            onReloadFromDisk={(filePath) => handleReloadCurrentFromDisk(filePath)}
             aiSidebar={aiSidebarComponent}
           />
         </Suspense>
diff --git a/src/components/AISettings.jsx b/src/components/AISettings.jsx
index e18aa2b..f340f63 100644
--- a/src/components/AISettings.jsx
+++ b/src/components/AISettings.jsx
@@ -549,16 +549,34 @@ export const AISettingsContent = ({ _onClose }) => {
 
                 {selectedProvider === 'local' ? (
                   <div style={{ padding: "8px 10px", background: "var(--surface-muted)", borderRadius: "6px", border: "1px solid var(--border-soft)", marginBottom: "8px" }}>
-                    <h4 style={{ fontSize: "11px", fontWeight: "600", margin: "0 0 4px 0" }}>Local Model Status (Qwen ONNX)</h4>
+                    <h4 style={{ fontSize: "11px", fontWeight: "600", margin: "0 0 4px 0" }}>Local Model Status (GLiNER + GLiREL ONNX)</h4>
                     {modelStatus.downloaded ? (
-                      <div style={{ display: "flex", alignItems: "center", gap: "6px", color: "var(--status-success-text)", fontSize: "11px" }}>
-                        <Database size={12} />
-                        <span>Qwen2.5-0.5B ONNX model is downloaded and ready offline.</span>
+                      <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+                        <div style={{ display: "flex", alignItems: "center", gap: "6px", color: "var(--status-success-text)", fontSize: "11px" }}>
+                          <Database size={12} />
+                          <span>GLiNER & GLiREL ONNX model weights downloaded and ready offline.</span>
+                        </div>
+                        <button
+                          className="btn btn-secondary btn-sm"
+                          onClick={async () => {
+                            if (!window.confirm('Delete local GLiNER and GLiREL ONNX weights from disk?')) return;
+                            try {
+                              const { aiDeleteGraphModel } = await import('../services/electronService');
+                              await aiDeleteGraphModel();
+                              setModelStatus({ downloaded: false, isDownloading: false, progress: 0 });
+                            } catch (err) {
+                              console.error(err);
+                            }
+                          }}
+                          style={{ display: "flex", gap: "4px", alignItems: "center", padding: "3px 6px", fontSize: "10px", color: "var(--text-danger)" }}
+                        >
+                          <Trash2 size={12} /> Delete
+                        </button>
                       </div>
                     ) : modelStatus.isDownloading ? (
                       <div style={{ display: "flex", flexDirection: "column", gap: "4px" }}>
                         <div style={{ display: "flex", justifyContent: "space-between", fontSize: "10px" }}>
-                          <span>Downloading local weights...</span>
+                          <span>Downloading GLiNER & GLiREL weights...</span>
                           <span>{modelStatus.progress}%</span>
                         </div>
                         <div style={{ width: "100%", height: "4px", background: "var(--border-soft)", borderRadius: "2px", overflow: "hidden" }}>
@@ -567,7 +585,7 @@ export const AISettingsContent = ({ _onClose }) => {
                       </div>
                     ) : (
                       <div style={{ display: "flex", flexDirection: "column", gap: "6px" }}>
-                        <span style={{ fontSize: "11px", color: "var(--text-muted)" }}>Qwen ONNX model not found. Click the button below or go to Knowledge Graph tab to download.</span>
+                        <span style={{ fontSize: "11px", color: "var(--text-muted)" }}>GLiNER + GLiREL ONNX models not found. Click below or go to Knowledge Graph tab to download.</span>
                         <button
                           className="btn btn-secondary btn-sm"
                           onClick={async () => {
@@ -584,13 +602,10 @@ export const AISettingsContent = ({ _onClose }) => {
                           style={{ display: "flex", gap: "6px", alignItems: "center", padding: "6px 12px", width: "fit-content" }}
                         >
                           <Download size={12} />
-                          <span>Download Qwen2.5-0.5B ONNX (350MB)</span>
+                          <span>Download GLiNER & GLiREL Models</span>
                         </button>
                       </div>
                     )}
-                    <div style={{ color: "var(--text-muted)", fontSize: "10.5px", marginTop: "6px", borderLeft: "2px solid var(--accent-solid)", paddingLeft: "6px" }}>
-                      ⚠️ <strong>Hardware Warning:</strong> Running text models locally executes inference directly on your CPU. This requires a modern processor and at least 8GB-16GB RAM. Performance may cause temporary UI lag/freezes during generation.
-                    </div>
                   </div>
                 ) : (
                   <div className="api-key-group compact" style={{ marginBottom: "8px" }}>
diff --git a/src/components/DocumentDetail.jsx b/src/components/DocumentDetail.jsx
index 3b2f41a..45bf822 100644
--- a/src/components/DocumentDetail.jsx
+++ b/src/components/DocumentDetail.jsx
@@ -708,6 +708,7 @@ export function DocumentDetail({
   autosaveEnabled = false,
   setAutosaveEnabled,
   openTabs = [],
+  onReorderTabs,
   activeTabPath = null,
   tabStates = {},
   documents = [],
@@ -722,10 +723,12 @@ export function DocumentDetail({
   onOpenInEditor,
   onRevealInExplorer,
   onCopyLinkPath,
+  onReloadFromDisk,
 }) {
   const { confirm } = useConfirm();
   const MAX_EDITOR_HISTORY = 200;
   const textareaRef = useRef(null);
+  const taskPopoverTimerRef = useRef(null);
   const historyStateRef = useRef({
     raw: { undo: [], redo: [] },
     cleansed: { undo: [], redo: [] },
@@ -759,6 +762,15 @@ export function DocumentDetail({
       return Number.isNaN(parsed) ? 380 : parsed;
     },
   });
+
+  const [targetLine, setTargetLine] = useState(initialLine);
+
+  useEffect(() => {
+    if (initialLine != null) {
+      setTargetLine(initialLine);
+    }
+  }, [initialLine]);
+
   const workspaceLayoutRef = useRef(null);
 
   const clampOutlineWidth = (w) => Math.min(Math.max(w, 150), 350);
@@ -867,11 +879,13 @@ export function DocumentDetail({
 
   const handleReloadFromDisk = async () => {
     try {
-      if (typeof onOpenDocument === "function") {
-        await onOpenDocument(document.filePath);
-        setChangedOnDisk(false);
-        onNotify?.("Note reloaded from disk.", "success");
+      if (typeof onReloadFromDisk === "function") {
+        await onReloadFromDisk(document.filePath);
+      } else if (typeof onOpenDocument === "function") {
+        await onOpenDocument(document.filePath, { forceReload: true, preserveActiveTab: true });
       }
+      setChangedOnDisk(false);
+      onNotify?.("Note reloaded from disk.", "success");
     } catch (err) {
       onNotify?.(err?.message || "Failed to reload document.", "error");
     }
@@ -1126,11 +1140,13 @@ export function DocumentDetail({
     requestAnimationFrame(restore);
     const lateRestoreA = window.setTimeout(restore, 80);
     const lateRestoreB = window.setTimeout(restore, 220);
+    const lateRestoreC = window.setTimeout(restore, 300);
 
     return () => {
       canceled = true;
       window.clearTimeout(lateRestoreA);
       window.clearTimeout(lateRestoreB);
+      window.clearTimeout(lateRestoreC);
     };
   };
 
@@ -1211,32 +1227,54 @@ export function DocumentDetail({
 
   const jumpToLine = (line) => {
     const safeLine = Math.max(Number(line) || 1, 1);
-    if (mode !== "edit" && mode !== "split") {
+    setTargetLine(safeLine);
+    
+    if (mode === "preview") {
+      const previewEl = window.document.querySelector(".markdown-preview, .preview-container");
+      if (previewEl) {
+        const targetNode = previewEl.querySelector(`[data-source-line="${safeLine}"]`) ||
+          Array.from(previewEl.querySelectorAll("[data-source-line]")).find(el => Number(el.getAttribute("data-source-line")) >= safeLine);
+        if (targetNode) {
+          targetNode.scrollIntoView({ behavior: "smooth", block: "center" });
+          return;
+        }
+      }
       setEditorMode("edit", { announce: false, force: true });
       requestAnimationFrame(() => jumpToLine(safeLine));
       return;
     }
 
     const editor = textareaRef?.current;
-    if (!editor) return;
+    if (editor) {
+      const lines = (content || "").split(/\r?\n/);
+      let startIndex = 0;
+      for (let index = 0; index < Math.min(safeLine - 1, lines.length); index += 1) {
+        startIndex += lines[index].length + 1;
+      }
 
-    const lines = (content || "").split(/\r?\n/);
-    let startIndex = 0;
-    for (let index = 0; index < Math.min(safeLine - 1, lines.length); index += 1) {
-      startIndex += lines[index].length + 1;
+      editor.focus();
+      editor.selectionStart = startIndex;
+      editor.selectionEnd = startIndex;
+
+      const lineHeight = typeof editor.getLineHeight === "function"
+        ? editor.getLineHeight()
+        : parseFloat(window.getComputedStyle(editor).lineHeight) || 20;
+      const viewportHeight = Number(editor.clientHeight) || lineHeight * 20;
+      const targetTop = (safeLine - 1) * lineHeight - viewportHeight * 0.66;
+      const maxScroll = Math.max(0, (Number(editor.scrollHeight) || 0) - viewportHeight);
+      editor.scrollTop = Math.max(0, Math.min(targetTop, maxScroll));
     }
 
-    editor.focus();
-    editor.selectionStart = startIndex;
-    editor.selectionEnd = startIndex;
-
-    const lineHeight = typeof editor.getLineHeight === "function"
-      ? editor.getLineHeight()
-      : parseFloat(window.getComputedStyle(editor).lineHeight) || 20;
-    const viewportHeight = Number(editor.clientHeight) || lineHeight * 20;
-    const targetTop = (safeLine - 1) * lineHeight - viewportHeight * 0.66;
-    const maxScroll = Math.max(0, (Number(editor.scrollHeight) || 0) - viewportHeight);
-    editor.scrollTop = Math.max(0, Math.min(targetTop, maxScroll));
+    if (mode === "split") {
+      const previewEl = window.document.querySelector(".markdown-preview, .preview-container");
+      if (previewEl) {
+        const targetNode = previewEl.querySelector(`[data-source-line="${safeLine}"]`) ||
+          Array.from(previewEl.querySelectorAll("[data-source-line]")).find(el => Number(el.getAttribute("data-source-line")) >= safeLine);
+        if (targetNode) {
+          targetNode.scrollIntoView({ behavior: "smooth", block: "center" });
+        }
+      }
+    }
   };
 
   const openFindPanel = ({ showReplace = false } = {}) => {
@@ -1707,6 +1745,7 @@ export function DocumentDetail({
       {!isFocusMode && (
         <NoteTabBar
           openTabs={openTabs}
+          onReorderTabs={onReorderTabs}
           activeTabPath={activeTabPath}
           tabStates={tabStates}
           documents={documents}
@@ -1721,6 +1760,7 @@ export function DocumentDetail({
           onOpenInEditor={onOpenInEditor}
           onRevealInExplorer={onRevealInExplorer}
           onCopyLinkPath={onCopyLinkPath}
+          onReloadFromDisk={onReloadFromDisk}
         />
       )}
       {!isFocusMode && (
@@ -1747,9 +1787,20 @@ export function DocumentDetail({
           </nav>
           {taskCounts.total > 0 && (
             <div
-              className="detail-task-summary"
-              onMouseEnter={() => setIsTaskSummaryOpen(true)}
-              onMouseLeave={() => setIsTaskSummaryOpen(false)}
+              className={`detail-task-summary${isTaskSummaryOpen ? " open" : ""}`}
+              onMouseEnter={() => {
+                if (taskPopoverTimerRef.current) {
+                  clearTimeout(taskPopoverTimerRef.current);
+                  taskPopoverTimerRef.current = null;
+                }
+                setIsTaskSummaryOpen(true);
+              }}
+              onMouseLeave={() => {
+                if (taskPopoverTimerRef.current) clearTimeout(taskPopoverTimerRef.current);
+                taskPopoverTimerRef.current = setTimeout(() => {
+                  setIsTaskSummaryOpen(false);
+                }, 450);
+              }}
               onFocus={() => setIsTaskSummaryOpen(true)}
               onBlur={(event) => {
                 if (!event.currentTarget.contains(event.relatedTarget)) {
@@ -1784,7 +1835,13 @@ export function DocumentDetail({
                     <strong>Open</strong>
                     <ul className="detail-task-popover-list">
                       {openTaskItems.map((task) => (
-                        <li className="detail-task-popover-item open" key={task.id}>
+                        <li
+                          className="detail-task-popover-item open"
+                          key={task.id}
+                          onClick={() => jumpToLine(task.line)}
+                          style={{ cursor: "pointer" }}
+                          title="Click to jump to task in editor"
+                        >
                           <span className="detail-task-popover-marker">[ ]</span>
                           <span>{task.text}</span>
                         </li>
@@ -1797,7 +1854,13 @@ export function DocumentDetail({
                     <strong>Closed</strong>
                     <ul className="detail-task-popover-list">
                       {closedTaskItems.map((task) => (
-                        <li className="detail-task-popover-item closed" key={task.id}>
+                        <li
+                          className="detail-task-popover-item closed"
+                          key={task.id}
+                          onClick={() => jumpToLine(task.line)}
+                          style={{ cursor: "pointer" }}
+                          title="Click to jump to task in editor"
+                        >
                           <span className="detail-task-popover-marker">[x]</span>
                           <span>{task.text}</span>
                         </li>
@@ -2096,8 +2159,10 @@ export function DocumentDetail({
             onRemoveIgnoredSpellingWord={onRemoveIgnoredSpellingWord}
             onClearIgnoredSpellingWords={onClearIgnoredSpellingWords}
             onForceSaveDocument={onForceSaveDocument}
-            initialLine={initialLine}
+            initialLine={targetLine ?? initialLine}
             onLineJumped={onLineJumped}
+            outlineEnabled={outlineEnabled}
+            onOutlineEnabledChange={onOutlineEnabledChange}
           />
         </main>
 
@@ -2144,17 +2209,7 @@ export function DocumentDetail({
             {aiSidebar}
           </div>
         )}
-        {!aiPanelVisible && aiEnabled ? (
-          <button
-            type="button"
-            className="ai-panel-reveal"
-            onClick={onShowAI}
-            data-tooltip="Show AI panel"
-            aria-label="Show AI panel"
-          >
-            AI
-          </button>
-        ) : null}
+
       </div>
 
 
diff --git a/src/components/EditorPane.jsx b/src/components/EditorPane.jsx
index 17a39a7..d5baaa5 100644
--- a/src/components/EditorPane.jsx
+++ b/src/components/EditorPane.jsx
@@ -35,6 +35,8 @@ export function EditorPane({
   activeFindMatchIndex = -1,
   showOriginalImages = false,
   inlineLinkedMarkdown = false,
+  outlineEnabled = true,
+  onOutlineEnabledChange,
   typoCheckEnabled = true,
   screenCaptureMode = "auto",
   ignoredSpellingWords = [],
@@ -50,6 +52,15 @@ export function EditorPane({
   const [editorReadyTick, setEditorReadyTick] = useState(0);
   const [selectedMediaPreview, setSelectedMediaPreview] = useState(null);
   const [scrollSyncEnabled, setScrollSyncEnabled] = useState(true);
+  const [tableEditorEnabled, setTableEditorEnabled] = useState(() => {
+    return localStorage.getItem("notes:table-editor-enabled") !== "false";
+  });
+
+  const handleTableEditorToggle = useCallback((nextValue) => {
+    const value = Boolean(nextValue);
+    setTableEditorEnabled(value);
+    localStorage.setItem("notes:table-editor-enabled", String(value));
+  }, []);
 
   const jumpToLine = useCallback((line) => {
     const editor = textareaRef?.current;
@@ -378,6 +389,7 @@ export function EditorPane({
     <MarkdownEditor
       value={value}
       onChange={onChange}
+      basePath={basePath}
       textareaRef={textareaRef}
       onNotify={onNotify}
       validationIssues={validationIssues}
@@ -397,6 +409,7 @@ export function EditorPane({
       onRejectInlineGhost={onRejectInlineGhost}
       findMatches={findMatches}
       activeFindMatchIndex={activeFindMatchIndex}
+      tableEditorEnabled={tableEditorEnabled}
       onEditorReady={() => setEditorReadyTick((value) => value + 1)}
       onSearchRequest={(query) => {
         window.dispatchEvent(new CustomEvent("open-global-search-query", { detail: { query } }));
@@ -420,6 +433,10 @@ export function EditorPane({
     ignoredSpellingWords,
     onIgnoreSpellingWord: onIgnoreSpellingWord,
     screenCaptureMode,
+    tableEditorEnabled,
+    onTableEditorToggle: handleTableEditorToggle,
+    outlineEnabled,
+    onOutlineEnabledChange,
   };
 
   const renderToolbar = () => (
@@ -448,6 +465,7 @@ export function EditorPane({
             onMediaClick={setSelectedMediaPreview}
             showOriginalImages={showOriginalImages}
             inlineLinkedMarkdown={inlineLinkedMarkdown}
+            onForceSaveDocument={onForceSaveDocument}
             onSearchRequest={(query) => {
               window.dispatchEvent(new CustomEvent("open-global-search-query", { detail: { query } }));
             }}
@@ -495,7 +513,7 @@ export function EditorPane({
               <span className="pane-title-label">Editor</span>
             </div>
             {showToolbar ? renderToolbar() : null}
-            {showToolbar ? <MarkdownValidationBanner issues={validationIssues} status={validationStatus} /> : null}
+
             <div className="markdown-editor">{markdownEditor}</div>
           </section>
           <div
diff --git a/src/components/ExcalidrawEditor.jsx b/src/components/ExcalidrawEditor.jsx
index cb706e8..edac84f 100644
--- a/src/components/ExcalidrawEditor.jsx
+++ b/src/components/ExcalidrawEditor.jsx
@@ -159,6 +159,7 @@ const ExcalidrawComponent = ({
   documentPath,
   onClose,
   onSave,
+  onNotify,
 }) => {
   const excalidrawAPIRef = useRef(null);
   const lastSavedElementsRef = useRef(initialData?.elements || []);
@@ -351,7 +352,6 @@ const ExcalidrawComponent = ({
         appState: {
           ...appState,
           exportBackground: true,
-          // Always export a white image background so embedded note previews stay visually consistent.
           viewBackgroundColor: "#ffffff",
         },
         files,
@@ -366,6 +366,7 @@ const ExcalidrawComponent = ({
       onSave?.(diagramData, imageData);
     } catch (err) {
       console.error("Failed to save Excalidraw diagram:", err);
+      onNotify?.(err?.message || "Failed to save Excalidraw diagram.", "error");
     } finally {
       setIsSaving(false);
     }
diff --git a/src/components/KnowledgeGraph.jsx b/src/components/KnowledgeGraph.jsx
index dd959d2..0d79f59 100644
--- a/src/components/KnowledgeGraph.jsx
+++ b/src/components/KnowledgeGraph.jsx
@@ -57,11 +57,19 @@ const TYPE_COLORS = {
   Project: { background: 'var(--kg-project-bg)', border: 'var(--kg-project-border)', text: 'var(--kg-project-border)' },
   Technology: { background: 'var(--kg-tech-bg)', border: 'var(--kg-tech-border)', text: 'var(--kg-tech-border)' },
   Company: { background: 'var(--kg-company-bg)', border: 'var(--kg-company-border)', text: 'var(--kg-company-border)' },
+  Organization: { background: 'var(--kg-company-bg)', border: 'var(--kg-company-border)', text: 'var(--kg-company-border)' },
   Concept: { background: 'var(--kg-concept-bg)', border: 'var(--kg-concept-border)', text: 'var(--kg-concept-border)' },
   Task: { background: 'var(--kg-task-bg)', border: 'var(--kg-task-border)', text: 'var(--kg-task-border)' },
   Image: { background: 'var(--kg-image-bg)', border: 'var(--kg-image-border)', text: 'var(--kg-image-border)' },
   Document: { background: 'var(--kg-doc-bg)', border: 'var(--kg-doc-border)', text: 'var(--kg-doc-border)' },
-  ExternalURL: { background: 'var(--kg-url-bg)', border: 'var(--kg-url-border)', text: 'var(--kg-url-border)' }
+  ExternalURL: { background: 'var(--kg-url-bg)', border: 'var(--kg-url-border)', text: 'var(--kg-url-border)' },
+  CodeBlock: { background: 'var(--kg-tech-bg)', border: 'var(--kg-tech-border)', text: 'var(--kg-tech-border)' },
+  Diagram: { background: 'var(--kg-image-bg)', border: 'var(--kg-image-border)', text: 'var(--kg-image-border)' },
+  Section: { background: 'var(--kg-concept-bg)', border: 'var(--kg-concept-border)', text: 'var(--kg-concept-border)' },
+  Tag: { background: 'var(--kg-project-bg)', border: 'var(--kg-project-border)', text: 'var(--kg-project-border)' },
+  KeyTerm: { background: 'var(--kg-person-bg)', border: 'var(--kg-person-border)', text: 'var(--kg-person-border)' },
+  Formula: { background: 'var(--kg-company-bg)', border: 'var(--kg-company-border)', text: 'var(--kg-company-border)' },
+  Callout: { background: 'var(--kg-task-bg)', border: 'var(--kg-task-border)', text: 'var(--kg-task-border)' }
 };
 
 const DEFAULT_COLOR = { background: 'var(--kg-default-bg)', border: 'var(--kg-default-border)', text: 'var(--text-strong)' };
@@ -342,12 +350,16 @@ export default function KnowledgeGraph({ onBack }) {
     try {
       setError('');
       setIsRebuilding(true);
-      setGraphStatus(prev => ({ ...prev, isBuilding: true, current: 0, noteName: 'Initializing ModernBERT worker...' }));
+      setNodes([]);
+      setEdges([]);
+      setGraphStatus(prev => ({ ...prev, isBuilding: true, current: 0, noteName: 'Initializing GLiNER/GLiREL worker...' }));
       const rebuildRes = await aiBuildGraph();
       if (!rebuildRes.success) {
         setError(rebuildRes.error || 'Rebuild failed.');
         setIsRebuilding(false);
         setGraphStatus(prev => ({ ...prev, isBuilding: false }));
+      } else {
+        loadGraphData();
       }
     } catch (err) {
       setError(err.message || 'Failed to rebuild Knowledge Graph.');
diff --git a/src/components/KnowledgeGraphSettings.jsx b/src/components/KnowledgeGraphSettings.jsx
index a5571fd..c82b0cb 100644
--- a/src/components/KnowledgeGraphSettings.jsx
+++ b/src/components/KnowledgeGraphSettings.jsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useState } from 'react';
-import { Database, Download, AlertCircle, Save, Trash2, Cpu } from 'lucide-react';
+import { Database, Download, AlertCircle, Save, Trash2, Cpu, Sliders } from 'lucide-react';
 import AppSelect from './AppSelect';
 import {
   aiGetGraphModelStatus,
@@ -12,7 +12,7 @@ import {
 
 export default function KnowledgeGraphSettings() {
   const [loading, setLoading] = useState(false);
-  const [preferences, setPreferences] = useState({ graphProvider: 'local', graphConfidence: 0.60 });
+  const [preferences, setPreferences] = useState({ graphProvider: 'gliner-glirel', graphConfidence: 0.60 });
   const [modelStatus, setModelStatus] = useState({ downloaded: false, isDownloading: false, progress: 0 });
 
   useEffect(() => {
@@ -48,7 +48,7 @@ export default function KnowledgeGraphSettings() {
     };
   }, []);
 
-  const handleProviderSave = async () => {
+  const handlePreferencesSave = async () => {
     try {
       setLoading(true);
       await aiSetPreferences({
@@ -57,7 +57,7 @@ export default function KnowledgeGraphSettings() {
         graphConfidence: preferences.graphConfidence
       });
       window.dispatchEvent(new CustomEvent('app:toast', {
-        detail: { message: `Knowledge Graph preferences saved.`, type: 'success' }
+        detail: { message: `Knowledge Graph preferences saved successfully.`, type: 'success' }
       }));
     } catch (err) {
       console.error(err);
@@ -87,13 +87,13 @@ export default function KnowledgeGraphSettings() {
   };
 
   const handleDeleteModel = async () => {
-    if (!window.confirm('Delete local ModernBERT ONNX model weights (NER + RE) from disk? You can redownload anytime.')) return;
+    if (!window.confirm('Delete local GLiNER and GLiREL ONNX model weights from disk? You can redownload anytime.')) return;
     try {
       setLoading(true);
       await aiDeleteGraphModel();
       setModelStatus({ downloaded: false, isDownloading: false, progress: 0 });
       window.dispatchEvent(new CustomEvent('app:toast', {
-        detail: { message: 'Local ModernBERT NER & RE model weights deleted successfully.', type: 'info' }
+        detail: { message: 'Local GLiNER & GLiREL ONNX model weights deleted successfully.', type: 'info' }
       }));
     } catch (err) {
       console.error(err);
@@ -105,6 +105,8 @@ export default function KnowledgeGraphSettings() {
     }
   };
 
+  const activeProvider = (preferences.graphProvider === 'text-provider') ? 'text-provider' : 'gliner-glirel';
+
   return (
     <div style={{ display: "flex", flexDirection: "column", gap: "16px", width: "100%" }}>
       <section className="ai-settings-section ai-settings-setup-card" style={{ gridColumn: "1 / -1", margin: 0 }}>
@@ -117,25 +119,25 @@ export default function KnowledgeGraphSettings() {
           <div style={{ display: "flex", gap: "5px", alignItems: "center", marginTop: "2px" }}>
             <AppSelect
               id="graph-provider-select"
-              value={preferences.graphProvider || 'local'}
+              value={activeProvider}
               onChange={async (e) => {
                 const newProvider = e.target.value;
                 const updated = { ...preferences, graphProvider: newProvider };
                 setPreferences(updated);
                 await aiSetPreferences(updated);
                 window.dispatchEvent(new CustomEvent('app:toast', {
-                  detail: { message: `Graph extraction provider set to ${newProvider === 'local' ? 'ModernBERT Local ONNX 2-Model Pipeline' : 'Cloud Text Provider'}.`, type: 'success' }
+                  detail: { message: `Graph extraction engine set to ${newProvider === 'gliner-glirel' ? 'GLiNER + GLiREL Model-Driven Pipeline' : 'Cloud AI Provider'}.`, type: 'success' }
                 }));
               }}
               disabled={loading}
               style={{ flex: 1 }}
             >
-              <option value="local">ModernBERT 2-Model Pipeline (NER + RE ONNX - Recommended)</option>
-              <option value="text-provider">Cloud LLM Provider (Configured Cloud AI)</option>
+              <option value="gliner-glirel">GLiNER + GLiREL Model-Driven Pipeline (Zero-Shot ONNX - Recommended)</option>
+              <option value="text-provider">Cloud LLM Text Provider (Configured Cloud AI)</option>
             </AppSelect>
             <button
               className="btn btn-primary"
-              onClick={handleProviderSave}
+              onClick={handlePreferencesSave}
               disabled={loading}
               type="button"
             >
@@ -144,20 +146,42 @@ export default function KnowledgeGraphSettings() {
           </div>
           <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', fontSize: '11px', marginTop: '10px', paddingBottom: '6px', borderBottom: '1px solid var(--border-soft)' }}>
             <span style={{ color: 'var(--text-muted)' }}>Active Extraction Engine</span>
-            <strong style={{ color: 'var(--text-strong)' }}>{preferences.graphProvider === 'local' ? 'ModernBERT 2-Model (NER + RE) ONNX + Structural Parser' : 'Cloud LLM Text Provider'}</strong>
+            <strong style={{ color: 'var(--text-strong)' }}>
+              {activeProvider === 'gliner-glirel' ? 'GLiNER Zero-Shot NER + GLiREL Zero-Shot RE ONNX' : 'Cloud LLM Text Provider'}
+            </strong>
+          </div>
+        </div>
+
+        <div className="preference-group compact" style={{ marginBottom: "12px" }}>
+          <label htmlFor="graph-confidence-slider" style={{ fontSize: "11px", display: "flex", justifyContent: "space-between" }}>
+            <span>Extraction Confidence Threshold</span>
+            <strong>{Math.round((preferences.graphConfidence || 0.60) * 100)}%</strong>
+          </label>
+          <div style={{ display: "flex", gap: "10px", alignItems: "center", marginTop: "4px" }}>
+            <Sliders size={14} style={{ color: 'var(--text-muted)' }} />
+            <input
+              id="graph-confidence-slider"
+              type="range"
+              min="0.30"
+              max="0.95"
+              step="0.05"
+              value={preferences.graphConfidence || 0.60}
+              onChange={(e) => setPreferences({ ...preferences, graphConfidence: parseFloat(e.target.value) })}
+              style={{ flex: 1 }}
+            />
           </div>
         </div>
 
-        {preferences.graphProvider === 'local' && (
+        {activeProvider === 'gliner-glirel' && (
           <div style={{ padding: "12px", background: "var(--surface-muted)", borderRadius: "6px", border: "1px solid var(--border-soft)", marginTop: "6px" }}>
             <h4 style={{ fontSize: "12px", fontWeight: "600", margin: "0 0 8px 0", display: "flex", alignItems: "center", gap: "6px" }}>
-              <Cpu size={14} /> Local 2-Model Status (ModernBERT NER + RE ONNX)
+              <Cpu size={14} /> Offline Model Status (GLiNER + GLiREL ONNX)
             </h4>
             {modelStatus.downloaded ? (
               <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
                 <div style={{ display: "flex", alignItems: "center", gap: "6px", color: "var(--status-success-text)", fontSize: "11px" }}>
                   <Database size={12} />
-                  <span>ModernBERT NER & RE ONNX weights (~70MB) downloaded and ready offline.</span>
+                  <span>GLiNER Zero-Shot NER & GLiREL Zero-Shot RE ONNX weights downloaded and ready offline.</span>
                 </div>
                 <button
                   className="btn btn-secondary btn-sm"
@@ -173,7 +197,7 @@ export default function KnowledgeGraphSettings() {
             ) : modelStatus.isDownloading ? (
               <div style={{ display: "flex", flexDirection: "column", gap: "6px" }}>
                 <div style={{ display: "flex", justifyContent: "space-between", fontSize: "11px" }}>
-                  <span>Downloading ModernBERT NER & RE ONNX weights (~70MB)...</span>
+                  <span>Downloading GLiNER & GLiREL ONNX weights...</span>
                   <span style={{ fontWeight: 600, color: 'var(--brand-primary)' }}>{modelStatus.progress}%</span>
                 </div>
                 <div style={{ width: '100%', height: '6px', background: 'var(--border-soft)', borderRadius: '3px', overflow: 'hidden' }}>
@@ -184,7 +208,7 @@ export default function KnowledgeGraphSettings() {
               <div style={{ display: "flex", flexDirection: "column", gap: "8px" }}>
                 <div style={{ display: "flex", alignItems: "center", gap: "6px", color: "var(--text-muted)", fontSize: "11px" }}>
                   <AlertCircle size={12} />
-                  <span>ModernBERT 2-Model pipeline is not downloaded. (Downloads both ModernBERT NER & RE models for deep entity and relation extraction)</span>
+                  <span>GLiNER + GLiREL models not downloaded. (Downloads zero-shot ONNX models for offline knowledge graph extraction)</span>
                 </div>
                 <button
                   className="btn btn-secondary btn-sm"
@@ -193,7 +217,7 @@ export default function KnowledgeGraphSettings() {
                   style={{ display: "flex", gap: "6px", alignItems: "center", padding: "6px 12px", width: "fit-content" }}
                 >
                   <Download size={12} />
-                  <span>Download ModernBERT NER & RE (~70MB)</span>
+                  <span>Download GLiNER & GLiREL Models</span>
                 </button>
               </div>
             )}
diff --git a/src/components/LandingListControls.jsx b/src/components/LandingListControls.jsx
index a341112..eceaea9 100644
--- a/src/components/LandingListControls.jsx
+++ b/src/components/LandingListControls.jsx
@@ -1,4 +1,4 @@
-import { FilePlus2, FileText, Folder } from "lucide-react";
+import { FilePlus2, FileText, Folder, RefreshCw } from "lucide-react";
 import AppButton from "./AppButton";
 import AppSelect from "./AppSelect";
 
@@ -16,6 +16,7 @@ export function LandingListControls({
   visibleNoteCount,
   totalNoteCount,
   onCreateNote,
+  onReloadWorkspace,
 }) {
   return (
     <div className="landing-list-controls" aria-label="List controls">
@@ -91,6 +92,19 @@ export function LandingListControls({
         </span>
       </div>
 
+      {onReloadWorkspace && (
+        <AppButton
+          variant="small"
+          className="landing-reload-btn"
+          onClick={onReloadWorkspace}
+          data-tooltip="Reload workspace from disk"
+          aria-label="Reload workspace from disk"
+        >
+          <RefreshCw size={14} />
+          <span>Reload</span>
+        </AppButton>
+      )}
+
       {onCreateNote && (
         <AppButton
           variant="small"
diff --git a/src/components/MarkdownEditor.jsx b/src/components/MarkdownEditor.jsx
index 8d64e57..4df9b8c 100644
--- a/src/components/MarkdownEditor.jsx
+++ b/src/components/MarkdownEditor.jsx
@@ -11,6 +11,7 @@ import { insertMediaFromFiles } from "../services/imageService";
 import { applyMarkdownQuickFix, applyValidationSuggestion, getIssueFixType } from "../utils/markdownQuickFix";
 import { editorTheme } from "../utils/editorTheme";
 import { generateDiagramId } from "../utils/diagramFileUtils";
+import { useClipboardPaste } from "../hooks/useClipboardPaste";
 
 function getLineStartIndex(text, lineNumber) {
   const targetLine = Math.max(lineNumber, 1);
@@ -274,8 +275,28 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
   activeFindMatchIndex = -1,
   onEditorReady,
   onInlineAIContinue,
+  tableEditorEnabled = true,
+  basePath,
 }) {
   const viewRef = useRef(null);
+
+  const handleInsertMarkdownAtCursor = useCallback((mdText) => {
+    if (!viewRef.current || !mdText) return;
+    const view = viewRef.current;
+    const selection = view.state.selection.main;
+    view.dispatch({
+      changes: { from: selection.from, to: selection.to, insert: mdText },
+      selection: { anchor: selection.from + mdText.length },
+    });
+    onChange?.(view.state.doc.toString());
+  }, [onChange]);
+
+  const { handlePaste } = useClipboardPaste({
+    enabled: !readOnly,
+    basePath,
+    onInsertMarkdown: handleInsertMarkdownAtCursor,
+    onNotify,
+  });
   const menuRef = useRef(null);
   const [contextMenu, setContextMenu] = useState(null);
   const [slashMenu, setSlashMenu] = useState(null);
@@ -336,6 +357,56 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
     }
   }, [slashMenu, viewRef, SLASH_COMMANDS, onNotify]);
 
+  const lastScrollTopRef = useRef(0);
+
+  useEffect(() => {
+    const view = viewRef.current;
+    if (!view?.scrollDOM) return;
+    const handleScroll = () => {
+      if (view?.scrollDOM) {
+        lastScrollTopRef.current = view.scrollDOM.scrollTop;
+      }
+    };
+    const scrollDOM = view.scrollDOM;
+    scrollDOM.addEventListener("scroll", handleScroll, { passive: true });
+    return () => scrollDOM.removeEventListener("scroll", handleScroll);
+  }, []);
+
+  useEffect(() => {
+    if (viewRef.current?.scrollDOM && lastScrollTopRef.current > 0) {
+      const targetScroll = lastScrollTopRef.current;
+      requestAnimationFrame(() => {
+        if (viewRef.current?.scrollDOM) {
+          viewRef.current.scrollDOM.scrollTop = targetScroll;
+        }
+      });
+      window.setTimeout(() => {
+        if (viewRef.current?.scrollDOM) {
+          viewRef.current.scrollDOM.scrollTop = targetScroll;
+        }
+      }, 60);
+    }
+  }, [value]);
+
+  useEffect(() => {
+    if (viewRef.current && Number.isFinite(focusedLine) && focusedLine > 0) {
+      const view = viewRef.current;
+      const safeLine = Math.max(1, Math.min(focusedLine, view.state.doc.lines));
+      const lineObj = view.state.doc.line(safeLine);
+
+      // Single cursor at start of line without selecting/highlighting block!
+      view.dispatch({
+        selection: { anchor: lineObj.from },
+        scrollIntoView: true,
+      });
+
+      if (view.scrollDOM) {
+        const block = view.lineBlockAt(lineObj.from);
+        view.scrollDOM.scrollTop = Math.max(0, block.top - view.scrollDOM.clientHeight / 3);
+      }
+    }
+  }, [focusedLine]);
+
   const [themeMode, setThemeMode] = useState(() => {
     return document.documentElement.getAttribute("data-theme") || "light";
   });
@@ -351,6 +422,8 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
 
   const valueLength = String(value || "").length;
   const decorationsSynced = docLength === valueLength;
+  const [isDragOver, setIsDragOver] = useState(false);
+  const dragCounterRef = useRef(0);
 
   // Explicit hotkey trigger for inline AI completion (Alt-\)
   useEffect(() => {
@@ -513,6 +586,7 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
       requestAnimationFrame(restoreViewport);
       window.setTimeout(restoreViewport, 80);
       window.setTimeout(restoreViewport, 220);
+      window.setTimeout(restoreViewport, 300);
     };
 
     applyChange(scheduleViewportRestore);
@@ -853,6 +927,10 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
         }
         return false;
       },
+      paste(event) {
+        void handlePaste(event);
+        return false;
+      },
       drop(event, view) {
         const files = event.dataTransfer?.files || [];
         if (!files.length) return false;
@@ -1002,10 +1080,29 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
         },
       },
     ]),
-  ], [findMatchDecorations, ghostSuggestionDecorations, onChange, onNotify, onOpenFind, onRedo, onToggleFind, onUndo, validationDecorations, validationIssues, _activeLine, aiEnabled, onAcceptInlineGhost, onRejectInlineGhost, ghostSuggestion, slashMenu, activeSlashIndex, SLASH_COMMANDS, triggerSlashCommand]);
+  ], [findMatchDecorations, ghostSuggestionDecorations, handlePaste, onChange, onNotify, onOpenFind, onRedo, onToggleFind, onUndo, validationDecorations, validationIssues, _activeLine, aiEnabled, onAcceptInlineGhost, onRejectInlineGhost, ghostSuggestion, slashMenu, activeSlashIndex, SLASH_COMMANDS, triggerSlashCommand]);
 
   return (
-    <div className="markdown-editor">
+    <div
+      className={`markdown-editor${isDragOver ? " cm-drop-active" : ""}`}
+      onDragEnter={(e) => {
+        if (e.dataTransfer?.types?.includes("Files")) {
+          dragCounterRef.current += 1;
+          setIsDragOver(true);
+        }
+      }}
+      onDragLeave={() => {
+        dragCounterRef.current -= 1;
+        if (dragCounterRef.current <= 0) {
+          dragCounterRef.current = 0;
+          setIsDragOver(false);
+        }
+      }}
+      onDrop={() => {
+        dragCounterRef.current = 0;
+        setIsDragOver(false);
+      }}
+    >
       <CodeMirror
         className="markdown-codemirror"
         value={value}
@@ -1076,7 +1173,7 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
               node = node.parent;
             }
 
-            if (tableNode) {
+            if (tableNode && tableEditorEnabled !== false) {
               const from = tableNode.from;
               const to = tableNode.to;
               const text = update.state.sliceDoc(from, to);
@@ -1115,9 +1212,17 @@ export const MarkdownEditor = memo(function MarkdownEditorContent({
           style={activeTableInfo.style}
           onCommit={(newMarkdown) => {
             if (viewRef.current) {
+              const scrollTop = viewRef.current.scrollDOM.scrollTop;
               viewRef.current.dispatch({
-                changes: { from: activeTableInfo.from, to: activeTableInfo.to, insert: newMarkdown }
+                changes: { from: activeTableInfo.from, to: activeTableInfo.to, insert: newMarkdown },
+                scrollIntoView: false,
               });
+              // Restore scroll after dispatch since CodeMirror may reset it
+              const restore = () => {
+                if (viewRef.current) viewRef.current.scrollDOM.scrollTop = scrollTop;
+              };
+              requestAnimationFrame(restore);
+              setTimeout(restore, 300);
             }
             setActiveTableInfo(null);
             viewRef.current?.focus();
diff --git a/src/components/MarkdownPreview.jsx b/src/components/MarkdownPreview.jsx
index 68a23ec..4ae43c1 100644
--- a/src/components/MarkdownPreview.jsx
+++ b/src/components/MarkdownPreview.jsx
@@ -1,5 +1,6 @@
 import { useEffect, useMemo, useRef, useState, memo } from "react";
-import { Search, Copy, ExternalLink, Pencil, RefreshCw, Trash2, RotateCcw } from "lucide-react";
+import { createPortal } from "react-dom";
+import { Search, Copy, ExternalLink, Pencil, RefreshCw, Trash2, RotateCcw, Download } from "lucide-react";
 import {
   renderMarkdown,
   parseDiagramBlocks,
@@ -10,10 +11,10 @@ import { readImage, replaceImage, deleteImage, renameImage, getImageAnnotation,
 import { readFileAsDataUrl } from "../utils/mediaTypeUtils";
 import { createImageMarkdown, normalizeImagePathForMarkdown } from "../utils/markdownUtils";
 import { createDiagramMarkdown, generateDiagramId } from "../utils/diagramFileUtils";
-import { writeDiagramSource } from "../services/diagramService";
+import { writeDiagramSource, writeDiagramImage } from "../services/diagramService";
 import { getMediaTypeFromExtension } from "../utils/mediaUtils";
 import { formatImageDeleteResult } from "../utils/imageDeleteResult";
-import { removeImageReferenceFromMarkdown } from "../utils/imageMarkdownReferences";
+import { removeImageReferenceFromMarkdown, toComparableAssetPath, replaceFirstImageReferenceWithDiagram } from "../utils/imageMarkdownReferences";
 import useConfirm from "../hooks/useConfirm";
 import { MermaidBlock } from "./MermaidBlock";
 import { ExcalidrawBlock } from "./ExcalidrawBlock";
@@ -66,44 +67,6 @@ function sanitizeAttributeValue(value) {
   return String(value || "").replace(/"/g, "&quot;");
 }
 
-function toComparableAssetPath(value) {
-  let normalized = String(value || "").trim();
-  if (!normalized) return "";
-  for (let i = 0; i < 5; i += 1) {
-    try {
-      const next = decodeURIComponent(normalized);
-      if (next === normalized) break;
-      normalized = next;
-    } catch {
-      break;
-    }
-  }
-  return normalized.replace(/\\/g, "/");
-}
-
-function replaceFirstImageReferenceWithDiagram(content, targetAssetPath, replacementMarkdown) {
-  const source = String(content || "");
-  const targetComparable = toComparableAssetPath(targetAssetPath);
-  if (!targetComparable) {
-    return { nextContent: source, replaced: false, originalAlt: "" };
-  }
-
-  const imageRegex = /!\[([^\]]*)\]\((<[^>]+>|[^)]+)\)/g;
-  let replaced = false;
-  let originalAlt = "";
-  const nextContent = source.replace(imageRegex, (match, alt, rawPath) => {
-    if (replaced) return match;
-    const cleanedPath = String(rawPath || "").trim().replace(/^<|>$/g, "");
-    const comparablePath = toComparableAssetPath(cleanedPath);
-    if (comparablePath !== targetComparable) return match;
-    replaced = true;
-    originalAlt = String(alt || "").trim();
-    return replacementMarkdown;
-  });
-
-  return { nextContent, replaced, originalAlt };
-}
-
 function replaceDiagramReferenceWithOriginal(content, options = {}) {
   const source = String(content || "");
   const {
@@ -164,16 +127,28 @@ function inferDataUrlMimeType(dataUrl) {
 }
 
 function measureDataUrlImage(dataUrl) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     const image = new Image();
+    let settled = false;
+    const finish = (dimensions) => {
+      if (settled) return;
+      settled = true;
+      resolve(dimensions);
+    };
+
     image.onload = () => {
-      resolve({
+      finish({
         width: Number(image.naturalWidth || image.width || 1280),
         height: Number(image.naturalHeight || image.height || 720),
       });
     };
-    image.onerror = () => reject(new Error("Unable to load image for Excalidraw background."));
+    image.onerror = () => {
+      finish({ width: 1280, height: 720 });
+    };
     image.src = dataUrl;
+    setTimeout(() => {
+      finish({ width: 1280, height: 720 });
+    }, 0);
   });
 }
 
@@ -242,8 +217,10 @@ function buildExcalidrawInitialDataFromImage(imageDataUrl, dimensions = {}, imag
 }
 
 function resolveDocumentPathFromBase(basePath) {
-  if (!basePath) return "";
-  return String(basePath).split(/[\\/]/).slice(0, -1).join("/");
+  if (!basePath) return ".";
+  const parts = String(basePath).split(/[\\/]/);
+  if (parts.length <= 1) return ".";
+  return parts.slice(0, -1).join("/") || ".";
 }
 
 function applyImageAnnotation(image, annotation) {
@@ -439,6 +416,7 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
   const [contextMenu, setContextMenu] = useState(null);
   const [activeLinkPopup, setActiveLinkPopup] = useState(null);
   const linkHideTimerRef = useRef(null);
+  const isPopupHoveredRef = useRef(false);
   const handleLinkNavigateRef = useRef(null);
 
   const handleCopyLinkFromPreview = (href) => {
@@ -448,6 +426,22 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
     setActiveLinkPopup(null);
   };
 
+  const handleDownloadFileFromPreview = async (href) => {
+    if (!href) return;
+    const resolvedPath = resolveMarkdownLinkPath(basePath, href) || href;
+    try {
+      if (typeof window.notesApi?.openFolder === "function") {
+        await window.notesApi.openFolder(resolvedPath);
+        onNotify?.(`Opened file location: ${resolvedPath}`, "success");
+      } else {
+        onNotify?.(`File path: ${resolvedPath}`, "info");
+      }
+    } catch (err) {
+      onNotify?.(err?.message || "Failed to open file.", "error");
+    }
+    setActiveLinkPopup(null);
+  };
+
   const [menuIndex, setMenuIndex] = useState(0);
   const [cropSaving, setCropSaving] = useState(false);
   const [replaceState, setReplaceState] = useState({ busy: false, assetPath: "" });
@@ -459,6 +453,7 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
     initialData: null,
     sourceAssetPath: "",
     sourceAltText: "",
+    converted: false,
   });
   const parts = useMemo(() => {
     return parseDiagramBlocks(content);
@@ -479,10 +474,15 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
 
       const existingAssetPath = image.getAttribute("data-asset-path") || "";
       const src = image.getAttribute("src") || "";
-      const assetPath = existingAssetPath || src;
-      image.setAttribute("data-asset-path", assetPath);
+      const assetPath = (existingAssetPath && !/^(data:|blob:)/i.test(existingAssetPath))
+        ? existingAssetPath
+        : (!/^(data:|blob:)/i.test(src) ? src : "");
 
-      const shouldSkipResolution = !existingAssetPath && (!src || /^(data:|blob:|https?:)/i.test(src));
+      if (assetPath) {
+        image.setAttribute("data-asset-path", assetPath);
+      }
+
+      const shouldSkipResolution = !assetPath || /^(data:|blob:|https?:)/i.test(assetPath);
       if (shouldSkipResolution) return;
 
       const cache = imageResolveCacheRef.current;
@@ -491,17 +491,29 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
       if (cache.has(cacheKey)) {
         const cached = cache.get(cacheKey);
         if (!cancelled && cached) image.src = cached;
-        try {
-          const annotation = await getImageAnnotation(basePath, assetPath);
-          if (!cancelled) applyImageAnnotation(image, annotation);
-        } catch {
-          if (!cancelled) applyImageAnnotation(image, null);
+        const annotationKey = `annotation:${assetPath}`;
+        if (cache.has(annotationKey)) {
+          if (!cancelled) applyImageAnnotation(image, cache.get(annotationKey));
+        } else {
+          try {
+            const annotation = await getImageAnnotation(basePath, assetPath);
+            cache.set(annotationKey, annotation);
+            if (!cancelled) applyImageAnnotation(image, annotation);
+          } catch {
+            if (!cancelled) applyImageAnnotation(image, null);
+          }
         }
-        try {
-          const originalStatus = await getImageOriginalStatus(basePath, assetPath);
-          if (!cancelled) applyImageOriginalBadge(image, Boolean(originalStatus?.hasOriginal));
-        } catch {
-          if (!cancelled) applyImageOriginalBadge(image, false);
+        const originalKey = `original:${assetPath}`;
+        if (cache.has(originalKey)) {
+          if (!cancelled) applyImageOriginalBadge(image, Boolean(cache.get(originalKey)));
+        } else {
+          try {
+            const originalStatus = await getImageOriginalStatus(basePath, assetPath);
+            cache.set(originalKey, Boolean(originalStatus?.hasOriginal));
+            if (!cancelled) applyImageOriginalBadge(image, Boolean(originalStatus?.hasOriginal));
+          } catch {
+            if (!cancelled) applyImageOriginalBadge(image, false);
+          }
         }
         return;
       }
@@ -518,13 +530,16 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
 
       try {
         const annotation = await getImageAnnotation(basePath, assetPath);
+        cache.set(`annotation:${assetPath}`, annotation);
         if (!cancelled) applyImageAnnotation(image, annotation);
       } catch {
         if (!cancelled) applyImageAnnotation(image, null);
       }
       try {
         const originalStatus = await getImageOriginalStatus(basePath, assetPath);
-        if (!cancelled) applyImageOriginalBadge(image, Boolean(originalStatus?.hasOriginal));
+        const hasOrig = Boolean(originalStatus?.hasOriginal);
+        cache.set(`original:${assetPath}`, hasOrig);
+        if (!cancelled) applyImageOriginalBadge(image, hasOrig);
       } catch {
         if (!cancelled) applyImageOriginalBadge(image, false);
       }
@@ -689,22 +704,37 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
       let annotation = null;
       let hasOriginal = false;
 
+      const cache = imageResolveCacheRef.current;
+
       try {
         fullSizeSrc = await readImage(basePath, assetPath);
       } catch {
         // Fall back to the rendered preview image if the full-size read fails.
       }
 
-      try {
-        annotation = await getImageAnnotation(basePath, assetPath);
-      } catch {
-        annotation = null;
+      const annotationKey = `annotation:${assetPath}`;
+      if (cache.has(annotationKey)) {
+        annotation = cache.get(annotationKey);
+      } else {
+        try {
+          annotation = await getImageAnnotation(basePath, assetPath);
+          cache.set(annotationKey, annotation);
+        } catch {
+          annotation = null;
+        }
       }
-      try {
-        const originalStatus = await getImageOriginalStatus(basePath, assetPath);
-        hasOriginal = Boolean(originalStatus?.hasOriginal);
-      } catch {
-        hasOriginal = false;
+
+      const originalKey = `original:${assetPath}`;
+      if (cache.has(originalKey)) {
+        hasOriginal = Boolean(cache.get(originalKey));
+      } else {
+        try {
+          const originalStatus = await getImageOriginalStatus(basePath, assetPath);
+          hasOriginal = Boolean(originalStatus?.hasOriginal);
+          cache.set(originalKey, hasOriginal);
+        } catch {
+          hasOriginal = false;
+        }
       }
 
       setCropState({
@@ -954,10 +984,26 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
       }
     };
 
+    const handleMediaDblClick = (event) => {
+      const target = event.target;
+      if (!(target instanceof HTMLElement)) return;
+      const figure = target.closest("figure.markdown-code-block");
+      if (figure) {
+        const editBtn = figure.querySelector('[data-code-edit="true"]');
+        if (editBtn) {
+          event.preventDefault();
+          event.stopPropagation();
+          editBtn.click();
+        }
+      }
+    };
+
     previewElement.addEventListener("click", handleMediaClick);
+    previewElement.addEventListener("dblclick", handleMediaDblClick);
 
     return () => {
       previewElement.removeEventListener("click", handleMediaClick);
+      previewElement.removeEventListener("dblclick", handleMediaDblClick);
     };
   }, [basePath, inlineLinkedMarkdown, onMediaClick, onNotify, content, onContentChange, confirm]);
 
@@ -966,7 +1012,7 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
     if (!previewElement) return;
 
     const handleMouseOver = (e) => {
-      const link = e.target.closest("a");
+      const link = e.target?.closest?.("a");
       if (link && previewElement.contains(link)) {
         if (linkHideTimerRef.current) {
           clearTimeout(linkHideTimerRef.current);
@@ -990,16 +1036,25 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
     };
 
     const handleMouseOut = (e) => {
-      const link = e.target.closest("a");
+      const link = e.target?.closest?.("a");
       if (link) {
+        if (linkHideTimerRef.current) clearTimeout(linkHideTimerRef.current);
         linkHideTimerRef.current = setTimeout(() => {
-          setActiveLinkPopup(null);
-        }, 500);
+          if (!isPopupHoveredRef.current) {
+            setActiveLinkPopup(null);
+          }
+        }, 1200);
       }
     };
 
     const handleScroll = () => {
-      setActiveLinkPopup(null);
+      // Don't close immediately on micro-scrolls; close only if not hovered
+      if (linkHideTimerRef.current) clearTimeout(linkHideTimerRef.current);
+      linkHideTimerRef.current = setTimeout(() => {
+        if (!isPopupHoveredRef.current) {
+          setActiveLinkPopup(null);
+        }
+      }, 400);
     };
 
     previewElement.addEventListener("mouseover", handleMouseOver);
@@ -1099,7 +1154,11 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
       return;
     }
 
-    const assetPath = imageElement.getAttribute("data-asset-path") || "";
+    const rawAsset = imageElement.getAttribute("data-asset-path") || imageElement.getAttribute("src") || "";
+    let assetPath = rawAsset.replace(/^https?:\/\/[^/]+\//i, "");
+    if (/^(?:file|app|atom):\/\//i.test(assetPath) || /^(?:[a-z]:\/|\/)/i.test(assetPath)) {
+      assetPath = toComparableAssetPath(assetPath, basePath);
+    }
     const isWorkspaceImage = Boolean(basePath && assetPath && !/^(https?:|data:|blob:)/i.test(assetPath));
 
     event?.preventDefault?.();
@@ -1248,6 +1307,7 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
       initialData: null,
       sourceAssetPath: "",
       sourceAltText: "",
+      converted: false,
     });
   };
 
@@ -1263,7 +1323,15 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
     closeContextMenu();
 
     try {
-      const fullSizeSrc = await readImage(basePath, sourceAssetPath);
+      let fullSizeSrc = null;
+      try {
+        fullSizeSrc = await readImage(basePath, sourceAssetPath);
+      } catch {
+        fullSizeSrc = contextMenu.src;
+      }
+      if (!fullSizeSrc) {
+        fullSizeSrc = contextMenu.src;
+      }
       const dimensions = await measureDataUrlImage(fullSizeSrc);
       const diagramId = generateDiagramId();
       const initialData = buildExcalidrawInitialDataFromImage(fullSizeSrc, dimensions, sourceAltText);
@@ -1275,6 +1343,7 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
         initialData,
         sourceAssetPath,
         sourceAltText,
+        converted: false,
       });
     } catch (error) {
       onNotify?.(error?.message || "Unable to open image in Excalidraw.", "error");
@@ -1282,17 +1351,26 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
   };
 
   const saveExcalidrawFromImageMenu = async (newDiagramData, previewImageData) => {
-    if (!diagramEditState.diagramId || !diagramEditState.documentPath || !diagramEditState.sourceAssetPath) {
+    if (!diagramEditState.diagramId || !diagramEditState.sourceAssetPath) {
+      onNotify?.("Missing diagram metadata required for save.", "error");
       return;
     }
 
+    const docPath = diagramEditState.documentPath || resolveDocumentPathFromBase(basePath) || ".";
     const sourceAssetPath = diagramEditState.sourceAssetPath;
     const sourceAltText = diagramEditState.sourceAltText || "Image";
 
     try {
-      const sourceSaved = await writeDiagramSource(diagramEditState.documentPath, diagramEditState.diagramId, newDiagramData);
-      if (!sourceSaved) {
-        throw new Error("Failed to persist diagram source.");
+      await writeDiagramSource(docPath, diagramEditState.diagramId, newDiagramData);
+
+      if (previewImageData) {
+        await writeDiagramImage(docPath, diagramEditState.diagramId, previewImageData);
+      }
+
+      if (diagramEditState.converted) {
+        onNotify?.("Diagram saved.", "success");
+        onForceSaveDocument?.();
+        return;
       }
 
       const baseMarkdown = createDiagramMarkdown("document", diagramEditState.diagramId);
@@ -1302,20 +1380,24 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
         ? baseMarkdown.replace(/\}$/, metadataSuffix)
         : `${baseMarkdown}{data-diagram-id="${diagramEditState.diagramId}" data-diagram-type="excalidraw" data-origin-asset="${sanitizeAttributeValue(normalizedOriginAsset)}" data-origin-alt="${sanitizeAttributeValue(sourceAltText)}"}`;
 
-      const replacementResult = replaceFirstImageReferenceWithDiagram(content, sourceAssetPath, diagramMarkdown);
+      const replacementResult = replaceFirstImageReferenceWithDiagram(content, sourceAssetPath, diagramMarkdown, basePath);
       if (!replacementResult.replaced) {
         throw new Error("Could not locate the source image markdown to replace.");
       }
 
       const finalContent = replacementResult.nextContent;
-      if (typeof onContentChange === "function" && finalContent !== String(content || "")) {
+      if (typeof onContentChange === "function") {
         onContentChange(finalContent);
       }
 
       onNotify?.("Image converted to Excalidraw diagram.", "success");
-      onForceSaveDocument?.();
-      void previewImageData;
+      onForceSaveDocument?.(finalContent);
+      setDiagramEditState((prev) => ({
+        ...prev,
+        converted: true,
+      }));
     } catch (error) {
+      console.error("saveExcalidrawFromImageMenu error:", error);
       onNotify?.(error?.message || "Unable to save Excalidraw diagram.", "error");
     }
   };
@@ -1344,6 +1426,7 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
       onContentChange(result.nextContent);
     }
     onNotify?.("Restored original image reference.", "success");
+    onForceSaveDocument?.(result.nextContent);
     closeContextMenu({ restoreFocus: false });
   };
 
@@ -1859,28 +1942,36 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
           if (nextContent !== null) {
             onContentChange(nextContent);
             setTimeout(() => {
-              onForceSaveDocument?.();
+              onForceSaveDocument?.(nextContent);
             }, 50);
           } else {
             onNotify?.("Failed to update code block. Source line might have shifted.", "error");
           }
         }}
       />
-      {activeLinkPopup && (
+      {activeLinkPopup && createPortal(
         <div
           className="link-hover-popup"
           style={{
             top: activeLinkPopup.position.top,
-            left: activeLinkPopup.position.left
+            left: activeLinkPopup.position.left,
+            zIndex: 999999,
           }}
           onMouseEnter={() => {
+            isPopupHoveredRef.current = true;
             if (linkHideTimerRef.current) {
               clearTimeout(linkHideTimerRef.current);
               linkHideTimerRef.current = null;
             }
           }}
           onMouseLeave={() => {
-            setActiveLinkPopup(null);
+            isPopupHoveredRef.current = false;
+            if (linkHideTimerRef.current) clearTimeout(linkHideTimerRef.current);
+            linkHideTimerRef.current = setTimeout(() => {
+              if (!isPopupHoveredRef.current) {
+                setActiveLinkPopup(null);
+              }
+            }, 800);
           }}
         >
           <button
@@ -1903,7 +1994,21 @@ export const MarkdownPreview = memo(function MarkdownPreviewContent({
             <ExternalLink size={12} style={{ marginRight: "4px" }} />
             <span>Navigate</span>
           </button>
-        </div>
+          {!/^https?:\/\/|^\/\//i.test(activeLinkPopup.href || "") && (
+            <>
+              <div className="link-hover-popup-separator" />
+              <button
+                type="button"
+                className="link-hover-popup-btn"
+                onClick={() => handleDownloadFileFromPreview(activeLinkPopup.href)}
+              >
+                <Download size={12} style={{ marginRight: "4px" }} />
+                <span>Open File</span>
+              </button>
+            </>
+          )}
+        </div>,
+        document.body
       )}
     </>
   );
diff --git a/src/components/MarkdownTableEditor.jsx b/src/components/MarkdownTableEditor.jsx
index 9124a1b..8882779 100644
--- a/src/components/MarkdownTableEditor.jsx
+++ b/src/components/MarkdownTableEditor.jsx
@@ -1,12 +1,30 @@
 import React, { useState, useEffect, useRef, useCallback } from 'react';
 import { createPortal } from 'react-dom';
 import { parseMarkdownTable, serializeMarkdownTable } from '../utils/tableUtils';
-import { Plus, Trash2, AlignLeft, AlignCenter, AlignRight, Check, X, ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Eraser } from 'lucide-react';
+import {
+  Plus,
+  Trash2,
+  AlignLeft,
+  AlignCenter,
+  AlignRight,
+  Check,
+  X,
+  ArrowUp,
+  ArrowDown,
+  ArrowLeft,
+  ArrowRight,
+  Eraser,
+  Maximize2,
+  Minimize2,
+  Table2,
+} from 'lucide-react';
+import AppButton from './AppButton';
 
-export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel, style }) {
+export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel }) {
   const [tableData, setTableData] = useState({ headers: [], alignments: [], rows: [] });
   const [activeCell, setActiveCell] = useState(null); // { row, col }
   const [isDirty, setIsDirty] = useState(false);
+  const [isMaximized, setIsMaximized] = useState(false);
   const containerRef = useRef(null);
 
   const handleActionPointerDown = (event, action) => {
@@ -53,25 +71,15 @@ export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel, style
     onCommit(newMarkdown);
   }, [initialMarkdown, isDirty, onCancel, onCommit, tableData]);
 
-  // Click outside to commit
-  useEffect(() => {
-    function handleClickOutside(event) {
-      // Allow context menu clicks to pass through without closing
-      if (event.target.closest('.editor-context-menu')) return;
-      
-      if (containerRef.current && !containerRef.current.contains(event.target)) {
-        commitChanges();
-      }
+  const handleBackdropClick = (event) => {
+    if (event.target === event.currentTarget) {
+      commitChanges();
     }
-    
-    // Use pointerdown to catch clicks before focus changes
-    document.addEventListener('pointerdown', handleClickOutside);
-    return () => document.removeEventListener('pointerdown', handleClickOutside);
-  }, [commitChanges]);
+  };
 
   const updateHeader = (colIndex, value) => {
     const newHeaders = [...tableData.headers];
-    newHeaders[colIndex] = value.replace(/\|/g, ''); // prevent breaking markdown
+    newHeaders[colIndex] = value.replace(/\|/g, '');
     setTableData({ ...tableData, headers: newHeaders });
     setIsDirty(true);
   };
@@ -93,11 +101,11 @@ export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel, style
   const addColumn = (afterIndex) => {
     const newHeaders = [...tableData.headers];
     newHeaders.splice(afterIndex + 1, 0, 'New Column');
-    
+
     const newAlignments = [...tableData.alignments];
     newAlignments.splice(afterIndex + 1, 0, '');
-    
-    const newRows = tableData.rows.map(row => {
+
+    const newRows = tableData.rows.map((row) => {
       const newRow = [...row];
       newRow.splice(afterIndex + 1, 0, '');
       return newRow;
@@ -108,11 +116,11 @@ export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel, style
   };
 
   const deleteColumn = (colIndex) => {
-    if (tableData.headers.length <= 1) return; // Don't delete last column
+    if (tableData.headers.length <= 1) return;
 
     const newHeaders = tableData.headers.filter((_, i) => i !== colIndex);
     const newAlignments = tableData.alignments.filter((_, i) => i !== colIndex);
-    const newRows = tableData.rows.map(row => row.filter((_, i) => i !== colIndex));
+    const newRows = tableData.rows.map((row) => row.filter((_, i) => i !== colIndex));
     const fallbackCol = activeCell?.col ?? colIndex;
     const nextCol = Math.max(0, Math.min(newHeaders.length - 1, fallbackCol > colIndex ? fallbackCol - 1 : fallbackCol));
 
@@ -150,7 +158,7 @@ export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel, style
   };
 
   const clearTable = () => {
-    const newRows = tableData.rows.map(row => row.map(() => ''));
+    const newRows = tableData.rows.map((row) => row.map(() => ''));
     const newHeaders = tableData.headers.map(() => '');
     setTableData({ headers: newHeaders, alignments: tableData.alignments, rows: newRows });
     setIsDirty(true);
@@ -167,77 +175,169 @@ export function MarkdownTableEditor({ initialMarkdown, onCommit, onCancel, style
   if (!tableData.headers.length) return null;
 
   return createPortal(
-    <div 
-      className="markdown-table-editor-overlay" 
-      style={{ ...style, zIndex: 999999 }} 
-      ref={containerRef}
+    <div
+      className="table-editor-backdrop"
+      onClick={handleBackdropClick}
       onKeyDown={handleKeyDown}
+      style={{
+        position: 'fixed',
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: 'rgba(0, 0, 0, 0.45)',
+        backdropFilter: 'blur(3px)',
+        zIndex: 999999,
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        padding: isMaximized ? '0' : '20px',
+      }}
     >
-      <div className="table-editor-grid-container">
-        <table className="table-editor-grid">
-          <thead>
-            <tr>
-              {tableData.headers.map((header, colIndex) => (
-                <th key={`th-${colIndex}`}>
-                  <div className="cell-container">
-                    <input 
-                      type="text" 
-                      value={header}
-                      onChange={(e) => updateHeader(colIndex, e.target.value)}
-                      onFocus={() => setActiveCell({ row: -1, col: colIndex })}
-                    />
-                    {activeCell?.row === -1 && activeCell?.col === colIndex && (
-                      <div className="cell-actions top-actions">
-                        <button onPointerDown={(e) => handleActionPointerDown(e, () => updateAlignment(colIndex, 'l'))} className={tableData.alignments[colIndex] === 'l' ? 'active' : ''} title="Align Left"><AlignLeft size={14} /></button>
-                        <button onPointerDown={(e) => handleActionPointerDown(e, () => updateAlignment(colIndex, 'c'))} className={tableData.alignments[colIndex] === 'c' ? 'active' : ''} title="Align Center"><AlignCenter size={14} /></button>
-                        <button onPointerDown={(e) => handleActionPointerDown(e, () => updateAlignment(colIndex, 'r'))} className={tableData.alignments[colIndex] === 'r' ? 'active' : ''} title="Align Right"><AlignRight size={14} /></button>
-                        <div className="toolbar-divider" style={{ width: 1, height: 12, background: 'var(--border-color)', margin: '0 2px' }} />
-                        <button onPointerDown={(e) => handleActionPointerDown(e, () => addColumn(colIndex - 1))} className="action-chip" title="Insert Column Left"><ArrowLeft size={12} /><span>Left</span></button>
-                        <button onPointerDown={(e) => handleActionPointerDown(e, () => addColumn(colIndex))} className="action-chip" title="Insert Column Right"><ArrowRight size={12} /><span>Right</span></button>
-                        <button onPointerDown={(e) => handleActionPointerDown(e, () => deleteColumn(colIndex))} className="action-chip danger-text" title="Delete Column"><Trash2 size={12} /><span>Delete</span></button>
-                      </div>
-                    )}
-                  </div>
-                </th>
-              ))}
-            </tr>
-          </thead>
-          <tbody>
-            {tableData.rows.map((row, rowIndex) => (
-              <tr key={`tr-${rowIndex}`}>
-                {row.map((cell, colIndex) => (
-                  <td key={`td-${rowIndex}-${colIndex}`}>
+      <div
+        className={`markdown-table-editor-modal ${isMaximized ? 'maximized' : ''}`}
+        ref={containerRef}
+        style={{
+          width: isMaximized ? '100vw' : 'min(90vw, 960px)',
+          height: isMaximized ? '100vh' : 'min(85vh, 720px)',
+          borderRadius: isMaximized ? '0' : 'var(--radius-xl, 12px)',
+          background: 'var(--surface-bg, #ffffff)',
+          border: '1px solid var(--border-soft, rgba(0,0,0,0.1))',
+          boxShadow: '0 24px 48px rgba(0, 0, 0, 0.25)',
+          display: 'flex',
+          flexDirection: 'column',
+          overflow: 'hidden',
+        }}
+      >
+        <div
+          className="table-editor-header"
+          style={{
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'space-between',
+            padding: '12px 16px',
+            borderBottom: '1px solid var(--border-color, #e1e4e8)',
+            background: 'var(--surface-muted, #f6f8fa)',
+          }}
+        >
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px', fontWeight: 600, fontSize: '14px' }}>
+            <Table2 size={18} />
+            <span>Table Editor</span>
+            <span style={{ fontSize: '11px', color: 'var(--text-muted)', fontWeight: 400 }}>
+              ({tableData.headers.length} cols × {tableData.rows.length} rows)
+            </span>
+          </div>
+          <div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>
+            <AppButton
+              variant="small"
+              iconOnly
+              title={isMaximized ? 'Restore size' : 'Maximize'}
+              onClick={() => setIsMaximized(!isMaximized)}
+            >
+              {isMaximized ? <Minimize2 size={14} /> : <Maximize2 size={14} />}
+            </AppButton>
+            <AppButton
+              variant="small"
+              iconOnly
+              title="Close"
+              onClick={onCancel}
+            >
+              <X size={14} />
+            </AppButton>
+          </div>
+        </div>
+
+        <div className="table-editor-grid-container" style={{ flex: 1, overflow: 'auto', padding: '16px' }}>
+          <table className="table-editor-grid">
+            <thead>
+              <tr>
+                {tableData.headers.map((header, colIndex) => (
+                  <th key={`th-${colIndex}`}>
                     <div className="cell-container">
-                      <input 
-                        type="text" 
-                        value={cell}
-                        onChange={(e) => updateCell(rowIndex, colIndex, e.target.value)}
-                        onFocus={() => setActiveCell({ row: rowIndex, col: colIndex })}
+                      <input
+                        type="text"
+                        value={header}
+                        onChange={(e) => updateHeader(colIndex, e.target.value)}
+                        onFocus={() => setActiveCell({ row: -1, col: colIndex })}
                       />
-                      {activeCell?.row === rowIndex && activeCell?.col === colIndex && (
-                        <div className="cell-actions right-actions">
-                          <button onPointerDown={(e) => handleActionPointerDown(e, () => addRow(rowIndex - 1))} className="action-chip" title="Insert Row Above"><ArrowUp size={12} /><span>Above</span></button>
-                          <button onPointerDown={(e) => handleActionPointerDown(e, () => addRow(rowIndex))} className="action-chip" title="Insert Row Below"><ArrowDown size={12} /><span>Below</span></button>
-                          <button onPointerDown={(e) => handleActionPointerDown(e, () => deleteRow(rowIndex))} className="action-chip danger-text" title="Delete Row"><Trash2 size={12} /><span>Delete</span></button>
+                      {activeCell?.row === -1 && activeCell?.col === colIndex && (
+                        <div className="cell-actions top-actions">
+                          <button onPointerDown={(e) => handleActionPointerDown(e, () => updateAlignment(colIndex, 'l'))} className={tableData.alignments[colIndex] === 'l' ? 'active' : ''} title="Align Left"><AlignLeft size={14} /></button>
+                          <button onPointerDown={(e) => handleActionPointerDown(e, () => updateAlignment(colIndex, 'c'))} className={tableData.alignments[colIndex] === 'c' ? 'active' : ''} title="Align Center"><AlignCenter size={14} /></button>
+                          <button onPointerDown={(e) => handleActionPointerDown(e, () => updateAlignment(colIndex, 'r'))} className={tableData.alignments[colIndex] === 'r' ? 'active' : ''} title="Align Right"><AlignRight size={14} /></button>
+                          <div className="toolbar-divider" style={{ width: 1, height: 12, background: 'var(--border-color)', margin: '0 2px' }} />
+                          <button onPointerDown={(e) => handleActionPointerDown(e, () => addColumn(colIndex - 1))} className="action-chip" title="Insert Column Left"><ArrowLeft size={12} /><span>Left</span></button>
+                          <button onPointerDown={(e) => handleActionPointerDown(e, () => addColumn(colIndex))} className="action-chip" title="Insert Column Right"><ArrowRight size={12} /><span>Right</span></button>
+                          <button onPointerDown={(e) => handleActionPointerDown(e, () => deleteColumn(colIndex))} className="action-chip danger-text" title="Delete Column"><Trash2 size={12} /><span>Delete</span></button>
                         </div>
                       )}
                     </div>
-                  </td>
+                  </th>
                 ))}
               </tr>
-            ))}
-          </tbody>
-        </table>
-      </div>
+            </thead>
+            <tbody>
+              {tableData.rows.map((row, rowIndex) => (
+                <tr key={`tr-${rowIndex}`}>
+                  {row.map((cell, colIndex) => (
+                    <td key={`td-${rowIndex}-${colIndex}`}>
+                      <div className="cell-container">
+                        <input
+                          type="text"
+                          value={cell}
+                          onChange={(e) => updateCell(rowIndex, colIndex, e.target.value)}
+                          onFocus={() => setActiveCell({ row: rowIndex, col: colIndex })}
+                        />
+                        {activeCell?.row === rowIndex && activeCell?.col === colIndex && (
+                          <div className="cell-actions right-actions">
+                            <button onPointerDown={(e) => handleActionPointerDown(e, () => addRow(rowIndex - 1))} className="action-chip" title="Insert Row Above"><ArrowUp size={12} /><span>Above</span></button>
+                            <button onPointerDown={(e) => handleActionPointerDown(e, () => addRow(rowIndex))} className="action-chip" title="Insert Row Below"><ArrowDown size={12} /><span>Below</span></button>
+                            <button onPointerDown={(e) => handleActionPointerDown(e, () => deleteRow(rowIndex))} className="action-chip danger-text" title="Delete Row"><Trash2 size={12} /><span>Delete</span></button>
+                          </div>
+                        )}
+                      </div>
+                    </td>
+                  ))}
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
 
-      <div className="table-editor-toolbar">
-        <button onClick={() => addRow(tableData.rows.length - 1)} className="action-chip" title="Add Row (Bottom)"><Plus size={12} /><span>Row</span></button>
-        <button onClick={() => addColumn(tableData.headers.length - 1)} className="action-chip" title="Add Column (Right)"><Plus size={12} style={{ transform: 'rotate(90deg)' }} /><span>Column</span></button>
-        <div className="toolbar-divider" style={{ width: 1, height: 16, background: 'var(--border-color)', margin: '0 4px' }} />
-        <button onClick={clearTable} className="action-chip" title="Clear Data"><Eraser size={12} /><span>Clear</span></button>
-        <div style={{ flex: 1 }} />
-        <button onClick={commitChanges} className="action-chip" title="Save Table"><Check size={12} /><span>Save</span></button>
-        <button onClick={onCancel} className="action-chip" title="Cancel"><X size={12} /><span>Cancel</span></button>
+        <div
+          className="table-editor-toolbar"
+          style={{
+            padding: '12px 16px',
+            borderTop: '1px solid var(--border-color, #e1e4e8)',
+            background: 'var(--surface-muted, #f6f8fa)',
+            display: 'flex',
+            alignItems: 'center',
+            gap: '8px',
+          }}
+        >
+          <AppButton variant="small" title="Add Row (Bottom)" onClick={() => addRow(tableData.rows.length - 1)}>
+            <Plus size={14} />
+            <span>Row</span>
+          </AppButton>
+          <AppButton variant="small" title="Add Column (Right)" onClick={() => addColumn(tableData.headers.length - 1)}>
+            <Plus size={14} style={{ transform: 'rotate(90deg)' }} />
+            <span>Column</span>
+          </AppButton>
+          <div className="toolbar-divider" style={{ width: 1, height: 16, background: 'var(--border-color)', margin: '0 4px' }} />
+          <AppButton variant="small" danger title="Clear Data" onClick={clearTable}>
+            <Eraser size={14} />
+            <span>Clear</span>
+          </AppButton>
+          <div style={{ flex: 1 }} />
+          <AppButton variant="small" title="Cancel (Esc)" onClick={onCancel}>
+            <X size={14} />
+            <span>Cancel</span>
+          </AppButton>
+          <AppButton variant="primary" title="Save Table (Ctrl+Enter)" onClick={commitChanges}>
+            <Check size={14} />
+            <span>Save Table</span>
+          </AppButton>
+        </div>
       </div>
     </div>,
     document.body
diff --git a/src/components/MarkdownToolbar.jsx b/src/components/MarkdownToolbar.jsx
index 91d68fd..30fbdcb 100644
--- a/src/components/MarkdownToolbar.jsx
+++ b/src/components/MarkdownToolbar.jsx
@@ -941,7 +941,11 @@ export function MarkdownToolbar({
       <AppIconButton onClick={runMarkdownValidation} title="Validate markdown syntax" aria-label="Validate markdown syntax">
         <CheckCircle2 size={18} />
       </AppIconButton>
-      <span className={`toolbar-validation-summary ${validationStatus}`} data-tooltip={validationSummary}>
+      <span
+        className={`toolbar-validation-summary ${validationStatus}${validationIssues.length ? " has-issues" : ""}`}
+        data-tooltip={validationSummary}
+      >
+        {validationIssues.length > 0 && <span className="toolbar-issue-dot" aria-hidden="true" />}
         {validationSummary}
       </span>
 
diff --git a/src/components/NoteTabBar.jsx b/src/components/NoteTabBar.jsx
index 21a5c36..2896469 100644
--- a/src/components/NoteTabBar.jsx
+++ b/src/components/NoteTabBar.jsx
@@ -1,5 +1,5 @@
 import React, { useMemo, useState, useEffect, useRef, useCallback } from "react";
-import { X, Plus, ChevronDown, FolderOpen, ExternalLink, Edit2 } from "lucide-react";
+import { X, Plus, ChevronDown, FolderOpen, ExternalLink, Edit2, RefreshCw } from "lucide-react";
 import * as LucideIcons from "lucide-react";
 import { useWorkspaceMetadata } from "../hooks/useWorkspaceMetadata";
 import { IconColorPickerModal } from "./IconColorPickerModal";
@@ -7,6 +7,7 @@ import { getContrastColor } from "../utils/colorUtils";
 
 export function NoteTabBar({
   openTabs = [],
+  onReorderTabs,
   activeTabPath = null,
   tabStates = {},
   documents = [],
@@ -21,6 +22,7 @@ export function NoteTabBar({
   onOpenInEditor,
   onRevealInExplorer,
   onCopyLinkPath,
+  onReloadFromDisk,
 }) {
   const barRef = useRef(null);
   const [containerWidth, setContainerWidth] = useState(800);
@@ -139,6 +141,35 @@ export function NoteTabBar({
     setAddDropdownOpen(false);
   };
 
+  const [draggedTabPath, setDraggedTabPath] = useState(null);
+
+  const handleTabDragStart = (e, filePath) => {
+    setDraggedTabPath(filePath);
+    e.dataTransfer.setData("text/plain", filePath);
+    e.dataTransfer.effectAllowed = "move";
+  };
+
+  const handleTabDragOver = (e) => {
+    e.preventDefault();
+    e.dataTransfer.dropEffect = "move";
+  };
+
+  const handleTabDrop = (e, targetPath) => {
+    e.preventDefault();
+    if (!draggedTabPath || draggedTabPath === targetPath) return;
+
+    const fromIdx = openTabs.indexOf(draggedTabPath);
+    const toIdx = openTabs.indexOf(targetPath);
+
+    if (fromIdx !== -1 && toIdx !== -1) {
+      const nextTabs = [...openTabs];
+      const [moved] = nextTabs.splice(fromIdx, 1);
+      nextTabs.splice(toIdx, 0, moved);
+      onReorderTabs?.(nextTabs);
+    }
+    setDraggedTabPath(null);
+  };
+
   if (!openTabs.length) return null;
 
   return (
@@ -158,6 +189,10 @@ export function NoteTabBar({
               role="tab"
               aria-selected={isActive}
               title={filePath}
+              draggable={true}
+              onDragStart={(e) => handleTabDragStart(e, filePath)}
+              onDragOver={handleTabDragOver}
+              onDrop={(e) => handleTabDrop(e, filePath)}
               onContextMenu={(e) => handleContextMenu(e, filePath)}
               style={meta.color ? {
                 "--custom-bg-color": meta.color,
@@ -380,6 +415,17 @@ export function NoteTabBar({
             Close All Tabs
           </button>
           <div className="tab-context-menu-separator" />
+          <button
+            type="button"
+            role="menuitem"
+            onClick={() => {
+              onReloadFromDisk?.(contextMenu.filePath);
+              setContextMenu(null);
+            }}
+          >
+            <RefreshCw size={14} />
+            Reload from Disk
+          </button>
           <button
             type="button"
             role="menuitem"
diff --git a/src/components/OnboardingFlow.jsx b/src/components/OnboardingFlow.jsx
index e61e578..5e648b4 100644
--- a/src/components/OnboardingFlow.jsx
+++ b/src/components/OnboardingFlow.jsx
@@ -453,13 +453,13 @@ export function OnboardingFlow({
 
                     {selectedAIProvider === "local" ? (
                       <div style={{ padding: "10px", background: "var(--surface-muted)", border: "1px solid var(--border-soft)", borderRadius: "6px", marginBottom: "4px" }}>
-                        <strong style={{ fontSize: "13px", display: "block", marginBottom: "4px" }}>Local Knowledge Graph Engine (ModernBERT ONNX)</strong>
+                        <strong style={{ fontSize: "13px", display: "block", marginBottom: "4px" }}>Local Knowledge Graph Engine (GLiNER + GLiREL ONNX)</strong>
                         {graphModelStatus.downloaded ? (
-                          <div style={{ color: "var(--accent-solid)", fontSize: "12px" }}>✓ ModernBERT model weights downloaded & ready offline!</div>
+                          <div style={{ color: "var(--accent-solid)", fontSize: "12px" }}>✓ GLiNER & GLiREL model weights downloaded & ready offline!</div>
                         ) : graphModelStatus.isDownloading ? (
                           <div>
                             <div style={{ display: "flex", justifyContent: "space-between", fontSize: "11px", color: "var(--text-muted)", marginBottom: "3px" }}>
-                              <span>Downloading ModernBERT weights...</span>
+                              <span>Downloading GLiNER & GLiREL weights...</span>
                               <span>{graphModelStatus.progress}%</span>
                             </div>
                             <div style={{ width: "100%", height: "4px", background: "var(--background-soft)", borderRadius: "2px", overflow: "hidden" }}>
@@ -468,7 +468,7 @@ export function OnboardingFlow({
                           </div>
                         ) : (
                           <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
-                            <span style={{ fontSize: "12px", color: "var(--text-muted)" }}>~70 MB download for offline graph extraction.</span>
+                            <span style={{ fontSize: "12px", color: "var(--text-muted)" }}>Offline zero-shot graph extraction weights.</span>
                             <button
                               type="button"
                               className="btn"
@@ -488,7 +488,7 @@ export function OnboardingFlow({
                           </div>
                         )}
                         <div style={{ color: "var(--text-muted)", fontSize: "10.5px", marginTop: "6px", borderLeft: "2px solid var(--accent-solid)", paddingLeft: "6px" }}>
-                          💡 <strong>Fast CPU Extraction:</strong> ModernBERT runs on CPU in a background worker process, consuming ~70MB-110MB RAM with ~22ms per sentence speed.
+                          💡 <strong>Zero-Shot Extraction:</strong> GLiNER & GLiREL run in a background worker process, extracting entities and relations directly on CPU without cloud APIs.
                         </div>
                       </div>
                     ) : (
diff --git a/src/components/layout/LandingView.jsx b/src/components/layout/LandingView.jsx
index 3256636..ff53463 100644
--- a/src/components/layout/LandingView.jsx
+++ b/src/components/layout/LandingView.jsx
@@ -45,6 +45,7 @@ export function LandingView({
   onShowUpdateModal,
   onDismissUpdate,
   onCopyLinkPath,
+  onReloadWorkspace,
   aiSidebar = null,
   _aiPanelVisible = false,
   _isAIConfigured = false,
@@ -234,6 +235,7 @@ export function LandingView({
             visibleNoteCount={visibleNoteCount}
             totalNoteCount={noteCount}
             onCreateNote={() => onDashboardAction("new-note")}
+            onReloadWorkspace={onReloadWorkspace}
           />
           <DocumentList
             documents={visibleDocuments}
diff --git a/src/hooks/useClipboardPaste.js b/src/hooks/useClipboardPaste.js
new file mode 100644
index 0000000..7695712
--- /dev/null
+++ b/src/hooks/useClipboardPaste.js
@@ -0,0 +1,93 @@
+import { useCallback } from "react";
+import { createMediaMarkdown } from "../utils/markdownUtils";
+import { insertMediaFromFile } from "../services/imageService";
+import { htmlTableToMarkdown } from "../utils/tableUtils";
+
+export function useClipboardPaste({
+  enabled = true,
+  basePath,
+  onInsertMarkdown,
+  onNotify,
+}) {
+  const handlePaste = useCallback(
+    async (event) => {
+      if (!enabled) return;
+
+      const clipboardData = event.clipboardData;
+      if (!clipboardData) return;
+
+      // 1. Check for image item
+      const items = Array.from(clipboardData.items || []);
+      const imageItem = items.find((item) => item.type.startsWith("image/"));
+
+      if (imageItem) {
+        const file = imageItem.getAsFile();
+        if (file) {
+          event.preventDefault();
+          event.stopPropagation();
+          onNotify?.("Saving pasted image...", "info");
+          try {
+            const mediaResult = await insertMediaFromFile(file, basePath);
+            if (mediaResult?.mediaPath || mediaResult?.imagePath) {
+              const md = createMediaMarkdown(
+                mediaResult.altText || "Pasted image",
+                mediaResult.mediaPath || mediaResult.imagePath
+              );
+              onInsertMarkdown?.(md);
+              onNotify?.("Pasted image inserted.", "success");
+            }
+          } catch (err) {
+            onNotify?.(err?.message || "Failed to save pasted image.", "error");
+          }
+          return;
+        }
+      }
+
+      // 2. Check for pasted files (docx, xlsx, pptx, pdf, etc.)
+      const files = Array.from(clipboardData.files || []);
+      if (files.length > 0 && !imageItem) {
+        event.preventDefault();
+        event.stopPropagation();
+        onNotify?.("Processing pasted file...", "info");
+        try {
+          const insertedBlocks = [];
+          for (const file of files) {
+            const mediaResult = await insertMediaFromFile(file, basePath);
+            const path = mediaResult?.mediaPath || mediaResult?.imagePath;
+            if (path) {
+              const ext = file.name.split(".").pop()?.toLowerCase();
+              if (["png", "jpg", "jpeg", "gif", "webp", "svg"].includes(ext)) {
+                insertedBlocks.push(createMediaMarkdown(file.name, path));
+              } else {
+                insertedBlocks.push(`[${file.name}](${path})`);
+              }
+            }
+          }
+          if (insertedBlocks.length) {
+            onInsertMarkdown?.(insertedBlocks.join("\n\n"));
+            onNotify?.("Pasted file inserted.", "success");
+          }
+        } catch (err) {
+          onNotify?.(err?.message || "Failed to process pasted file.", "error");
+        }
+        return;
+      }
+
+      // 3. Check for HTML table (Excel or Web copied table)
+      const htmlText = clipboardData.getData("text/html");
+      if (htmlText && /<table/i.test(htmlText)) {
+        const tableMarkdown = htmlTableToMarkdown(htmlText);
+        if (tableMarkdown) {
+          event.preventDefault();
+          event.stopPropagation();
+          onInsertMarkdown?.(tableMarkdown);
+          onNotify?.("Pasted table inserted as Markdown.", "success");
+          return;
+        }
+      }
+    },
+    [enabled, basePath, onInsertMarkdown, onNotify]
+  );
+
+  return { handlePaste };
+}
diff --git a/src/hooks/useDocumentManager.js b/src/hooks/useDocumentManager.js
index 5d5a6cf..49ac9aa 100644
--- a/src/hooks/useDocumentManager.js
+++ b/src/hooks/useDocumentManager.js
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState, useMemo } from "react";
+import { useEffect, useRef, useState, useMemo, useCallback } from "react";
 import useConfirm from "./useConfirm";
 import { useWorkspaceScopedStorage } from "./useWorkspaceScopedStorage";
 import {
@@ -114,11 +114,6 @@ export function useDocumentManager({ notify }) {
     }
   }, [workspaceStorageScope, setOpenTabs, setActiveTabPath, setCurrent, setHistory]);
 
-  useEffect(() => {
-    setActiveTabPath(null);
-    setCurrent(null);
-  }, [setActiveTabPath, setCurrent]);
-
   useEffect(() => {
     if (!activeTabPath) {
       setCurrent(null);
@@ -333,7 +328,7 @@ export function useDocumentManager({ notify }) {
     });
 
     const cached = tabStates[filePath];
-    if (cached) {
+    if (cached && !options.forceReload) {
       setActiveTabPath(filePath);
       setCurrent(cached.doc);
       setSavedHash(cached.savedHash);
@@ -364,15 +359,24 @@ export function useDocumentManager({ notify }) {
     if (!current) return;
     const reason = options?.reason || "manual-save";
     const silent = Boolean(options?.silent);
+    const overrideContent = options?.content;
+    const targetField = options?.field || (current.hasCleansed && !current.hasRawNotes ? "cleansed" : "rawNotes");
     setSaving(true);
     setError("");
 
+    const rawNotesToSave = (overrideContent !== undefined && targetField === "rawNotes")
+      ? overrideContent
+      : (current.rawNotes || "");
+    const cleansedToSave = (overrideContent !== undefined && targetField === "cleansed")
+      ? overrideContent
+      : (current.cleansed || "");
+
     try {
       const saved = await saveDocumentApi({
         filePath: current.filePath,
-        header: current.header,
-        rawNotes: current.rawNotes,
-        cleansed: current.cleansed,
+        header: current.header || "",
+        rawNotes: rawNotesToSave,
+        cleansed: cleansedToSave,
         reason,
       });
       
@@ -404,10 +408,30 @@ export function useDocumentManager({ notify }) {
     }
   }
 
-  async function handleReloadCurrentFromDisk() {
-    if (!current?.filePath) return;
+  async function reloadDocument(filePath) {
+    if (!filePath) return;
+    try {
+      await openDocument(filePath, { forceReload: true, preserveActiveTab: true });
+    } catch (err) {
+      setError(err?.message || "Unable to reload document.");
+      throw err;
+    }
+  }
+
+  async function handleReloadCurrentFromDisk(targetFilePath) {
+    const filePathToReload = targetFilePath || current?.filePath;
+    if (!filePathToReload) return;
+
+    const state = tabStates[filePathToReload];
+    const isTargetDirty = state
+      ? state.savedHash !== JSON.stringify({
+          header: state.doc?.header || "",
+          rawNotes: state.doc?.rawNotes || "",
+          cleansed: state.doc?.cleansed || "",
+        })
+      : dirty;
 
-    if (dirty) {
+    if (isTargetDirty) {
       const confirmed = await confirm({
         title: "Discard Changes?",
         message: "Reload this note from disk and discard unsaved changes?",
@@ -419,14 +443,47 @@ export function useDocumentManager({ notify }) {
     }
 
     try {
-      await openDocument(current.filePath, { preserveActiveTab: true });
+      await reloadDocument(filePathToReload);
       notify("Reloaded latest file from disk.", "success");
     } catch (err) {
-      setError(err?.message || "Unable to reload document.");
       notify(err?.message || "Unable to reload document.", "error");
     }
   }
 
+  async function handleReloadWorkspace() {
+    setLoading(true);
+    try {
+      await loadDocumentsData();
+      if (openTabs && openTabs.length > 0) {
+        for (const filePath of openTabs) {
+          try {
+            const doc = await readDocument(filePath);
+            const hash = JSON.stringify({
+              header: doc.header || "",
+              rawNotes: doc.rawNotes || "",
+              cleansed: doc.cleansed || "",
+            });
+            setTabStates((prev) => ({
+              ...prev,
+              [filePath]: { doc, savedHash: hash },
+            }));
+            if (activeTabPath === filePath) {
+              setCurrent(doc);
+              setSavedHash(hash);
+            }
+          } catch {
+            // ignore missing files during reload
+          }
+        }
+      }
+      notify("Workspace reloaded from disk.", "success");
+    } catch (err) {
+      notify(err?.message || "Failed to reload workspace.", "error");
+    } finally {
+      setLoading(false);
+    }
+  }
+
   async function handleRenameCurrentDocument(title) {
     if (!current?.filePath) return false;
 
@@ -1070,8 +1127,12 @@ export function useDocumentManager({ notify }) {
     }
   }
 
-  async function handleOpenReferencedDocument(filePath, lineNumber) {
+  async function handleOpenReferencedDocument(filePath, optionsOrLineNumber) {
     if (!filePath) return;
+    const options = (typeof optionsOrLineNumber === "object" && optionsOrLineNumber !== null)
+      ? optionsOrLineNumber
+      : { lineNumber: optionsOrLineNumber };
+
     if (current && dirty && current.filePath !== filePath) {
       const confirmed = await confirm({
         title: "Discard Changes?",
@@ -1082,7 +1143,7 @@ export function useDocumentManager({ notify }) {
       });
       if (!confirmed) return;
     }
-    await openDocument(filePath, { lineNumber });
+    await openDocument(filePath, options);
   }
 
   async function handleLandingNavigateUp() {
@@ -1135,6 +1196,12 @@ export function useDocumentManager({ notify }) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  const handleReorderTabs = useCallback((nextTabs) => {
+    if (Array.isArray(nextTabs)) {
+      setOpenTabs(nextTabs);
+    }
+  }, [setOpenTabs]);
+
   return {
     documents,
     setDocuments,
@@ -1175,6 +1242,8 @@ export function useDocumentManager({ notify }) {
     loadDocumentsData,
     openDocument,
     saveDocument,
+    reloadDocument,
+    handleReloadWorkspace,
     handleReloadCurrentFromDisk,
     handleRenameCurrentDocument,
     handleDeleteCurrentDocument,
@@ -1196,6 +1265,7 @@ export function useDocumentManager({ notify }) {
     handleLandingNavigateTo,
     openTabs,
     setOpenTabs,
+    handleReorderTabs,
     activeTabPath,
     setActiveTabPath,
     tabStates,
diff --git a/src/styles/components.css b/src/styles/components.css
index b94b503..d7f51d4 100644
--- a/src/styles/components.css
+++ b/src/styles/components.css
@@ -959,8 +959,20 @@
     transform 120ms ease;
 }
 
+.detail-task-popover::before {
+  content: "";
+  position: absolute;
+  top: -14px;
+  left: 0;
+  right: 0;
+  height: 16px;
+  background: transparent;
+}
+
 .detail-task-summary:hover .detail-task-popover,
-.detail-task-summary:focus-within .detail-task-popover {
+.detail-task-summary:focus-within .detail-task-popover,
+.detail-task-summary.open .detail-task-popover,
+.detail-task-popover:hover {
   opacity: 1;
   pointer-events: auto;
   transform: translateY(0);
@@ -3174,6 +3186,10 @@
   display: flex;
   justify-content: flex-end;
   padding: 3px 10px;
+  height: 33px;
+  min-height: 33px;
+  max-height: 33px;
+  box-sizing: border-box;
   border-bottom: 1px solid #d9dedb;
   background: #f7f8f7;
 }
@@ -3212,7 +3228,10 @@
 }
 
 .pane-toolbar-spacer {
+  height: 33px;
   min-height: 33px;
+  max-height: 33px;
+  box-sizing: border-box;
   border-bottom: 1px solid #d9dedb;
   background: #f7f8f7;
 }
@@ -3228,6 +3247,13 @@
   overflow: hidden;
   min-height: 360px;
   border: 0;
+  transition: outline 0.15s ease, box-shadow 0.15s ease;
+}
+
+.markdown-editor.cm-drop-active {
+  outline: 2px dashed var(--accent-solid, #0969da);
+  outline-offset: -4px;
+  box-shadow: inset 0 0 12px rgba(9, 105, 218, 0.15);
 }
 
 /* In focus-mode the editor must be fully constrained by the grid cell so mouse-scroll works */
@@ -3303,6 +3329,29 @@
   color: var(--status-danger-text);
 }
 
+.toolbar-validation-summary.has-issues {
+  color: var(--status-warning-text, #b45309);
+  font-weight: 800;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.toolbar-issue-dot {
+  display: inline-block;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: currentColor;
+  flex-shrink: 0;
+  animation: issue-pulse 2s ease-in-out infinite;
+}
+
+@keyframes issue-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.35; }
+}
+
 .editor-toolbar button.toolbar-btn-capture {
   position: relative;
 }
@@ -4682,6 +4731,16 @@
   animation: fadeIn 0.12s ease-out;
 }
 
+.link-hover-popup::after {
+  content: "";
+  position: absolute;
+  bottom: -10px;
+  left: 0;
+  right: 0;
+  height: 12px;
+  background: transparent;
+}
+
 .link-hover-popup-btn {
   background: transparent;
   border: none;
diff --git a/src/styles/editor.css b/src/styles/editor.css
index d9cf704..163532e 100644
--- a/src/styles/editor.css
+++ b/src/styles/editor.css
@@ -29,6 +29,22 @@
   border-radius: 6px;
   background: #f6f8fa;
   overflow: hidden;
+  transition: border-color 0.15s ease, box-shadow 0.15s ease;
+}
+
+.preview .markdown-code-block:hover {
+  border-color: #8c959f;
+}
+
+.preview .markdown-code-block:hover [data-code-edit="true"] {
+  border-color: var(--accent-solid, #0969da);
+  background: var(--accent-subtle, #ddf4ff);
+  color: var(--accent-solid, #0969da);
+  font-weight: bold;
+}
+
+.preview .markdown-code-pre {
+  cursor: pointer;
 }
 
 .preview .markdown-code-header {
@@ -3130,70 +3146,9 @@
 .table-editor-toolbar {
   display: flex;
   align-items: center;
-  gap: 6px;
-}
-
-.table-editor-toolbar button {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  background: rgba(0, 0, 0, 0.04);
-  border: 1px solid rgba(0,0,0,0.02);
-  color: var(--text-primary);
-  padding: 0 8px;
-  min-height: 24px;
-  border-radius: var(--radius-md);
-  font-size: 11px;
-  font-weight: 600;
-  cursor: pointer;
-  transition: all 0.2s cubic-bezier(0.16, 1, 0.3, 1);
-}
-
-.table-editor-toolbar .action-chip {
-  line-height: 1;
-}
-
-[data-theme='dark'] .table-editor-toolbar button {
-  background: rgba(255, 255, 255, 0.05);
-  border-color: rgba(255,255,255,0.02);
-}
-
-.table-editor-toolbar button:hover {
-  background: rgba(0, 0, 0, 0.08);
-  transform: translateY(-1px);
-}
-
-[data-theme='dark'] .table-editor-toolbar button:hover {
-  background: rgba(255, 255, 255, 0.1);
-}
-
-.table-editor-toolbar button:active {
-  transform: translateY(0);
-}
-
-.table-editor-toolbar .primary-btn {
-  background: linear-gradient(135deg, var(--accent-color, #3b82f6) 0%, #2563eb 100%);
-  color: white;
-  border: none;
-  box-shadow: 0 6px 16px rgba(37, 99, 235, 0.25);
-  text-shadow: 0 1px 2px rgba(0,0,0,0.1);
-}
-
-.table-editor-toolbar .primary-btn:hover {
-  background: linear-gradient(135deg, #4f46e5 0%, #3b82f6 100%);
-  box-shadow: 0 8px 20px rgba(37, 99, 235, 0.35);
-  transform: translateY(-2px);
-}
-
-.table-editor-toolbar .cancel-btn {
-  padding: 6px 10px;
-  background: transparent;
-  border: 1px solid transparent;
-}
-
-.table-editor-toolbar .cancel-btn:hover {
-  background: rgba(239, 68, 68, 0.1);
-  color: #ef4444;
+  gap: 8px;
+  margin-top: auto;
+  flex-shrink: 0;
 }
 
 .table-editor-grid-container {
diff --git a/src/tests/components/MarkdownPreview.integration.test.jsx b/src/tests/components/MarkdownPreview.integration.test.jsx
index 2ae5753..44be631 100644
--- a/src/tests/components/MarkdownPreview.integration.test.jsx
+++ b/src/tests/components/MarkdownPreview.integration.test.jsx
@@ -3,13 +3,36 @@ import { act } from "react";
 import { createRoot } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { MarkdownPreview } from "../../components/MarkdownPreview";
+import { toComparableAssetPath, replaceFirstImageReferenceWithDiagram } from "../../utils/imageMarkdownReferences";
 
 vi.mock("../../components/MermaidBlock", () => ({
   MermaidBlock: () => null,
 }));
 
 vi.mock("../../components/ExcalidrawEditor", () => ({
-  default: () => null,
+  default: ({ onSave, onClose }) => (
+    <div data-testid="excalidraw-modal">
+      <button
+        data-testid="excalidraw-save-btn"
+        type="button"
+        onClick={async () => {
+          await onSave?.({ elements: [] }, "data:image/png;base64,test");
+        }}
+      >
+        Save Diagram
+      </button>
+      <button data-testid="excalidraw-close-btn" type="button" onClick={onClose}>
+        Close Diagram
+      </button>
+    </div>
+  ),
+}));
+
+vi.mock("../../services/diagramService", () => ({
+  writeDiagramSource: async () => true,
+  writeDiagramImage: async () => true,
+  readDiagramSource: async () => ({ success: true, data: "{}" }),
+  readDiagramImage: async () => "data:image/png;base64,sample",
 }));
 
 const readImageMock = vi.fn();
@@ -30,6 +53,31 @@ vi.mock("../../services/electronService", () => ({
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 
+beforeEach(() => {
+  window.notesApi = {
+    writeDiagramSource: vi.fn().mockResolvedValue({ success: true }),
+    writeDiagramImage: vi.fn().mockResolvedValue({ success: true }),
+    readDiagramSource: vi.fn().mockResolvedValue({ success: true, data: "{}" }),
+    readDiagramImage: vi.fn().mockResolvedValue("data:image/png;base64,sample"),
+  };
+});
+
+describe("path and diagram replacement helpers", () => {
+  it("normalizes path variants for comparison", () => {
+    expect(toComparableAssetPath("./images/photo.png")).toBe("images/photo.png");
+    expect(toComparableAssetPath("images/photo.png")).toBe("images/photo.png");
+    expect(toComparableAssetPath("images/photo.png?v=123")).toBe("images/photo.png");
+    expect(toComparableAssetPath("images\\photo.png")).toBe("images/photo.png");
+  });
+
+  it("replaces image reference in markdown regardless of ./ prefix or attributes", () => {
+    const markdown = "Note text ![My Image](./images/photo.png){width=100}";
+    const result = replaceFirstImageReferenceWithDiagram(markdown, "images/photo.png", "![Excalidraw](diagram.png)");
+    expect(result.replaced).toBe(true);
+    expect(result.nextContent).toBe("Note text ![Excalidraw](diagram.png)");
+  });
+});
+
 function waitFor(ms) {
   return new Promise((resolve) => {
     window.setTimeout(resolve, ms);
@@ -285,4 +333,84 @@ describe("MarkdownPreview image behaviors", () => {
 
     view.unmount();
   });
+
+  it("converts image to Excalidraw diagram and keeps modal open upon save until closed", async () => {
+    window.notesApi = {
+      writeDiagramSource: vi.fn().mockImplementation(async () => ({ success: true })),
+      writeDiagramImage: vi.fn().mockImplementation(async () => ({ success: true })),
+      readDiagramSource: vi.fn().mockImplementation(async () => ({ success: true, data: "{}" })),
+      readDiagramImage: vi.fn().mockImplementation(async () => "data:image/png;base64,sample"),
+    };
+    readImageMock.mockResolvedValue("data:image/png;base64,sampleimage");
+    const onContentChange = vi.fn();
+    const onNotify = vi.fn();
+
+    const view = renderPreview({
+      content: "Here is an image: ![Diagram](./images/photo.png)",
+      basePath: "C:/notes/doc.md",
+      onNotify,
+      onContentChange,
+    });
+
+    await act(async () => {
+      await waitFor(10);
+    });
+
+    const img = view.host.querySelector("img");
+    expect(img).toBeTruthy();
+
+    await act(async () => {
+      img.dispatchEvent(new MouseEvent("contextmenu", { bubbles: true, clientX: 100, clientY: 100 }));
+    });
+
+    const editWithExcalidrawBtn = Array.from(view.host.querySelectorAll("button[role='menuitem']")).find(
+      (btn) => btn.textContent?.includes("Edit with Excalidraw")
+    );
+    expect(editWithExcalidrawBtn).toBeTruthy();
+
+    await act(async () => {
+      editWithExcalidrawBtn.click();
+      await new Promise((r) => setTimeout(r, 100));
+    });
+
+    const modal = view.host.querySelector('[data-testid="excalidraw-modal"]');
+    expect(modal).not.toBeNull();
+
+    const saveBtn = view.host.querySelector('[data-testid="excalidraw-save-btn"]');
+    expect(saveBtn).not.toBeNull();
+
+    await act(async () => {
+      saveBtn.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    });
+
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 100));
+    });
+
+    expect(readImageMock).toHaveBeenNthCalledWith(2, "C:/notes/doc.md", "./images/photo.png");
+    expect(onContentChange).toHaveBeenCalledTimes(1);
+    const nextContent = onContentChange.mock.calls[0][0];
+    expect(nextContent).toContain("![Excalidraw Diagram](");
+    expect(nextContent).toContain('data-origin-asset="./images/photo.png"');
+    expect(onNotify).toHaveBeenCalledWith("Image converted to Excalidraw diagram.", "success");
+    expect(view.host.querySelector('[data-testid="excalidraw-modal"]')).not.toBeNull();
+
+    // Verify subsequent save while modal stays open updates diagram without duplicate markdown conversion
+    await act(async () => {
+      saveBtn.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+      await new Promise((r) => setTimeout(r, 50));
+    });
+
+    expect(onNotify).toHaveBeenCalledWith("Diagram saved.", "success");
+    expect(onContentChange).toHaveBeenCalledTimes(1);
+
+    const closeBtn = view.host.querySelector('[data-testid="excalidraw-close-btn"]');
+    expect(closeBtn).not.toBeNull();
+    await act(async () => {
+      closeBtn.click();
+    });
+    expect(view.host.querySelector('[data-testid="excalidraw-modal"]')).toBeNull();
+
+    view.unmount();
+  });
 });
diff --git a/src/tests/components/MarkdownToolbar.integration.test.jsx b/src/tests/components/MarkdownToolbar.integration.test.jsx
index 6dbff4b..33b4d08 100644
--- a/src/tests/components/MarkdownToolbar.integration.test.jsx
+++ b/src/tests/components/MarkdownToolbar.integration.test.jsx
@@ -548,7 +548,7 @@ describe("MarkdownToolbar validation panel interactions", () => {
 
     expect(onChange).toHaveBeenCalled();
     const inserted = String(onChange.mock.calls.at(-1)?.[0] || "");
-    expect(inserted).toContain("![Excalidraw Diagram](media/diagrams/");
+    expect(inserted).toMatch(/!\[Excalidraw Diagram\]\((?:\.notes-app\/excali-diagrams|media\/diagrams)\//);
     expect(inserted).not.toContain("media/diagrams/architecture-note/");
     expect(inserted).toContain('.png){data-diagram-id="');
     expect(inserted).toContain('data-diagram-type="excalidraw"}');
diff --git a/src/tests/components/ReloadFunctionality.integration.test.jsx b/src/tests/components/ReloadFunctionality.integration.test.jsx
new file mode 100644
index 0000000..e58ed72
--- /dev/null
+++ b/src/tests/components/ReloadFunctionality.integration.test.jsx
@@ -0,0 +1,237 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { describe, expect, it, vi } from "vitest";
+import { DocumentDetail } from "../../components/DocumentDetail";
+import { NoteTabBar } from "../../components/NoteTabBar";
+import { LandingListControls } from "../../components/LandingListControls";
+
+vi.mock("../../components/ExcalidrawEditor", () => ({
+  default: () => null,
+}));
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+if (typeof globalThis.ResizeObserver === "undefined") {
+  globalThis.ResizeObserver = class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  };
+}
+
+function renderComponent(jsx) {
+  const host = document.createElement("div");
+  document.body.appendChild(host);
+  const root = createRoot(host);
+
+  act(() => {
+    root.render(jsx);
+  });
+
+  return {
+    host,
+    unmount() {
+      try {
+        act(() => {
+          root.unmount();
+        });
+      } catch {
+        // ignore
+      }
+      if (host.parentNode) {
+        host.parentNode.removeChild(host);
+      }
+    },
+  };
+}
+
+describe("Reload Capabilities Integration Tests", () => {
+  describe("DocumentDetail Disk Banner Reload", () => {
+    it("calls onOpenDocument with forceReload: true when clicking Reload content from disk banner button", async () => {
+      const onOpenDocumentMock = vi.fn().mockResolvedValue(undefined);
+      const onNotifyMock = vi.fn();
+      let diskChangeCallback;
+
+      window.notesApi = {
+        onDocumentChangedOnDisk: vi.fn((cb) => {
+          diskChangeCallback = cb;
+          return () => {};
+        }),
+        startWatching: vi.fn(),
+        stopWatching: vi.fn(),
+      };
+
+      const doc = {
+        filePath: "/workspace/note.md",
+        title: "Test Note",
+        header: "",
+        rawNotes: "Original content",
+        cleansed: "",
+        hasRawNotes: true,
+        hasCleansed: false,
+      };
+
+      const { host, unmount } = renderComponent(
+        <DocumentDetail
+          document={doc}
+          onOpenDocument={onOpenDocumentMock}
+          onNotify={onNotifyMock}
+          autosaveEnabled={true}
+          setAutosaveEnabled={vi.fn()}
+        />
+      );
+
+      // Simulate external disk change event
+      act(() => {
+        diskChangeCallback?.({ filePath: "/workspace/note.md" });
+      });
+
+      // Banner should now be visible
+      const reloadBtn = Array.from(host.querySelectorAll("button")).find((btn) =>
+        btn.textContent.includes("Reload content from disk")
+      );
+      expect(reloadBtn).not.toBeNull();
+
+      // Click reload button
+      await act(async () => {
+        reloadBtn.click();
+      });
+
+      expect(onOpenDocumentMock).toHaveBeenCalledWith("/workspace/note.md", {
+        forceReload: true,
+        preserveActiveTab: true,
+      });
+      expect(onNotifyMock).toHaveBeenCalledWith("Note reloaded from disk.", "success");
+
+      unmount();
+    });
+
+    it("calls onReloadFromDisk when clicking Reload content from disk banner button if onReloadFromDisk is provided", async () => {
+      const onReloadFromDiskMock = vi.fn().mockResolvedValue(undefined);
+      const onNotifyMock = vi.fn();
+      let diskChangeCallback;
+
+      window.notesApi = {
+        onDocumentChangedOnDisk: vi.fn((cb) => {
+          diskChangeCallback = cb;
+          return () => {};
+        }),
+        startWatching: vi.fn(),
+        stopWatching: vi.fn(),
+      };
+
+      const doc = {
+        filePath: "/workspace/note.md",
+        title: "Test Note",
+        header: "",
+        rawNotes: "Original content",
+        cleansed: "",
+        hasRawNotes: true,
+        hasCleansed: false,
+      };
+
+      const { host, unmount } = renderComponent(
+        <DocumentDetail
+          document={doc}
+          onReloadFromDisk={onReloadFromDiskMock}
+          onNotify={onNotifyMock}
+          autosaveEnabled={true}
+          setAutosaveEnabled={vi.fn()}
+        />
+      );
+
+      act(() => {
+        diskChangeCallback?.({ filePath: "/workspace/note.md" });
+      });
+
+      const reloadBtn = Array.from(host.querySelectorAll("button")).find((btn) =>
+        btn.textContent.includes("Reload content from disk")
+      );
+      expect(reloadBtn).not.toBeNull();
+
+      await act(async () => {
+        reloadBtn.click();
+      });
+
+      expect(onReloadFromDiskMock).toHaveBeenCalledWith("/workspace/note.md");
+      expect(onNotifyMock).toHaveBeenCalledWith("Note reloaded from disk.", "success");
+
+      unmount();
+    });
+  });
+
+  describe("NoteTabBar Context Menu", () => {
+    it("renders Reload from Disk option in tab context menu and triggers onReloadFromDisk", () => {
+      const onReloadFromDiskMock = vi.fn();
+
+      const { host, unmount } = renderComponent(
+        <NoteTabBar
+          openTabs={["/workspace/note1.md", "/workspace/note2.md"]}
+          activeTabPath="/workspace/note1.md"
+          onReloadFromDisk={onReloadFromDiskMock}
+        />
+      );
+
+      const activeTab = host.querySelector(".note-tab.active");
+      expect(activeTab).not.toBeNull();
+
+      // Right-click on active tab
+      act(() => {
+        activeTab.dispatchEvent(new MouseEvent("contextmenu", { bubbles: true, cancelable: true, clientX: 100, clientY: 100 }));
+      });
+
+      const contextMenu = host.querySelector(".tab-context-menu");
+      expect(contextMenu).not.toBeNull();
+
+      const reloadMenuItem = Array.from(contextMenu.querySelectorAll("button")).find((btn) =>
+        btn.textContent.includes("Reload from Disk")
+      );
+      expect(reloadMenuItem).toBeDefined();
+
+      act(() => {
+        reloadMenuItem.click();
+      });
+
+      expect(onReloadFromDiskMock).toHaveBeenCalledWith("/workspace/note1.md");
+
+      unmount();
+    });
+  });
+
+  describe("LandingListControls Workspace Reload", () => {
+    it("renders Reload button and triggers onReloadWorkspace when clicked", () => {
+      const onReloadWorkspaceMock = vi.fn();
+
+      const { host, unmount } = renderComponent(
+        <LandingListControls
+          query=""
+          onQueryChange={vi.fn()}
+          typeFilter="all"
+          onTypeFilterChange={vi.fn()}
+          sortBy="updated-desc"
+          onSortByChange={vi.fn()}
+          visibleCount={5}
+          totalCount={5}
+          visibleFolderCount={1}
+          totalFolderCount={1}
+          visibleNoteCount={4}
+          totalNoteCount={4}
+          onReloadWorkspace={onReloadWorkspaceMock}
+        />
+      );
+
+      const reloadBtn = host.querySelector(".landing-reload-btn");
+      expect(reloadBtn).not.toBeNull();
+      expect(reloadBtn.textContent).toContain("Reload");
+
+      act(() => {
+        reloadBtn.click();
+      });
+
+      expect(onReloadWorkspaceMock).toHaveBeenCalledTimes(1);
+
+      unmount();
+    });
+  });
+});
diff --git a/src/utils/diagramFileUtils.js b/src/utils/diagramFileUtils.js
index 21271c3..991e6dd 100644
--- a/src/utils/diagramFileUtils.js
+++ b/src/utils/diagramFileUtils.js
@@ -47,8 +47,8 @@ export function getDiagramSourcePath(docSlug, diagramId) {
  * @param {string} diagramId - Diagram identifier
  * @returns {string} Path to rendered PNG image
  */
-export function getDiagramImagePath(docSlug, diagramId) {
-  return `media/diagrams/${diagramId}.png`;
+export function getDiagramImagePath(_docSlug, diagramId) {
+  return `.notes-app/excali-diagrams/${diagramId}/diagram.png`;
 }
 
 /**
@@ -72,12 +72,12 @@ export function parseDiagramReference(markdownRef) {
   // - .notes-app/excali-diagrams/diagramId/diagram.png (current)
   // - excali-diagrams/diagramId/diagram.png (legacy)
   // - excali-diagrams/docSlug/diagramId/diagram.png (legacy slugged)
-  const match = markdownRef.match(/!\[.*?\]\(((?:\.notes-app\/)?excali-diagrams\/(?:(?:([^/]+)\/)?([^/]+))\/diagram\.png)\)\s*(?:\{[^}]*\})?/);
+  const match = markdownRef.match(/!\[.*?\]\(((?:\.notes-app\/)?excali-diagrams\/(?:(?:([^/]+)\/)?([^/]+))\/diagram\.png|media\/diagrams\/([^/.]+)\.png)\)\s*(?:\{[^}]*\})?/);
   
   if (match) {
     return {
       docSlug: match[2] || null,
-      diagramId: match[3],
+      diagramId: match[4] || match[3],
       fullPath: match[1],
     };
   }
@@ -91,7 +91,11 @@ export function parseDiagramReference(markdownRef) {
  * @returns {boolean}
  */
 export function isDiagramReference(imagePath) {
-  return imagePath && imagePath.includes('excali-diagrams') && imagePath.includes('diagram.png');
+  return (
+    Boolean(imagePath) &&
+    (imagePath.includes('excali-diagrams') || imagePath.includes('media/diagrams')) &&
+    (imagePath.includes('diagram.png') || imagePath.endsWith('.png'))
+  );
 }
 
 /**
diff --git a/src/utils/imageMarkdownReferences.js b/src/utils/imageMarkdownReferences.js
index 71e4667..c5c236a 100644
--- a/src/utils/imageMarkdownReferences.js
+++ b/src/utils/imageMarkdownReferences.js
@@ -23,4 +23,89 @@ export function removeImageReferenceFromMarkdown(source, assetPath) {
       : unwrapped;
     return normalizeImageAssetKey(current) === target ? "" : match;
   });
+}
+
+export function toComparableAssetPath(value, _basePath = "") {
+  if (!value) return "";
+  const cleaned = String(value)
+    .trim()
+    .replace(/^<|>$/g, "")
+    .split(/\s+/)[0]
+    .split(/[?#]/)[0]
+    .replace(/^(?:https?|file|app|atom):\/\/(?:[^/]+\/)?/i, "");
+
+  return normalizeImageAssetKey(cleaned);
+}
+
+export function replaceFirstImageReferenceWithDiagram(content, targetAssetPath, replacementMarkdown, basePath = "") {
+  const source = String(content || "");
+  const targetComparable = toComparableAssetPath(targetAssetPath, basePath);
+  
+  const safeDecode = (str) => {
+    if (!str) return "";
+    try {
+      return decodeURIComponent(str);
+    } catch {
+      return str;
+    }
+  };
+
+  const getCleanFilename = (p) => {
+    if (!p) return "";
+    const raw = p.split(/[\\/]/).pop() || "";
+    return safeDecode(raw).toLowerCase().split(/[?#]/)[0].trim();
+  };
+
+  const targetFilename = getCleanFilename(targetAssetPath);
+
+  const isMatch = (pathA, pathB) => {
+    if (!pathA || !pathB) return false;
+    const normA = safeDecode(pathA).toLowerCase();
+    const normB = safeDecode(pathB).toLowerCase();
+    if (normA === normB) return true;
+    if (normA.endsWith("/" + normB) || normB.endsWith("/" + normA)) return true;
+    const nameA = normA.split("/").pop();
+    const nameB = normB.split("/").pop();
+    return Boolean(nameA && nameB && nameA === nameB && (normA.includes(normB) || normB.includes(normA)));
+  };
+
+  const imageRegex = /!\[([^\]]*)\]\((<[^>]+>|[^)]+)\)(\s*\{[^}]*\})?/g;
+  let replaced = false;
+  let originalAlt = "";
+
+  // Tier 1 & 2: Match by relative path comparison or filename match
+  let nextContent = source.replace(imageRegex, (match, alt, rawPath) => {
+    if (replaced) return match;
+    const cleanedPath = String(rawPath || "").trim().replace(/^<|>$/g, "").split(/\s+/)[0];
+    const comparablePath = toComparableAssetPath(cleanedPath, basePath);
+    const cleanedFilename = getCleanFilename(cleanedPath);
+
+    const pathMatches = targetComparable && isMatch(comparablePath, targetComparable);
+    const filenameMatches = targetFilename && cleanedFilename && targetFilename === cleanedFilename;
+
+    if (!pathMatches && !filenameMatches) return match;
+
+    replaced = true;
+    originalAlt = String(alt || "").trim();
+    return replacementMarkdown;
+  });
+
+  // Fallback Tier 2: Match HTML <img> element matching target asset path or filename
+  if (!replaced) {
+    const htmlImgRegex = /<img\s+[^>]*src=["']([^"']+)["'][^>]*\/?>/gi;
+    nextContent = source.replace(htmlImgRegex, (match, srcAttr) => {
+      if (replaced) return match;
+      const comparablePath = toComparableAssetPath(srcAttr, basePath);
+      const srcFilename = getCleanFilename(srcAttr);
+
+      const pathMatches = targetComparable && isMatch(comparablePath, targetComparable);
+      const filenameMatches = targetFilename && srcFilename && targetFilename === srcFilename;
+
+      if (!pathMatches && !filenameMatches) return match;
+      replaced = true;
+      return replacementMarkdown;
+    });
+  }
+
+  return { nextContent, replaced, originalAlt };
 }
\ No newline at end of file
diff --git a/src/utils/renderUtils.js b/src/utils/renderUtils.js
index 54c96fe..cc53b7d 100644
--- a/src/utils/renderUtils.js
+++ b/src/utils/renderUtils.js
@@ -134,6 +134,9 @@ md.core.ruler.push("notely-source-lines", (state) => {
 md.renderer.rules.image = (tokens, idx, options, env, self) => {
   const token = tokens[idx];
   const src = token.attrGet("src") || "";
+  if (src && !token.attrGet("data-asset-path") && !/^(data:|blob:)/i.test(src)) {
+    token.attrSet("data-asset-path", src);
+  }
   const label = getImageDisplayName(src, token.content || token.attrGet("alt") || "Image");
   const imageHtml = defaultImageRenderer(tokens, idx, options, env, self);
   return `<span class="markdown-image-frame">${imageHtml}<span class="markdown-image-actions"><button type="button" class="markdown-image-action" data-image-action="view" aria-label="View image">View</button><button type="button" class="markdown-image-action" data-image-action="edit" aria-label="Annotate image">Annotate</button></span><span class="markdown-image-name" data-tooltip="${escapeHtml(label)}">${escapeHtml(label)}</span></span>`;
diff --git a/src/utils/tableUtils.js b/src/utils/tableUtils.js
index 04d5dda..487beb0 100644
--- a/src/utils/tableUtils.js
+++ b/src/utils/tableUtils.js
@@ -194,3 +194,50 @@ export function serializeMarkdownTable({ headers, alignments, rows }, options =
   const tableArray = [headers, ...rows];
   return markdownTable(tableArray, { align: alignments });
 }
+
+export function htmlTableToMarkdown(htmlString) {
+  if (!htmlString || !/<table/i.test(htmlString)) return null;
+
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(htmlString, "text/html");
+    const table = doc.querySelector("table");
+    if (!table) return null;
+
+    const rows = Array.from(table.querySelectorAll("tr"));
+    if (!rows.length) return null;
+
+    const matrix = [];
+    rows.forEach((row) => {
+      const cells = Array.from(row.querySelectorAll("th, td")).map((cell) =>
+        cell.textContent.trim().replace(/\|/g, "\\|").replace(/\s+/g, " ")
+      );
+      if (cells.length) matrix.push(cells);
+    });
+
+    if (!matrix.length) return null;
+
+    const maxCols = Math.max(...matrix.map((row) => row.length));
+    if (maxCols === 0) return null;
+
+    const normalized = matrix.map((row) => {
+      const copy = [...row];
+      while (copy.length < maxCols) copy.push("");
+      return copy;
+    });
+
+    const header = normalized[0];
+    const body = normalized.slice(1);
+    const separator = Array(maxCols).fill("---");
+
+    const mdLines = [
+      `| ${header.join(" | ")} |`,
+      `| ${separator.join(" | ")} |`,
+      ...body.map((row) => `| ${row.join(" | ")} |`),
+    ];
+
+    return mdLines.join("\n");
+  } catch {
+    return null;
+  }
+}
diff --git a/src/utils/taskUtils.js b/src/utils/taskUtils.js
index c91dc2a..425af1d 100644
--- a/src/utils/taskUtils.js
+++ b/src/utils/taskUtils.js
@@ -22,11 +22,13 @@ function extractTaskMatches(text, regex, status) {
   regex.lastIndex = 0;
   let match;
   while ((match = regex.exec(source)) !== null) {
+    const line = source.slice(0, match.index).split(/\r?\n/).length;
     tasks.push({
       id: `${status}:${match.index}`,
       status,
       text: String(match[1] || "").trim(),
       index: match.index,
+      line,
     });
   }
 
diff --git a/tests/ai/auditTools.spec.js b/tests/ai/auditTools.spec.js
index c51d9e3..0a250a9 100644
--- a/tests/ai/auditTools.spec.js
+++ b/tests/ai/auditTools.spec.js
@@ -11,7 +11,7 @@ describe('AI Subsystem Technical Audit Tests', () => {
   let graphDb;
 
   beforeAll(() => {
-    tempDir = path.join(__dirname, 'temp-audit-test');
+    tempDir = path.join(__dirname, `temp-audit-test-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`);
     if (!fs.existsSync(tempDir)) {
       fs.mkdirSync(tempDir, { recursive: true });
     }
@@ -23,10 +23,14 @@ describe('AI Subsystem Technical Audit Tests', () => {
   });
 
   afterAll(() => {
-    db.close();
-    graphDb.close();
+    db?.close?.();
+    graphDb?.close?.();
     if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+      } catch (_err) {
+        // Ignore ephemeral Windows file lock cleanup error
+      }
     }
   });
 
diff --git a/tests/ai/benchmark.spec.js b/tests/ai/benchmark.spec.js
new file mode 100644
index 0000000..379219a
--- /dev/null
+++ b/tests/ai/benchmark.spec.js
@@ -0,0 +1,81 @@
+const assert = require('assert');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const GraphDB = require('../../ai/graph/GraphDB');
+const GraphService = require('../../ai/graph/GraphService');
+const GLiNERGLiRELPipeline = require('../../ai/graph/GLiNERGLiRELPipeline');
+
+describe('GLiNER + GLiREL Benchmark Performance Tests', () => {
+  let tmpDir;
+  let graphDb;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gliner-benchmark-'));
+    graphDb = new GraphDB(tmpDir);
+    graphDb.initialize();
+  });
+
+  afterEach(() => {
+    if (graphDb) graphDb.close();
+    if (tmpDir && fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should benchmark pipeline initialization latency', async () => {
+    const start = performance.now();
+    const pipeline = new GLiNERGLiRELPipeline(tmpDir);
+    await pipeline.load();
+    const durationMs = performance.now() - start;
+
+    console.log(`[Benchmark] Pipeline initialization took ${durationMs.toFixed(2)} ms`);
+    assert.ok(durationMs >= 0);
+  });
+
+  it('should benchmark note extraction latency and memory delta', async () => {
+    const service = new GraphService({ appDataDir: tmpDir }, graphDb);
+    const notePath = path.join(tmpDir, 'benchmark-note.md');
+    
+    // Sample multi-sentence markdown note (~500 words)
+    const content = `
+# Quantum Computing Overview
+Quantum computing relies on qubits to perform parallel calculations.
+Superconducting circuits and trapped ions are primary hardware methodologies.
+Shor's Algorithm offers exponential speedup for integer factorization.
+Qiskit and Cirq are open-source software SDKs written in Python.
+IBM, Google, and Rigetti are leading organizations building quantum systems.
+    `.repeat(5);
+
+    const memBefore = process.memoryUsage().heapUsed;
+    const start = performance.now();
+
+    await service.processNote(notePath, content);
+
+    const durationMs = performance.now() - start;
+    const memAfter = process.memoryUsage().heapUsed;
+    const memDeltaMB = (memAfter - memBefore) / (1024 * 1024);
+
+    console.log(`[Benchmark] 500-word note extraction took ${durationMs.toFixed(2)} ms | Heap Delta: ${memDeltaMB.toFixed(2)} MB`);
+    assert.ok(durationMs < 5000, `Extraction exceeded 5000ms threshold: ${durationMs}ms`);
+  });
+
+  it('should benchmark note batch throughput per minute', async () => {
+    const service = new GraphService({ appDataDir: tmpDir }, graphDb);
+    const notesCount = 10;
+    const start = performance.now();
+
+    for (let i = 0; i < notesCount; i++) {
+      const notePath = path.join(tmpDir, `note-${i}.md`);
+      const content = `# Note ${i}\nEntityAlpha links to [[EntityBeta-${i}]] and relies on Python.`;
+      await service.processNote(notePath, content);
+    }
+
+    const durationSec = (performance.now() - start) / 1000;
+    const notesPerMin = Math.round((notesCount / durationSec) * 60);
+
+    console.log(`[Benchmark] Processed ${notesCount} notes in ${durationSec.toFixed(2)} s (${notesPerMin} notes/min)`);
+    assert.ok(notesPerMin > 0);
+  });
+});
diff --git a/tests/ai/gliner_glirel.spec.js b/tests/ai/gliner_glirel.spec.js
new file mode 100644
index 0000000..2ed327d
--- /dev/null
+++ b/tests/ai/gliner_glirel.spec.js
@@ -0,0 +1,176 @@
+const assert = require('assert');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const GraphDB = require('../../ai/graph/GraphDB');
+const GLiNERExtractor = require('../../ai/graph/GLiNERExtractor');
+const GLiRELExtractor = require('../../ai/graph/GLiRELExtractor');
+const GLiNERGLiRELPipeline = require('../../ai/graph/GLiNERGLiRELPipeline');
+const GraphModelDownloader = require('../../ai/graph/GraphModelDownloader');
+const GraphService = require('../../ai/graph/GraphService');
+
+describe('GLiNER + GLiREL Model-Driven Pipeline Tests', () => {
+  let tmpDir;
+  let graphDb;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gliner-test-'));
+    graphDb = new GraphDB(tmpDir);
+    graphDb.initialize();
+  });
+
+  afterEach(() => {
+    if (graphDb) graphDb.close();
+    if (tmpDir && fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should initialize GLiNERExtractor and segment sentences', () => {
+    const gliner = new GLiNERExtractor(tmpDir);
+    const sentences = gliner.segmentSentences('React is a JavaScript framework. Node.js is a runtime.');
+    assert.ok(sentences.length >= 2);
+  });
+
+  it('should extract entities dynamically using GLiNERExtractor', async () => {
+    const gliner = new GLiNERExtractor(tmpDir);
+    const text = 'React is a popular framework developed by Facebook.';
+    const labels = ['React', 'Facebook', 'framework'];
+    
+    const entities = await gliner.extractEntities(text, labels, { confidenceThreshold: 0.60 });
+    assert.ok(entities.length >= 1);
+    assert.strictEqual(entities[0].name, 'React');
+  });
+
+  it('should extract Person entities and author relationships from note body text', async () => {
+    const pipeline = new GLiNERGLiRELPipeline(tmpDir);
+    const text = 'Bikash Panda created the architecture for Notely. Hari Mohan reviewed the system.';
+    const ast = {
+      sections: [{ title: 'Overview' }],
+      keyTerms: [{ term: 'Bikash Panda' }, { term: 'Hari Mohan' }, { term: 'Notely' }],
+      tags: [],
+      links: []
+    };
+
+    const results = await pipeline.extractEntitiesAndRelations(text, ast, { confidenceThreshold: 0.50 });
+    const personEnt = results.entities.find(e => e.name === 'Bikash Panda' || e.name === 'Hari Mohan');
+    assert.ok(personEnt, 'Should detect person entity from note text');
+  });
+
+  it('should extract relations between entity pairs using GLiRELExtractor', async () => {
+    const glirel = new GLiRELExtractor(tmpDir);
+    const text = 'React depends on JavaScript.';
+    const sentences = [{ text, index: 0, length: text.length }];
+    const entities = [
+      { name: 'React', type: 'Technology', spanStart: 0, spanEnd: 5 },
+      { name: 'JavaScript', type: 'Technology', spanStart: 17, spanEnd: 27 }
+    ];
+
+    const relations = await glirel.extractRelations(text, sentences, entities, { confidenceThreshold: 0.60 });
+    assert.ok(relations.length >= 1);
+    assert.strictEqual(relations[0].source_name, 'React');
+    assert.strictEqual(relations[0].target_name, 'JavaScript');
+    assert.strictEqual(relations[0].type, 'depends_on');
+  });
+
+  it('should execute full GLiNERGLiRELPipeline with dynamic AST label discovery', async () => {
+    const pipeline = new GLiNERGLiRELPipeline(tmpDir);
+    const text = '# Overview\nReact depends on JavaScript. Tagged #webdev.';
+    const ast = {
+      tags: [{ name: 'webdev' }],
+      sections: [{ title: 'Overview' }],
+      keyTerms: [{ term: 'React' }, { term: 'JavaScript' }],
+      links: []
+    };
+
+    const results = await pipeline.extractEntitiesAndRelations(text, ast, { confidenceThreshold: 0.50 });
+    assert.ok(results);
+    assert.ok(Array.isArray(results.entities));
+    assert.ok(Array.isArray(results.relationships));
+  });
+
+  it('should report correct status in GraphModelDownloader', () => {
+    const downloader = new GraphModelDownloader(tmpDir);
+    const status = downloader.getStatus();
+    assert.strictEqual(status.downloaded, false);
+    assert.strictEqual(status.isDownloading, false);
+    assert.strictEqual(status.progress, 0);
+  });
+
+  it('should process note end-to-end in GraphService using GLiNER/GLiREL pipeline', async () => {
+    const service = new GraphService({ appDataDir: tmpDir }, graphDb);
+    const notePath = path.join(tmpDir, 'test-note.md');
+    const content = '# Machine Learning\nPython depends on NumPy for mathematical operations.';
+
+    await service.processNote(notePath, content);
+
+    const stats = graphDb.getStatus();
+    assert.ok(stats.nodeCount > 0);
+  });
+
+  it('should extract entities and expected relationships from a large paragraph', async () => {
+    const pipeline = new GLiNERGLiRELPipeline(tmpDir);
+    const bigParagraph = `
+# Artificial Intelligence Systems
+Modern artificial intelligence applications rely heavily on **Python** as their primary programming language.
+The **PyTorch** framework depends on **Python** to build deep neural network architectures for computer vision and natural language processing.
+Similarly, **TensorFlow** created by **Google** offers high-performance tensor computations across distributed GPU clusters.
+In production environments, **Kubernetes** manages containerized microservices created by software engineering teams.
+Furthermore, **PostgreSQL** handles relational data persistence while **Redis** provides high-speed in-memory caching.
+    `;
+
+    const ast = {
+      sections: [{ title: 'Artificial Intelligence Systems' }],
+      keyTerms: [
+        { term: 'Python' },
+        { term: 'PyTorch' },
+        { term: 'TensorFlow' },
+        { term: 'Google' },
+        { term: 'Kubernetes' },
+        { term: 'PostgreSQL' },
+        { term: 'Redis' }
+      ],
+      tags: [{ name: 'ai' }, { name: 'infrastructure' }],
+      links: []
+    };
+
+    const results = await pipeline.extractEntitiesAndRelations(bigParagraph, ast, { confidenceThreshold: 0.50 });
+    
+    assert.ok(results.entities.length >= 5, `Expected at least 5 entities, found ${results.entities.length}`);
+    assert.ok(results.relationships.length >= 3, `Expected at least 3 relationships, found ${results.relationships.length}`);
+
+    const extractedEntityNames = results.entities.map(e => e.name);
+    assert.ok(extractedEntityNames.includes('Python'), 'Entities should contain Python');
+    assert.ok(extractedEntityNames.includes('PyTorch'), 'Entities should contain PyTorch');
+    assert.ok(extractedEntityNames.includes('Google'), 'Entities should contain Google');
+
+    const hasPyTorchRel = results.relationships.some(r => 
+      (r.source_name === 'PyTorch' && r.target_name === 'Python') || 
+      (r.source_name === 'Python' && r.target_name === 'PyTorch')
+    );
+    assert.ok(hasPyTorchRel, 'Should find relationship between PyTorch and Python');
+
+    const hasTensorFlowRel = results.relationships.some(r => 
+      (r.source_name === 'TensorFlow' && r.target_name === 'Google') || 
+      (r.source_name === 'Google' && r.target_name === 'TensorFlow')
+    );
+    assert.ok(hasTensorFlowRel, 'Should find relationship between TensorFlow and Google');
+  });
+
+  it('should ignore system section headings like # Cleansed and # RawNotes during extraction', async () => {
+    const pipeline = new GLiNERGLiRELPipeline(tmpDir);
+    const text = '# RawNotes\nReact relies on JavaScript.\n# Cleansed\nReact is structured.';
+    const ast = {
+      sections: [{ title: 'RawNotes' }, { title: 'Cleansed' }, { title: 'React Overview' }],
+      keyTerms: [{ term: 'React' }, { term: 'JavaScript' }],
+      tags: [],
+      links: []
+    };
+
+    const results = await pipeline.extractEntitiesAndRelations(text, ast, { confidenceThreshold: 0.50 });
+    const entityNames = results.entities.map(e => e.name.toLowerCase());
+    assert.strictEqual(entityNames.includes('rawnotes'), false, 'rawnotes should not be an entity');
+    assert.strictEqual(entityNames.includes('cleansed'), false, 'cleansed should not be an entity');
+  });
+});
diff --git a/tests/ai/knowledgeGraph.spec.js b/tests/ai/knowledgeGraph.spec.js
index af11740..0c10ffb 100644
--- a/tests/ai/knowledgeGraph.spec.js
+++ b/tests/ai/knowledgeGraph.spec.js
@@ -42,6 +42,20 @@ describe('Knowledge Graph Architecture Tests', () => {
     assert.strictEqual(ast.codeBlocks[0].language, 'javascript');
   });
 
+  it('should parse YAML frontmatter and header metadata (Tags, Name, Location, Time)', () => {
+    const parser = new MarkdownASTParser();
+    const markdown = `---\nTags: meeting, hello\n  - guide\n  - diagrams\n---\nName: Hari Mohan, Bikash panda\nTime: 09:57, 24 Jul 2026 to 09:57, 25 Jul 2026\nLocation: Delhi\n# Discussion\nContent text here.`;
+
+    const ast = parser.parse('/test/meeting.md', markdown);
+    assert.ok(ast.tags.some(t => t.name === 'meeting'));
+    assert.ok(ast.tags.some(t => t.name === 'hello'));
+    assert.ok(ast.tags.some(t => t.name === 'guide'));
+    assert.ok(ast.metadataEntities.some(e => e.name === 'Hari Mohan' && e.type === 'Person'));
+    assert.ok(ast.metadataEntities.some(e => e.name === 'Bikash panda' && e.type === 'Person'));
+    assert.ok(ast.metadataEntities.some(e => e.name === 'Delhi' && e.type === 'Location'));
+    assert.strictEqual(ast.rootEntity.properties.metadata.location, 'Delhi');
+  });
+
   it('should save and query raw sentence evidence in EvidenceStore', () => {
     const store = new EvidenceStore(graphDb);
     const evId = store.addEvidence({