diff --git a/apps/desktop/electron-vite.config.ts b/apps/desktop/electron-vite.config.ts
index fc03c0c..94b5467 100644
--- a/apps/desktop/electron-vite.config.ts
+++ b/apps/desktop/electron-vite.config.ts
@@ -33,6 +33,20 @@ export default defineConfig({
   },
   renderer: {
     plugins: [react()],
+    // Pre-bundle all CodeMirror packages together to avoid multiple instances of @codemirror/state
+    // See: https://codemirror.net/docs/guide/#bundling
+    optimizeDeps: {
+      include: [
+        '@codemirror/state',
+        '@codemirror/view',
+        '@codemirror/autocomplete',
+        '@codemirror/commands',
+        '@codemirror/language',
+        '@codemirror/lang-markdown',
+        '@codemirror/language-data',
+        '@lezer/highlight',
+      ],
+    },
     build: {
       outDir: 'out/renderer',
       rollupOptions: {
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index f5830a4..219686f 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -28,6 +28,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@codemirror/autocomplete": "^6.20.0",
     "@codemirror/commands": "^6.10.1",
     "@codemirror/lang-markdown": "^6.5.0",
     "@codemirror/language": "^6.12.1",
@@ -35,7 +36,11 @@
     "@codemirror/state": "^6.5.3",
     "@codemirror/view": "^6.39.8",
     "@lezer/highlight": "^1.2.3",
+    "@readied/commands": "workspace:*",
     "@readied/core": "workspace:*",
+    "@readied/embeds": "workspace:*",
+    "@readied/tasks": "workspace:*",
+    "@readied/wikilinks": "workspace:*",
     "@readied/licensing": "workspace:*",
     "@readied/product-config": "workspace:*",
     "@readied/storage-core": "workspace:*",
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index 4292bc1..b225b5f 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -414,6 +414,26 @@ function registerIpcHandlers(): void {
     return { ok: true };
   });
 
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Links (Wikilinks / Backlinks)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  // Sync links for a note (call after saving note)
+  ipcMain.handle('links:sync', async (_event, noteId: string, content: string) => {
+    repo.syncLinks(createNoteId(noteId), content);
+    return { ok: true };
+  });
+
+  // Get backlinks (notes that link TO this note)
+  ipcMain.handle('links:backlinks', async (_event, noteId: string) => {
+    return repo.getBacklinks(createNoteId(noteId));
+  });
+
+  // Get outgoing links (notes this note links TO)
+  ipcMain.handle('links:outgoing', async (_event, noteId: string) => {
+    return repo.getOutgoingLinks(createNoteId(noteId));
+  });
+
   // Count notes
   ipcMain.handle('notes:count', async () => {
     // Get all notes to compute counts
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index 8e453e7..040de18 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -140,6 +140,20 @@ export interface TagWithColor {
   color: string | null;
 }
 
+/** Backlink information (notes that link TO a note) */
+export interface BacklinkInfo {
+  noteId: string;
+  noteTitle: string;
+  targetRef: string;
+}
+
+/** Outgoing link information (notes that a note links TO) */
+export interface OutgoingLinkInfo {
+  targetRef: string;
+  targetNoteId: string | null;
+  targetTitle: string | null;
+}
+
 /** Log level types */
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 
@@ -260,6 +274,14 @@ export interface ReadiedAPI {
     /** Get log directory path */
     getLogPath: () => Promise<string | null>;
   };
+  links: {
+    /** Sync links for a note (extracts wikilinks and updates link table) */
+    sync: (noteId: string, content: string) => Promise<{ ok: boolean }>;
+    /** Get backlinks (notes that link TO this note) */
+    getBacklinks: (noteId: string) => Promise<BacklinkInfo[]>;
+    /** Get outgoing links (notes this note links TO) */
+    getOutgoing: (noteId: string) => Promise<OutgoingLinkInfo[]>;
+  };
 }
 
 // Expose the API
@@ -334,6 +356,11 @@ const api: ReadiedAPI = {
     },
     getLogPath: () => ipcRenderer.invoke('log:getPath'),
   },
+  links: {
+    sync: (noteId, content) => ipcRenderer.invoke('links:sync', noteId, content),
+    getBacklinks: noteId => ipcRenderer.invoke('links:backlinks', noteId),
+    getOutgoing: noteId => ipcRenderer.invoke('links:outgoing', noteId),
+  },
 };
 
 contextBridge.exposeInMainWorld('readied', api);
diff --git a/apps/desktop/src/renderer/App.tsx b/apps/desktop/src/renderer/App.tsx
index fea29b6..fe524c5 100644
--- a/apps/desktop/src/renderer/App.tsx
+++ b/apps/desktop/src/renderer/App.tsx
@@ -18,6 +18,7 @@ import {
   useStatusFilter,
 } from './hooks/useNavigation';
 import { useSearchNotes, useNoteMutations } from './hooks/useNotes';
+import { useSyncLinks } from './hooks/useLinks';
 import { useEditorPreferencesStore } from './stores/editorPreferencesStore';
 import { useTagColorsStore } from './stores/tagColorsStore';
 import { usePerformanceMode } from './hooks/usePerformanceMode';
@@ -89,6 +90,9 @@ function NotesApp() {
     unpinNote,
   } = useNoteMutations();
 
+  // Links sync mutation
+  const syncLinks = useSyncLinks();
+
   // Determine which notes to display
   // Both filteredNotes and searchNotesQuery.data have excerpt
   const displayedNotes = debouncedSearch.trim() ? (searchNotesQuery.data ?? []) : filteredNotes;
@@ -152,8 +156,10 @@ function NotesApp() {
       if (!selectedNote) return;
       const updated = await updateNote.mutateAsync({ id: selectedNote.id, content });
       setSelectedNote(updated);
+      // Sync links after save (fire-and-forget, don't block UI)
+      syncLinks.mutate({ noteId: selectedNote.id, content });
     },
-    [selectedNote, updateNote]
+    [selectedNote, updateNote, syncLinks]
   );
 
   // Update note title
@@ -347,6 +353,7 @@ function NotesApp() {
               onDuplicate={selectedNote ? () => handleDuplicateNote(selectedNote.id) : undefined}
               onDelete={selectedNote ? () => handleDeleteNote(selectedNote.id) : undefined}
               onWikilinkClick={handleWikilinkClick}
+              onNavigateToNote={handleSelectNote}
             />
           </Panel>
         </Group>
diff --git a/apps/desktop/src/renderer/components/MarkdownEditor.tsx b/apps/desktop/src/renderer/components/MarkdownEditor.tsx
index eb2dca6..3119a11 100644
--- a/apps/desktop/src/renderer/components/MarkdownEditor.tsx
+++ b/apps/desktop/src/renderer/components/MarkdownEditor.tsx
@@ -2,7 +2,7 @@
  * CodeMirror 6 Markdown Editor
  */
 
-import { useEffect, useRef, useCallback, forwardRef, useImperativeHandle } from 'react';
+import { useEffect, useRef, useCallback, forwardRef, useImperativeHandle, useMemo } from 'react';
 import { EditorState, type Extension } from '@codemirror/state';
 import {
   EditorView,
@@ -37,8 +37,13 @@ import {
   insertHorizontalRule,
   undoChange,
   redoChange,
-} from './editor/toolbar-commands';
-import { wikilinkExtension } from './editor/wikilink-extension';
+} from '@readied/commands';
+import {
+  wikilinkExtension,
+  createWikilinkAutocomplete,
+  setCurrentNoteId,
+  currentNoteIdField,
+} from '@readied/wikilinks';
 
 /** Dark theme matching Readied's design */
 const darkTheme = EditorView.theme(
@@ -87,6 +92,32 @@ const darkTheme = EditorView.theme(
       backgroundColor: 'rgba(94, 234, 212, 0.3)',
       outline: 'none',
     },
+    // Autocomplete tooltip
+    '.cm-tooltip-autocomplete': {
+      backgroundColor: 'rgba(24, 24, 27, 0.98)',
+      backdropFilter: 'blur(12px)',
+      border: '1px solid rgba(255, 255, 255, 0.1)',
+      borderRadius: '8px',
+      boxShadow: '0 8px 32px rgba(0, 0, 0, 0.5)',
+      overflow: 'hidden',
+    },
+    '.cm-tooltip-autocomplete > ul': {
+      fontFamily: "'Inter', -apple-system, sans-serif",
+      fontSize: '13px',
+      maxHeight: '300px',
+    },
+    '.cm-tooltip-autocomplete > ul > li': {
+      padding: '8px 12px',
+      color: '#a1a1aa',
+      cursor: 'pointer',
+    },
+    '.cm-tooltip-autocomplete > ul > li[aria-selected]': {
+      backgroundColor: 'rgba(94, 234, 212, 0.15)',
+      color: '#5eead4',
+    },
+    '.cm-completionLabel': {
+      fontWeight: '500',
+    },
   },
   { dark: true }
 );
@@ -144,6 +175,8 @@ interface MarkdownEditorProps {
   onChange: (content: string) => void;
   placeholder?: string;
   onReady?: () => void;
+  /** Current note ID (for excluding from wikilink autocomplete) */
+  noteId?: string;
 }
 
 /** Imperative handle exposed via ref */
@@ -173,13 +206,33 @@ export interface MarkdownEditorHandle {
 
 export const MarkdownEditor = forwardRef<MarkdownEditorHandle, MarkdownEditorProps>(
   function MarkdownEditor(
-    { initialContent, onChange, placeholder = 'Start writing...', onReady },
+    { initialContent, onChange, placeholder = 'Start writing...', onReady, noteId },
     ref
   ) {
     const containerRef = useRef<HTMLDivElement>(null);
     const viewRef = useRef<EditorView | null>(null);
     const onChangeRef = useRef(onChange);
 
+    // Create wikilink autocomplete extension with injected dependencies
+    const wikilinkAutocomplete = useMemo(
+      () =>
+        createWikilinkAutocomplete({
+          searchNotes: async query => {
+            const notes = await window.readied.notes.search(query, 20);
+            return notes.map(n => ({ id: n.id, title: n.title }));
+          },
+          listNotes: async () => {
+            const notes = await window.readied.notes.list({
+              sortBy: 'updatedAt',
+              sortOrder: 'desc',
+              archived: 'active',
+            });
+            return notes.map(n => ({ id: n.id, title: n.title }));
+          },
+        }),
+      []
+    );
+
     // Expose methods via ref
     useImperativeHandle(ref, () => ({
       focus: () => {
@@ -304,6 +357,9 @@ export const MarkdownEditor = forwardRef<MarkdownEditorHandle, MarkdownEditorPro
         // Wikilink [[note]] highlighting
         wikilinkExtension,
 
+        // Wikilink autocomplete (triggers on [[)
+        wikilinkAutocomplete,
+
         // Dark theme
         darkTheme,
 
@@ -318,7 +374,7 @@ export const MarkdownEditor = forwardRef<MarkdownEditorHandle, MarkdownEditorPro
           }
         }),
       ];
-    }, [placeholder]);
+    }, [placeholder, wikilinkAutocomplete]);
 
     // Initialize editor
     useEffect(() => {
@@ -355,16 +411,36 @@ export const MarkdownEditor = forwardRef<MarkdownEditorHandle, MarkdownEditorPro
 
       const currentContent = view.state.doc.toString();
       if (currentContent !== initialContent) {
+        const { selection } = view.state;
+
         view.dispatch({
           changes: {
             from: 0,
             to: view.state.doc.length,
             insert: initialContent,
           },
+          selection, // Preserve cursor (CodeMirror clamps if invalid)
         });
       }
     }, [initialContent]);
 
+    // Update currentNoteId in editor state (for autocomplete filtering)
+    useEffect(() => {
+      const view = viewRef.current;
+      if (!view) return;
+
+      // Guard: avoid redundant dispatch
+      const current = view.state.field(currentNoteIdField, false);
+      if (current === noteId) return;
+
+      const { selection } = view.state;
+
+      view.dispatch({
+        effects: setCurrentNoteId.of(noteId ?? null),
+        selection, // Preserve cursor position
+      });
+    }, [noteId]);
+
     return <div ref={containerRef} className="markdown-editor" />;
   }
 );
diff --git a/apps/desktop/src/renderer/components/NoteEditor.tsx b/apps/desktop/src/renderer/components/NoteEditor.tsx
index ac5d7a3..dafde9e 100644
--- a/apps/desktop/src/renderer/components/NoteEditor.tsx
+++ b/apps/desktop/src/renderer/components/NoteEditor.tsx
@@ -1,6 +1,6 @@
 import { useRef, useCallback, useState, useEffect, lazy, Suspense } from 'react';
 import { useQueryClient } from '@tanstack/react-query';
-import { FileText, MoreVertical } from 'lucide-react';
+import { FileText, MoreVertical, Link2 } from 'lucide-react';
 import { TitleInput } from './TitleInput';
 import {
   ActionsPanel,
@@ -9,12 +9,14 @@ import {
   FormattingToolbar,
   MarkdownPreview,
 } from './editor';
+import { BacklinksPanel } from './editor/BacklinksPanel';
 import type { MarkdownPreviewHandle, ToolbarVisibility } from './editor';
 import type { MarkdownEditorHandle } from './MarkdownEditor';
 import type { NoteSnapshot, NoteStatus } from '../../preload/index';
 import { useEditorPreferencesStore } from '../stores/editorPreferencesStore';
 import { useScrollSync } from '../hooks/useScrollSync';
 import { noteKeys } from '../hooks/useNotes';
+import { useBacklinks } from '../hooks/useLinks';
 
 // Lazy load the markdown editor for better initial load performance
 const MarkdownEditor = lazy(() =>
@@ -39,6 +41,7 @@ interface NoteEditorProps {
   onDuplicate?: () => void;
   onDelete?: () => void;
   onWikilinkClick?: (target: string) => void;
+  onNavigateToNote?: (noteId: string) => void;
 }
 
 export function NoteEditor({
@@ -50,6 +53,7 @@ export function NoteEditor({
   onDuplicate,
   onDelete,
   onWikilinkClick,
+  onNavigateToNote,
 }: NoteEditorProps) {
   const queryClient = useQueryClient();
   const debounceRef = useRef<NodeJS.Timeout | null>(null);
@@ -67,6 +71,11 @@ export function NoteEditor({
   // Actions panel state
   const [actionsOpen, setActionsOpen] = useState(false);
 
+  // Backlinks panel state
+  const [backlinksOpen, setBacklinksOpen] = useState(false);
+  const { data: backlinks } = useBacklinks(note?.id ?? null);
+  const backlinksCount = backlinks?.length ?? 0;
+
   // Toolbar visibility state (for passing to ActionsPanel)
   const [toolbarVisibility, setToolbarVisibility] = useState<ToolbarVisibility>({
     text: true,
@@ -211,18 +220,30 @@ export function NoteEditor({
 
   return (
     <main className="note-editor" aria-label="Note editor">
-      {/* Title row with actions button */}
+      {/* Title row with actions buttons */}
       <header className="note-editor-header">
         <TitleInput value={note.title} onChange={handleTitleChange} onEnter={handleTitleEnter} />
-        <button
-          type="button"
-          className="note-editor-actions-btn"
-          onClick={() => setActionsOpen(true)}
-          title="More actions"
-          aria-label="Open actions panel"
-        >
-          <MoreVertical size={18} />
-        </button>
+        <div className="note-editor-header-actions">
+          <button
+            type="button"
+            className={`note-editor-actions-btn ${backlinksCount > 0 ? 'has-badge' : ''}`}
+            onClick={() => setBacklinksOpen(true)}
+            title={`Backlinks${backlinksCount > 0 ? ` (${backlinksCount})` : ''}`}
+            aria-label="Open backlinks panel"
+          >
+            <Link2 size={18} />
+            {backlinksCount > 0 && <span className="badge">{backlinksCount}</span>}
+          </button>
+          <button
+            type="button"
+            className="note-editor-actions-btn"
+            onClick={() => setActionsOpen(true)}
+            title="More actions"
+            aria-label="Open actions panel"
+          >
+            <MoreVertical size={18} />
+          </button>
+        </div>
       </header>
       {/* Metadata row: Notebook, Status, Tags */}
       {onMoveToNotebook && onStatusChange && (
@@ -258,6 +279,7 @@ export function NoteEditor({
                 initialContent={note.content}
                 onChange={handleChange}
                 onReady={handleEditorReady}
+                noteId={note.id}
               />
             </Suspense>
           </div>
@@ -296,6 +318,14 @@ export function NoteEditor({
         hiddenFormatting={toolbarVisibility}
         editorRef={editorRef}
       />
+
+      {/* Backlinks Panel */}
+      <BacklinksPanel
+        isOpen={backlinksOpen}
+        onClose={() => setBacklinksOpen(false)}
+        noteId={note.id}
+        onNavigateToNote={onNavigateToNote ?? (() => {})}
+      />
     </main>
   );
 }
diff --git a/apps/desktop/src/renderer/components/editor/BacklinksPanel/BacklinksPanel.module.css b/apps/desktop/src/renderer/components/editor/BacklinksPanel/BacklinksPanel.module.css
new file mode 100644
index 0000000..5f276bd
--- /dev/null
+++ b/apps/desktop/src/renderer/components/editor/BacklinksPanel/BacklinksPanel.module.css
@@ -0,0 +1,239 @@
+/**
+ * BacklinksPanel CSS Module
+ *
+ * Slide-in panel from the right with backlinks list.
+ * Uses portal to avoid stacking context issues.
+ * Matches ActionsPanel styling for consistency.
+ */
+
+/* Backdrop overlay */
+.backdrop {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.4);
+  backdrop-filter: blur(4px);
+  -webkit-backdrop-filter: blur(4px);
+  z-index: 49;
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity var(--transition-normal);
+}
+
+.backdropOpen {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.4);
+  backdrop-filter: blur(4px);
+  -webkit-backdrop-filter: blur(4px);
+  z-index: 49;
+  opacity: 1;
+  pointer-events: auto;
+  transition: opacity var(--transition-normal);
+}
+
+/* Panel container - Glassmorphism */
+.panel {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  width: 300px;
+  background: var(--glass-bg);
+  backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturate));
+  -webkit-backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturate));
+  border-left: 1px solid var(--glass-border);
+  box-shadow: var(--glass-shadow);
+  transform: translateX(100%);
+  transition: transform var(--transition-normal);
+  z-index: 50;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  -webkit-app-region: no-drag;
+}
+
+.panelOpen {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  width: 300px;
+  background: var(--glass-bg);
+  backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturate));
+  -webkit-backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturate));
+  border-left: 1px solid var(--glass-border);
+  box-shadow: var(--glass-shadow);
+  transform: translateX(0);
+  transition: transform var(--transition-normal);
+  z-index: 50;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  -webkit-app-region: no-drag;
+}
+
+/* Header */
+.header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px;
+  border-bottom: 1px solid var(--border-subtle);
+  flex-shrink: 0;
+}
+
+.title {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0;
+}
+
+.count {
+  font-size: 12px;
+  font-weight: 500;
+  padding: 2px 8px;
+  border-radius: 10px;
+  background: var(--accent-muted);
+  color: var(--accent);
+}
+
+.closeBtn {
+  width: 32px;
+  height: 32px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: transparent;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition: background var(--transition-fast), color var(--transition-fast);
+  -webkit-app-region: no-drag;
+}
+
+.closeBtn:hover {
+  background: var(--bg-elevated);
+  color: var(--text-primary);
+}
+
+/* Scrollable content */
+.content {
+  flex: 1;
+  overflow-y: auto;
+  padding: 8px 0;
+}
+
+/* Backlinks list */
+.list {
+  display: flex;
+  flex-direction: column;
+}
+
+/* Backlink item */
+.item {
+  width: 100%;
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 12px 16px;
+  background: transparent;
+  border: none;
+  color: var(--text-secondary);
+  font-size: 13px;
+  cursor: pointer;
+  text-align: left;
+  transition: background var(--transition-fast), color var(--transition-fast);
+}
+
+.item:hover {
+  background: var(--bg-elevated);
+  color: var(--text-primary);
+}
+
+/* Icon container */
+.icon {
+  width: 18px;
+  height: 18px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  margin-top: 2px;
+  color: var(--text-muted);
+}
+
+.item:hover .icon {
+  color: var(--accent);
+}
+
+/* Item content */
+.itemContent {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  min-width: 0;
+}
+
+.itemTitle {
+  font-weight: 500;
+  color: var(--text-primary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.itemRef {
+  font-size: 11px;
+  color: var(--text-muted);
+  font-family: var(--font-mono);
+}
+
+/* Empty state */
+.emptyState {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 48px 24px;
+  text-align: center;
+  gap: 12px;
+}
+
+.emptyIcon {
+  color: var(--text-muted);
+  opacity: 0.5;
+}
+
+.emptyText {
+  font-size: 14px;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.emptyHint {
+  font-size: 12px;
+  color: var(--text-muted);
+  max-width: 200px;
+  line-height: 1.5;
+}
+
+/* Loading spinner */
+.spinner {
+  width: 24px;
+  height: 24px;
+  border: 2px solid var(--border-subtle);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
diff --git a/apps/desktop/src/renderer/components/editor/BacklinksPanel/BacklinksPanel.tsx b/apps/desktop/src/renderer/components/editor/BacklinksPanel/BacklinksPanel.tsx
new file mode 100644
index 0000000..bc42e75
--- /dev/null
+++ b/apps/desktop/src/renderer/components/editor/BacklinksPanel/BacklinksPanel.tsx
@@ -0,0 +1,165 @@
+/**
+ * BacklinksPanel - Shows notes that link to the current note
+ *
+ * Part of PKM features (Personal Knowledge Management).
+ * Displays a slide-in panel from the right with backlinks.
+ */
+
+import { memo, useEffect, useCallback } from 'react';
+import { createPortal } from 'react-dom';
+import { X, Link2, FileText, AlertCircle } from 'lucide-react';
+import { useBacklinks } from '../../../hooks/useLinks';
+import styles from './BacklinksPanel.module.css';
+
+interface BacklinksPanelProps {
+  readonly isOpen: boolean;
+  readonly onClose: () => void;
+  readonly noteId: string | null;
+  readonly onNavigateToNote: (noteId: string) => void;
+}
+
+/**
+ * BacklinksPanel - Slide-in panel showing backlinks
+ *
+ * Features:
+ * - Shows all notes that contain wikilinks to the current note
+ * - Click a backlink to navigate to that note
+ * - Empty state when no backlinks exist
+ */
+export const BacklinksPanel = memo(function BacklinksPanel({
+  isOpen,
+  onClose,
+  noteId,
+  onNavigateToNote,
+}: BacklinksPanelProps) {
+  const { data: backlinks, isLoading, error } = useBacklinks(noteId);
+
+  // Handle ESC key to close
+  useEffect(() => {
+    if (!isOpen) return;
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        onClose();
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [isOpen, onClose]);
+
+  // Set data-overlay-open for blur policy
+  useEffect(() => {
+    document.documentElement.dataset.overlayOpen = isOpen ? 'true' : 'false';
+    return () => {
+      document.documentElement.dataset.overlayOpen = 'false';
+    };
+  }, [isOpen]);
+
+  // Handle backlink click
+  const handleBacklinkClick = useCallback(
+    (backlinkNoteId: string) => {
+      onNavigateToNote(backlinkNoteId);
+      onClose();
+    },
+    [onNavigateToNote, onClose]
+  );
+
+  // Render content based on state
+  const renderContent = () => {
+    if (isLoading) {
+      return (
+        <div className={styles.emptyState}>
+          <div className={styles.spinner} />
+          <span className={styles.emptyText}>Loading backlinks...</span>
+        </div>
+      );
+    }
+
+    if (error) {
+      return (
+        <div className={styles.emptyState}>
+          <AlertCircle size={24} className={styles.emptyIcon} />
+          <span className={styles.emptyText}>Failed to load backlinks</span>
+        </div>
+      );
+    }
+
+    if (!backlinks || backlinks.length === 0) {
+      return (
+        <div className={styles.emptyState}>
+          <Link2 size={24} className={styles.emptyIcon} />
+          <span className={styles.emptyText}>No backlinks yet</span>
+          <span className={styles.emptyHint}>
+            Notes that link to this note using [[wikilinks]] will appear here.
+          </span>
+        </div>
+      );
+    }
+
+    return (
+      <div className={styles.list}>
+        {backlinks.map(backlink => (
+          <button
+            key={backlink.noteId}
+            type="button"
+            className={styles.item}
+            onClick={() => handleBacklinkClick(backlink.noteId)}
+          >
+            <span className={styles.icon}>
+              <FileText size={16} />
+            </span>
+            <span className={styles.itemContent}>
+              <span className={styles.itemTitle}>{backlink.noteTitle}</span>
+              <span className={styles.itemRef}>[[{backlink.targetRef}]]</span>
+            </span>
+          </button>
+        ))}
+      </div>
+    );
+  };
+
+  // Render via portal to avoid stacking context issues
+  return createPortal(
+    <>
+      {/* Backdrop */}
+      <div
+        className={isOpen ? styles.backdropOpen : styles.backdrop}
+        onClick={onClose}
+        aria-hidden="true"
+      />
+
+      {/* Panel */}
+      <aside
+        className={isOpen ? styles.panelOpen : styles.panel}
+        role="dialog"
+        aria-label="Backlinks"
+        aria-modal="true"
+      >
+        {/* Header */}
+        <header className={styles.header}>
+          <h2 className={styles.title}>
+            <Link2 size={16} />
+            Backlinks
+            {backlinks && backlinks.length > 0 && (
+              <span className={styles.count}>{backlinks.length}</span>
+            )}
+          </h2>
+          <button
+            type="button"
+            className={styles.closeBtn}
+            onClick={onClose}
+            aria-label="Close backlinks panel"
+          >
+            <X size={18} />
+          </button>
+        </header>
+
+        {/* Content */}
+        <div className={styles.content}>{renderContent()}</div>
+      </aside>
+    </>,
+    document.body
+  );
+});
diff --git a/apps/desktop/src/renderer/components/editor/BacklinksPanel/index.ts b/apps/desktop/src/renderer/components/editor/BacklinksPanel/index.ts
new file mode 100644
index 0000000..190f75b
--- /dev/null
+++ b/apps/desktop/src/renderer/components/editor/BacklinksPanel/index.ts
@@ -0,0 +1 @@
+export { BacklinksPanel } from './BacklinksPanel';
diff --git a/apps/desktop/src/renderer/components/editor/MarkdownPreview.tsx b/apps/desktop/src/renderer/components/editor/MarkdownPreview.tsx
index 33ac022..0b17922 100644
--- a/apps/desktop/src/renderer/components/editor/MarkdownPreview.tsx
+++ b/apps/desktop/src/renderer/components/editor/MarkdownPreview.tsx
@@ -2,8 +2,9 @@ import { useMemo, useRef, useImperativeHandle, forwardRef, useEffect, useCallbac
 import Markdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import { Clock, CalendarPlus, ListChecks } from 'lucide-react';
-import { remarkWikilink } from './remark-wikilink';
-import { countMarkdownTasks } from '../../utils/markdown';
+import { remarkWikilink } from '@readied/wikilinks';
+import { remarkEmbed } from '@readied/embeds';
+import { countMarkdownTasks } from '@readied/tasks';
 import { formatDateTime } from '../../utils/date';
 
 interface MarkdownPreviewProps {
@@ -135,7 +136,7 @@ export const MarkdownPreview = forwardRef<MarkdownPreviewHandle, MarkdownPreview
         </div>
 
         <Markdown
-          remarkPlugins={[remarkGfm, remarkWikilink]}
+          remarkPlugins={[remarkGfm, remarkWikilink, remarkEmbed]}
           skipHtml={true}
           components={{
             // Custom checkbox rendering for task lists
diff --git a/apps/desktop/src/renderer/hooks/useLinks.ts b/apps/desktop/src/renderer/hooks/useLinks.ts
new file mode 100644
index 0000000..a50dae6
--- /dev/null
+++ b/apps/desktop/src/renderer/hooks/useLinks.ts
@@ -0,0 +1,67 @@
+/**
+ * Links Hooks (Wikilinks / Backlinks)
+ *
+ * React Query hooks for link-related operations.
+ */
+
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import type { BacklinkInfo, OutgoingLinkInfo } from '../../preload/index';
+
+/** Query key factory for links */
+export const linkKeys = {
+  all: ['links'] as const,
+  backlinks: (noteId: string) => [...linkKeys.all, 'backlinks', noteId] as const,
+  outgoing: (noteId: string) => [...linkKeys.all, 'outgoing', noteId] as const,
+};
+
+/**
+ * Hook for getting backlinks (notes that link TO this note).
+ *
+ * @param noteId - The note ID to get backlinks for
+ * @returns Query result with array of BacklinkInfo
+ */
+export function useBacklinks(noteId: string | null) {
+  return useQuery({
+    queryKey: linkKeys.backlinks(noteId ?? ''),
+    queryFn: async (): Promise<BacklinkInfo[]> => {
+      if (!noteId) return [];
+      return window.readied.links.getBacklinks(noteId);
+    },
+    enabled: !!noteId,
+  });
+}
+
+/**
+ * Hook for getting outgoing links (notes this note links TO).
+ *
+ * @param noteId - The note ID to get outgoing links for
+ * @returns Query result with array of OutgoingLinkInfo
+ */
+export function useOutgoingLinks(noteId: string | null) {
+  return useQuery({
+    queryKey: linkKeys.outgoing(noteId ?? ''),
+    queryFn: async (): Promise<OutgoingLinkInfo[]> => {
+      if (!noteId) return [];
+      return window.readied.links.getOutgoing(noteId);
+    },
+    enabled: !!noteId,
+  });
+}
+
+/**
+ * Hook for syncing links.
+ * Call this after saving a note to update the links table.
+ */
+export function useSyncLinks() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ noteId, content }: { noteId: string; content: string }) => {
+      await window.readied.links.sync(noteId, content);
+    },
+    onSuccess: () => {
+      // Invalidate all link queries since links may have changed
+      queryClient.invalidateQueries({ queryKey: linkKeys.all });
+    },
+  });
+}
diff --git a/apps/desktop/src/renderer/styles/global.css b/apps/desktop/src/renderer/styles/global.css
index 80de63f..eca6878 100644
--- a/apps/desktop/src/renderer/styles/global.css
+++ b/apps/desktop/src/renderer/styles/global.css
@@ -374,6 +374,37 @@ input:focus-visible {
   transform: scale(0.95);
 }
 
+/* Header actions group (backlinks + more actions) */
+.note-editor-header-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  flex-shrink: 0;
+  -webkit-app-region: no-drag;
+}
+
+/* Badge for backlinks count */
+.note-editor-actions-btn .badge {
+  position: absolute;
+  top: -2px;
+  right: -2px;
+  min-width: 16px;
+  height: 16px;
+  padding: 0 4px;
+  border-radius: 8px;
+  background: var(--accent);
+  color: white;
+  font-size: 10px;
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.note-editor-actions-btn.has-badge {
+  position: relative;
+}
+
 .note-editor-body {
   flex: 1;
   overflow: hidden;
diff --git a/apps/desktop/src/renderer/styles/preview.css b/apps/desktop/src/renderer/styles/preview.css
index e80d166..ca375b3 100644
--- a/apps/desktop/src/renderer/styles/preview.css
+++ b/apps/desktop/src/renderer/styles/preview.css
@@ -12,6 +12,8 @@
   font-family: var(--font-sans);
   font-size: 15px;
   line-height: 1.7;
+  container-type: inline-size;
+  container-name: preview;
 }
 
 /* ============================================================================
@@ -21,8 +23,9 @@
 
 .preview-metadata-header {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
-  gap: 48px;
+  gap: 24px 48px;
   padding: 10px 16px;
   margin-bottom: 16px;
   background: var(--bg-surface);
@@ -30,10 +33,30 @@
   border-radius: 12px;
 }
 
+/* Compact layout for narrow widths (container query) */
+@container preview (max-width: 450px) {
+  .preview-metadata-header {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 12px;
+  }
+
+  .preview-meta-item {
+    gap: 10px;
+  }
+
+  .preview-meta-icon {
+    width: 16px;
+    height: 16px;
+  }
+}
+
 .preview-meta-item {
   display: flex;
   align-items: center;
   gap: 12px;
+  min-width: 0;
+  flex-shrink: 0;
 }
 
 .preview-meta-icon {
@@ -149,6 +172,7 @@
 
 /* Wikilinks [[note]] */
 .markdown-preview .wikilink {
+  display: inline; /* Force inline in all contexts (blockquotes, etc) */
   color: var(--accent);
   border-bottom: 1px solid rgba(94, 234, 212, 0.3);
   cursor: pointer;
@@ -290,6 +314,43 @@
   margin: 1em 0;
 }
 
+/* Embeds (![[file]] syntax) */
+.markdown-preview .embed {
+  display: block;
+  margin: 1em 0;
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.markdown-preview .embed-image {
+  max-width: 100%;
+  height: auto;
+}
+
+.markdown-preview .embed-video,
+.markdown-preview .embed-audio {
+  width: 100%;
+  max-width: 100%;
+}
+
+.markdown-preview .embed-pdf {
+  width: 100%;
+  height: 500px;
+  border: 1px solid var(--border-subtle);
+}
+
+.markdown-preview .embed-unresolved {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  color: var(--text-muted);
+  font-style: italic;
+  background: var(--bg-elevated);
+  border: 1px dashed var(--border-subtle);
+  padding: 4px 8px;
+  border-radius: 4px;
+}
+
 /* Footnotes (GFM) */
 .markdown-preview .footnotes {
   margin-top: 2em;
diff --git a/apps/desktop/src/renderer/utils/markdown.ts b/apps/desktop/src/renderer/utils/markdown.ts
deleted file mode 100644
index e768eeb..0000000
--- a/apps/desktop/src/renderer/utils/markdown.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * Markdown parsing utilities for UI display
- * Visual derivations only - NOT domain logic
- */
-
-/**
- * Counts markdown task checkboxes in content
- * @example countMarkdownTasks("- [x] done\n- [ ] todo") => { total: 2, completed: 1 }
- */
-export function countMarkdownTasks(content: string): { total: number; completed: number } {
-  // Match: - [ ] or - [x] or * [ ] or * [x] (with optional leading whitespace)
-  const all = content.match(/^[ \t]*[-*]\s+\[.\]/gm) ?? [];
-  const done = content.match(/^[ \t]*[-*]\s+\[[xX]\]/gm) ?? [];
-  return {
-    total: all.length,
-    completed: done.length,
-  };
-}
diff --git a/packages/commands/package.json b/packages/commands/package.json
new file mode 100644
index 0000000..1f2403a
--- /dev/null
+++ b/packages/commands/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "@readied/commands",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Markdown editing commands for Readied",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@codemirror/commands": "^6.0.0",
+    "@codemirror/state": "^6.0.0",
+    "@codemirror/view": "^6.0.0"
+  },
+  "devDependencies": {
+    "@codemirror/commands": "^6.10.1",
+    "@codemirror/state": "^6.5.3",
+    "@codemirror/view": "^6.39.8",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}
diff --git a/packages/commands/src/index.ts b/packages/commands/src/index.ts
new file mode 100644
index 0000000..de053ee
--- /dev/null
+++ b/packages/commands/src/index.ts
@@ -0,0 +1,24 @@
+/**
+ * @readied/commands
+ *
+ * Markdown editing commands for Readied.
+ * Pure functions - no Electron, React, or UI dependencies.
+ */
+
+// Markdown commands
+export {
+  toggleBold,
+  toggleItalic,
+  toggleStrikethrough,
+  toggleInlineCode,
+  insertLink,
+  insertHeading,
+  insertUnorderedList,
+  insertOrderedList,
+  insertCheckbox,
+  insertQuote,
+  insertCodeBlock,
+  insertHorizontalRule,
+  undoChange,
+  redoChange,
+} from './markdown/commands.js';
diff --git a/apps/desktop/src/renderer/components/editor/toolbar-commands.ts b/packages/commands/src/markdown/commands.ts
similarity index 99%
rename from apps/desktop/src/renderer/components/editor/toolbar-commands.ts
rename to packages/commands/src/markdown/commands.ts
index 6db7012..a4cca6f 100644
--- a/apps/desktop/src/renderer/components/editor/toolbar-commands.ts
+++ b/packages/commands/src/markdown/commands.ts
@@ -1,5 +1,5 @@
 /**
- * CodeMirror 6 Toolbar Commands
+ * Markdown Editing Commands
  *
  * Pure functions for markdown formatting operations.
  * All functions take an EditorView and dispatch changes.
diff --git a/packages/commands/tsconfig.json b/packages/commands/tsconfig.json
new file mode 100644
index 0000000..31d92b3
--- /dev/null
+++ b/packages/commands/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}
diff --git a/packages/commands/vitest.config.ts b/packages/commands/vitest.config.ts
new file mode 100644
index 0000000..b6aa913
--- /dev/null
+++ b/packages/commands/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: false,
+    environment: 'node',
+    passWithNoTests: true,
+  },
+});
diff --git a/packages/core/package.json b/packages/core/package.json
index e5065fe..59d3e2a 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -18,6 +18,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@readied/wikilinks": "workspace:*",
     "zod": "^3.24.1"
   },
   "devDependencies": {
diff --git a/packages/core/src/domain/index.ts b/packages/core/src/domain/index.ts
index 229c51e..9afddaa 100644
--- a/packages/core/src/domain/index.ts
+++ b/packages/core/src/domain/index.ts
@@ -7,3 +7,6 @@ export * from './metadata.js';
 export * from './note.js';
 export * from './notebook.js';
 export * from './invariants.js';
+// Re-export wikilinks from the dedicated package
+export { extractWikilinks, extractWikilinkTargets } from '@readied/wikilinks';
+export type { WikilinkRef } from '@readied/wikilinks';
diff --git a/packages/embeds/package.json b/packages/embeds/package.json
new file mode 100644
index 0000000..234be84
--- /dev/null
+++ b/packages/embeds/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@readied/embeds",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Embed system for Readied (![[filename]] syntax)",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.4",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}
diff --git a/packages/embeds/src/adapters/remark/remark-embed.ts b/packages/embeds/src/adapters/remark/remark-embed.ts
new file mode 100644
index 0000000..7b70c4e
--- /dev/null
+++ b/packages/embeds/src/adapters/remark/remark-embed.ts
@@ -0,0 +1,154 @@
+/**
+ * Remark plugin for embed ![[file]] syntax in Markdown preview
+ *
+ * Transforms ![[target]] and ![[target|display]] into appropriate HTML elements
+ * based on file type (image, video, audio, pdf).
+ *
+ * File resolution is handled by the app - this plugin just creates the elements.
+ */
+
+import { visit } from 'unist-util-visit';
+import type { Root, Text, Parent } from 'mdast';
+import { getEmbedType } from '../../core/types.js';
+
+// Pattern: ![[target]] or ![[target|display]]
+const EMBED_PATTERN = /!\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+
+/**
+ * Text node with hast data for rendering as HTML element.
+ */
+interface TextWithData {
+  type: 'text';
+  value: string;
+  data?: {
+    hName: string;
+    hProperties: Record<string, string | boolean>;
+  };
+}
+
+/**
+ * Create remark plugin for embed syntax.
+ *
+ * @param options - Optional configuration
+ * @param options.resolveUrl - Function to resolve embed target to URL (defaults to data-embed attribute)
+ */
+export function remarkEmbed(options?: { resolveUrl?: (target: string) => string | null }) {
+  const resolveUrl = options?.resolveUrl;
+
+  return (tree: Root) => {
+    visit(tree, 'text', (node: Text, index: number | undefined, parent: Parent | undefined) => {
+      if (index === undefined || !parent) return;
+
+      const value = node.value;
+      if (!value.includes('![[')) return;
+
+      const children: TextWithData[] = [];
+      let lastIndex = 0;
+
+      // Reset lastIndex for global regex
+      EMBED_PATTERN.lastIndex = 0;
+
+      let match;
+      while ((match = EMBED_PATTERN.exec(value)) !== null) {
+        // Text before match
+        if (match.index > lastIndex) {
+          children.push({ type: 'text', value: value.slice(lastIndex, match.index) });
+        }
+
+        const target = match[1]!.trim();
+        const display = match[2]?.trim() || target;
+        const embedType = getEmbedType(target);
+        const url = resolveUrl?.(target);
+
+        // Create appropriate element based on embed type
+        children.push(createEmbedNode(target, display, embedType, url));
+
+        lastIndex = match.index + match[0].length;
+      }
+
+      // Remaining text
+      if (lastIndex < value.length) {
+        children.push({ type: 'text', value: value.slice(lastIndex) });
+      }
+
+      if (children.length > 0) {
+        (parent.children as TextWithData[]).splice(index, 1, ...children);
+        return index + children.length;
+      }
+    });
+  };
+}
+
+/**
+ * Create the appropriate HTML node for an embed based on its type.
+ */
+function createEmbedNode(
+  target: string,
+  display: string,
+  embedType: string,
+  url: string | null | undefined
+): TextWithData {
+  const baseProps: Record<string, string | boolean> = {
+    'data-embed': target,
+    className: `embed embed-${embedType}`,
+  };
+
+  // If we have a resolved URL, use it
+  if (url) {
+    switch (embedType) {
+      case 'image':
+        return {
+          type: 'text',
+          value: '',
+          data: {
+            hName: 'img',
+            hProperties: { ...baseProps, src: url, alt: display, loading: 'lazy' },
+          },
+        };
+
+      case 'video':
+        return {
+          type: 'text',
+          value: '',
+          data: {
+            hName: 'video',
+            hProperties: { ...baseProps, src: url, controls: true },
+          },
+        };
+
+      case 'audio':
+        return {
+          type: 'text',
+          value: '',
+          data: {
+            hName: 'audio',
+            hProperties: { ...baseProps, src: url, controls: true },
+          },
+        };
+
+      case 'pdf':
+        return {
+          type: 'text',
+          value: '',
+          data: {
+            hName: 'embed',
+            hProperties: { ...baseProps, src: url, type: 'application/pdf' },
+          },
+        };
+    }
+  }
+
+  // Fallback: show as placeholder link (file not resolved yet)
+  return {
+    type: 'text',
+    value: display,
+    data: {
+      hName: 'span',
+      hProperties: {
+        ...baseProps,
+        className: 'embed embed-unresolved',
+        title: `Embed: ${target}`,
+      },
+    },
+  };
+}
diff --git a/packages/embeds/src/core/parsing.ts b/packages/embeds/src/core/parsing.ts
new file mode 100644
index 0000000..5ad32fd
--- /dev/null
+++ b/packages/embeds/src/core/parsing.ts
@@ -0,0 +1,73 @@
+/**
+ * Embed Parsing
+ *
+ * Pure functions to extract embed references from markdown.
+ */
+
+import type { EmbedRef } from './types.js';
+
+/**
+ * Regex to match embed syntax: ![[target]] or ![[target|display]]
+ * - Must start with ![[
+ * - Target cannot contain [ or ]
+ * - Optional |display text
+ * - Must end with ]]
+ */
+const EMBED_REGEX = /!\[\[([^[\]|]+)(?:\|([^\]]+))?\]\]/g;
+
+/**
+ * Extract all embed references from markdown content.
+ *
+ * @param content - Markdown text
+ * @returns Array of embed references
+ *
+ * @example
+ * extractEmbeds('Check ![[diagram.png]] and ![[spec.pdf|PDF Spec]]')
+ * // Returns: [
+ * //   { target: 'diagram.png' },
+ * //   { target: 'spec.pdf', display: 'PDF Spec' }
+ * // ]
+ */
+export function extractEmbeds(content: string): EmbedRef[] {
+  const embeds: EmbedRef[] = [];
+  let match: RegExpExecArray | null;
+
+  // Reset regex state
+  EMBED_REGEX.lastIndex = 0;
+
+  while ((match = EMBED_REGEX.exec(content)) !== null) {
+    const rawTarget = match[1];
+    if (!rawTarget) continue;
+
+    const target = rawTarget.trim();
+    const display = match[2]?.trim();
+
+    if (target) {
+      embeds.push(display ? { target, display } : { target });
+    }
+  }
+
+  return embeds;
+}
+
+/**
+ * Extract unique embed targets (filenames) from markdown content.
+ *
+ * @param content - Markdown text
+ * @returns Array of unique filenames (case-preserved, deduplicated case-insensitive)
+ */
+export function extractEmbedTargets(content: string): string[] {
+  const embeds = extractEmbeds(content);
+  const seen = new Set<string>();
+  const targets: string[] = [];
+
+  for (const embed of embeds) {
+    const lower = embed.target.toLowerCase();
+    if (!seen.has(lower)) {
+      seen.add(lower);
+      targets.push(embed.target);
+    }
+  }
+
+  return targets;
+}
diff --git a/packages/embeds/src/core/types.ts b/packages/embeds/src/core/types.ts
new file mode 100644
index 0000000..992f990
--- /dev/null
+++ b/packages/embeds/src/core/types.ts
@@ -0,0 +1,39 @@
+/**
+ * Embed Types
+ *
+ * Core types for embed references.
+ */
+
+/**
+ * Reference to an embedded file.
+ * Extracted from ![[filename]] or ![[filename|display]] syntax.
+ */
+export interface EmbedRef {
+  /** Filename or path (e.g., "diagram.png", "docs/spec.pdf") */
+  target: string;
+  /** Optional display text */
+  display?: string;
+}
+
+/**
+ * Supported embed types based on file extension.
+ */
+export type EmbedType = 'image' | 'video' | 'audio' | 'pdf' | 'unknown';
+
+/**
+ * Get embed type from filename.
+ */
+export function getEmbedType(filename: string): EmbedType {
+  const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+
+  const imageExts = ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'ico', 'bmp'];
+  const videoExts = ['mp4', 'webm', 'mov', 'avi', 'mkv'];
+  const audioExts = ['mp3', 'wav', 'ogg', 'm4a', 'flac', 'aac'];
+
+  if (imageExts.includes(ext)) return 'image';
+  if (videoExts.includes(ext)) return 'video';
+  if (audioExts.includes(ext)) return 'audio';
+  if (ext === 'pdf') return 'pdf';
+
+  return 'unknown';
+}
diff --git a/packages/embeds/src/index.ts b/packages/embeds/src/index.ts
new file mode 100644
index 0000000..57adab6
--- /dev/null
+++ b/packages/embeds/src/index.ts
@@ -0,0 +1,25 @@
+/**
+ * @readied/embeds
+ *
+ * Embed system for Readied.
+ * Supports ![[filename]] syntax for embedding images, videos, audio, and PDFs.
+ *
+ * USAGE:
+ *   import { remarkEmbed, extractEmbeds } from '@readied/embeds';
+ *
+ *   // In remark plugins:
+ *   remarkPlugins={[remarkGfm, remarkWikilink, remarkEmbed]}
+ *
+ *   // For parsing:
+ *   const embeds = extractEmbeds(content);
+ */
+
+// Core - types
+export type { EmbedRef, EmbedType } from './core/types.js';
+export { getEmbedType } from './core/types.js';
+
+// Core - parsing (pure, no deps)
+export { extractEmbeds, extractEmbedTargets } from './core/parsing.js';
+
+// Adapters
+export { remarkEmbed } from './adapters/remark/remark-embed.js';
diff --git a/packages/embeds/tests/parsing.test.ts b/packages/embeds/tests/parsing.test.ts
new file mode 100644
index 0000000..ec29a88
--- /dev/null
+++ b/packages/embeds/tests/parsing.test.ts
@@ -0,0 +1,125 @@
+/**
+ * Embed Parsing Tests
+ *
+ * Pure domain tests for embed extraction.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { extractEmbeds, extractEmbedTargets } from '../src/core/parsing.js';
+import { getEmbedType } from '../src/core/types.js';
+
+describe('extractEmbeds', () => {
+  it('returns empty array for content without embeds', () => {
+    const result = extractEmbeds('Just regular markdown content.');
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array for empty content', () => {
+    const result = extractEmbeds('');
+    expect(result).toEqual([]);
+  });
+
+  it('extracts single embed', () => {
+    const result = extractEmbeds('Check this ![[diagram.png]]');
+    expect(result).toEqual([{ target: 'diagram.png' }]);
+  });
+
+  it('extracts embed with display text', () => {
+    const result = extractEmbeds('See ![[spec.pdf|PDF Specification]]');
+    expect(result).toEqual([{ target: 'spec.pdf', display: 'PDF Specification' }]);
+  });
+
+  it('extracts multiple embeds', () => {
+    const result = extractEmbeds('![[image1.png]] and ![[image2.jpg|Photo]]');
+    expect(result).toEqual([{ target: 'image1.png' }, { target: 'image2.jpg', display: 'Photo' }]);
+  });
+
+  it('handles embeds with paths', () => {
+    const result = extractEmbeds('![[assets/images/logo.svg]]');
+    expect(result).toEqual([{ target: 'assets/images/logo.svg' }]);
+  });
+
+  it('ignores wikilinks (no ! prefix)', () => {
+    const result = extractEmbeds('Link to [[note]] is not an embed');
+    expect(result).toEqual([]);
+  });
+
+  it('handles mixed wikilinks and embeds', () => {
+    const result = extractEmbeds('See [[note]] and ![[image.png]]');
+    expect(result).toEqual([{ target: 'image.png' }]);
+  });
+
+  it('trims whitespace from target and display', () => {
+    const result = extractEmbeds('![[  file.png  |  Label  ]]');
+    expect(result).toEqual([{ target: 'file.png', display: 'Label' }]);
+  });
+
+  it('handles embeds in multiline content', () => {
+    const content = `
+# Title
+
+![[header.png]]
+
+Some text with ![[inline.gif|GIF]] embed.
+
+![[footer.svg]]
+    `;
+    const result = extractEmbeds(content);
+    expect(result).toEqual([
+      { target: 'header.png' },
+      { target: 'inline.gif', display: 'GIF' },
+      { target: 'footer.svg' },
+    ]);
+  });
+});
+
+describe('extractEmbedTargets', () => {
+  it('returns unique targets', () => {
+    const result = extractEmbedTargets('![[a.png]] ![[b.png]] ![[a.png]]');
+    expect(result).toEqual(['a.png', 'b.png']);
+  });
+
+  it('deduplicates case-insensitive', () => {
+    const result = extractEmbedTargets('![[Image.PNG]] ![[image.png]]');
+    expect(result).toEqual(['Image.PNG']);
+  });
+});
+
+describe('getEmbedType', () => {
+  it('detects image types', () => {
+    expect(getEmbedType('photo.png')).toBe('image');
+    expect(getEmbedType('photo.jpg')).toBe('image');
+    expect(getEmbedType('photo.jpeg')).toBe('image');
+    expect(getEmbedType('photo.gif')).toBe('image');
+    expect(getEmbedType('photo.svg')).toBe('image');
+    expect(getEmbedType('photo.webp')).toBe('image');
+  });
+
+  it('detects video types', () => {
+    expect(getEmbedType('video.mp4')).toBe('video');
+    expect(getEmbedType('video.webm')).toBe('video');
+    expect(getEmbedType('video.mov')).toBe('video');
+  });
+
+  it('detects audio types', () => {
+    expect(getEmbedType('audio.mp3')).toBe('audio');
+    expect(getEmbedType('audio.wav')).toBe('audio');
+    expect(getEmbedType('audio.ogg')).toBe('audio');
+  });
+
+  it('detects PDF', () => {
+    expect(getEmbedType('document.pdf')).toBe('pdf');
+  });
+
+  it('returns unknown for other types', () => {
+    expect(getEmbedType('file.txt')).toBe('unknown');
+    expect(getEmbedType('file.doc')).toBe('unknown');
+    expect(getEmbedType('noextension')).toBe('unknown');
+  });
+
+  it('handles uppercase extensions', () => {
+    expect(getEmbedType('photo.PNG')).toBe('image');
+    expect(getEmbedType('video.MP4')).toBe('video');
+    expect(getEmbedType('document.PDF')).toBe('pdf');
+  });
+});
diff --git a/packages/embeds/tsconfig.json b/packages/embeds/tsconfig.json
new file mode 100644
index 0000000..31d92b3
--- /dev/null
+++ b/packages/embeds/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}
diff --git a/packages/embeds/vitest.config.ts b/packages/embeds/vitest.config.ts
new file mode 100644
index 0000000..2dcea8c
--- /dev/null
+++ b/packages/embeds/vitest.config.ts
@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: false,
+    environment: 'node',
+  },
+});
diff --git a/packages/storage-sqlite/src/index.ts b/packages/storage-sqlite/src/index.ts
index 6e79755..b5d935c 100644
--- a/packages/storage-sqlite/src/index.ts
+++ b/packages/storage-sqlite/src/index.ts
@@ -14,8 +14,17 @@ export {
 } from './database.js';
 
 // Repositories
-export { SQLiteNoteRepository } from './repositories/SQLiteNoteRepository.js';
+export { SQLiteNoteRepository, type BacklinkInfo } from './repositories/SQLiteNoteRepository.js';
 export { SQLiteNotebookRepository } from './repositories/SQLiteNotebookRepository.js';
 
 // Migrations
-export { allMigrations, initialSchema, addArchivedAt, addNotebooks } from './migrations/index.js';
+export {
+  allMigrations,
+  initialSchema,
+  addArchivedAt,
+  addNotebooks,
+  addNoteFields,
+  addManualTags,
+  addTagColors,
+  addLinks,
+} from './migrations/index.js';
diff --git a/packages/storage-sqlite/src/migrations/007_links.ts b/packages/storage-sqlite/src/migrations/007_links.ts
new file mode 100644
index 0000000..6ca7464
--- /dev/null
+++ b/packages/storage-sqlite/src/migrations/007_links.ts
@@ -0,0 +1,39 @@
+/**
+ * Links Migration
+ *
+ * Creates table for tracking note-to-note wikilinks.
+ *
+ * Design decisions:
+ * - target_ref stores the raw link text (e.g., "Note B" from [[Note B]])
+ * - target_note_id is nullable for unresolved/broken links
+ * - ON DELETE CASCADE cleans up when source/target notes are deleted
+ */
+
+import type { Migration } from '@readied/storage-core';
+
+export const addLinks: Migration = {
+  version: 20250103000001,
+  name: 'links',
+  up: `
+    -- Create links table for note-to-note relationships
+    CREATE TABLE IF NOT EXISTS links (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_note_id TEXT NOT NULL,
+      target_ref TEXT NOT NULL,
+      target_note_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(source_note_id, target_ref),
+      FOREIGN KEY (source_note_id) REFERENCES notes(id) ON DELETE CASCADE,
+      FOREIGN KEY (target_note_id) REFERENCES notes(id) ON DELETE SET NULL
+    );
+
+    -- Index for finding backlinks (what links TO this note)
+    CREATE INDEX IF NOT EXISTS idx_links_target ON links(target_note_id);
+
+    -- Index for finding outgoing links (what this note links TO)
+    CREATE INDEX IF NOT EXISTS idx_links_source ON links(source_note_id);
+
+    -- Index for resolving links by reference text
+    CREATE INDEX IF NOT EXISTS idx_links_target_ref ON links(target_ref);
+  `,
+};
diff --git a/packages/storage-sqlite/src/migrations/index.ts b/packages/storage-sqlite/src/migrations/index.ts
index 5281ff0..f9abac9 100644
--- a/packages/storage-sqlite/src/migrations/index.ts
+++ b/packages/storage-sqlite/src/migrations/index.ts
@@ -9,6 +9,7 @@ import { addNotebooks } from './003_notebooks.js';
 import { addNoteFields } from './004_note_fields.js';
 import { addManualTags } from './005_manual_tags.js';
 import { addTagColors } from './006_tag_colors.js';
+import { addLinks } from './007_links.js';
 
 /** All migrations in order */
 export const allMigrations: Migration[] = [
@@ -18,6 +19,15 @@ export const allMigrations: Migration[] = [
   addNoteFields,
   addManualTags,
   addTagColors,
+  addLinks,
 ];
 
-export { initialSchema, addArchivedAt, addNotebooks, addNoteFields, addManualTags, addTagColors };
+export {
+  initialSchema,
+  addArchivedAt,
+  addNotebooks,
+  addNoteFields,
+  addManualTags,
+  addTagColors,
+  addLinks,
+};
diff --git a/packages/storage-sqlite/src/repositories/SQLiteNoteRepository.ts b/packages/storage-sqlite/src/repositories/SQLiteNoteRepository.ts
index 9de2151..f4e3a47 100644
--- a/packages/storage-sqlite/src/repositories/SQLiteNoteRepository.ts
+++ b/packages/storage-sqlite/src/repositories/SQLiteNoteRepository.ts
@@ -20,6 +20,7 @@ import {
   createNotebookId,
   createTag,
   DEFAULT_NOTE_STATUS,
+  extractWikilinks,
 } from '@readied/core';
 import type { DatabaseConnection } from '../database.js';
 
@@ -47,6 +48,13 @@ interface TagWithColorRow {
   color: string | null;
 }
 
+/** Backlink information for UI display */
+export interface BacklinkInfo {
+  noteId: string;
+  noteTitle: string;
+  targetRef: string;
+}
+
 /** SQLite implementation of ExtendedNoteRepository */
 export class SQLiteNoteRepository implements ExtendedNoteRepository {
   constructor(private readonly db: DatabaseConnection) {}
@@ -394,4 +402,130 @@ export class SQLiteNoteRepository implements ExtendedNoteRepository {
       },
     };
   }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Links (Wikilinks / Backlinks)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Sync links for a note based on its content.
+   * Replaces all existing links from this note with newly extracted ones.
+   *
+   * @param noteId - The source note ID
+   * @param content - The note content to extract wikilinks from
+   */
+  syncLinks(noteId: NoteId, content: string): void {
+    this.db.transaction(() => {
+      // Delete all existing links from this note
+      const deleteStmt = this.db.prepare('DELETE FROM links WHERE source_note_id = ?');
+      deleteStmt.run(noteId);
+
+      // Extract wikilinks from content
+      const wikilinks = extractWikilinks(content);
+      if (wikilinks.length === 0) return;
+
+      // Prepare statements
+      const findNoteByTitle = this.db.prepare<{ id: string; title: string }>(`
+        SELECT id, title FROM notes
+        WHERE title = ? COLLATE NOCASE AND archived_at IS NULL
+        LIMIT 1
+      `);
+
+      const insertLink = this.db.prepare(`
+        INSERT INTO links (source_note_id, target_ref, target_note_id)
+        VALUES (?, ?, ?)
+        ON CONFLICT(source_note_id, target_ref) DO UPDATE SET
+          target_note_id = excluded.target_note_id
+      `);
+
+      // Insert each link
+      for (const wikilink of wikilinks) {
+        const targetRef = wikilink.target;
+
+        // Try to resolve target by title (case-insensitive)
+        const targetNote = findNoteByTitle.get(targetRef) as { id: string } | undefined;
+        const targetNoteId = targetNote?.id ?? null;
+
+        insertLink.run(noteId, targetRef, targetNoteId);
+      }
+    });
+  }
+
+  /**
+   * Get all notes that link TO a given note (backlinks).
+   *
+   * @param noteId - The target note ID
+   * @returns Array of backlink info with source note details
+   */
+  getBacklinks(noteId: NoteId): BacklinkInfo[] {
+    const stmt = this.db.prepare<{ source_note_id: string; title: string; target_ref: string }>(`
+      SELECT l.source_note_id, n.title, l.target_ref
+      FROM links l
+      JOIN notes n ON l.source_note_id = n.id
+      WHERE l.target_note_id = ? AND n.archived_at IS NULL
+      ORDER BY n.updated_at DESC
+    `);
+
+    const rows = stmt.all(noteId) as Array<{
+      source_note_id: string;
+      title: string;
+      target_ref: string;
+    }>;
+
+    return rows.map(row => ({
+      noteId: row.source_note_id,
+      noteTitle: row.title,
+      targetRef: row.target_ref,
+    }));
+  }
+
+  /**
+   * Get all notes that a given note links TO (outgoing links).
+   *
+   * @param noteId - The source note ID
+   * @returns Array of outgoing link info
+   */
+  getOutgoingLinks(
+    noteId: NoteId
+  ): Array<{ targetRef: string; targetNoteId: string | null; targetTitle: string | null }> {
+    const stmt = this.db.prepare<{
+      target_ref: string;
+      target_note_id: string | null;
+      target_title: string | null;
+    }>(`
+      SELECT l.target_ref, l.target_note_id, n.title as target_title
+      FROM links l
+      LEFT JOIN notes n ON l.target_note_id = n.id
+      WHERE l.source_note_id = ?
+      ORDER BY l.target_ref
+    `);
+
+    const rows = stmt.all(noteId) as Array<{
+      target_ref: string;
+      target_note_id: string | null;
+      target_title: string | null;
+    }>;
+
+    return rows.map(row => ({
+      targetRef: row.target_ref,
+      targetNoteId: row.target_note_id,
+      targetTitle: row.target_title,
+    }));
+  }
+
+  /**
+   * Re-resolve all links that reference a given title.
+   * Call this when a note is renamed to update resolved links.
+   *
+   * @param oldTitle - The old note title
+   * @param newNoteId - The new note ID to resolve to (or null to break links)
+   */
+  reResolveLinks(title: string, noteId: NoteId | null): void {
+    const stmt = this.db.prepare(`
+      UPDATE links
+      SET target_note_id = ?
+      WHERE target_ref = ? COLLATE NOCASE
+    `);
+    stmt.run(noteId, title);
+  }
 }
diff --git a/packages/storage-sqlite/src/repositories/index.ts b/packages/storage-sqlite/src/repositories/index.ts
index 128618c..6199949 100644
--- a/packages/storage-sqlite/src/repositories/index.ts
+++ b/packages/storage-sqlite/src/repositories/index.ts
@@ -2,4 +2,4 @@
  * Repository exports
  */
 
-export { SQLiteNoteRepository } from './SQLiteNoteRepository.js';
+export { SQLiteNoteRepository, type BacklinkInfo } from './SQLiteNoteRepository.js';
diff --git a/packages/tasks/package.json b/packages/tasks/package.json
new file mode 100644
index 0000000..aa2f651
--- /dev/null
+++ b/packages/tasks/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "@readied/tasks",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Task parsing for Readied",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}
diff --git a/packages/tasks/src/core/parsing.ts b/packages/tasks/src/core/parsing.ts
new file mode 100644
index 0000000..e6b00f2
--- /dev/null
+++ b/packages/tasks/src/core/parsing.ts
@@ -0,0 +1,33 @@
+/**
+ * Task Parsing
+ *
+ * Pure domain logic for extracting task information from markdown content.
+ * No dependencies on storage, UI, or external libraries.
+ */
+
+import type { TaskProgress } from './types.js';
+
+/**
+ * Count markdown task checkboxes in content.
+ *
+ * Matches GFM-style task lists:
+ * - `- [ ]` or `- [x]` (dash)
+ * - `* [ ]` or `* [x]` (asterisk)
+ *
+ * @param content - Markdown content to parse
+ * @returns Object with total and completed task counts
+ *
+ * @example
+ * countMarkdownTasks("- [x] done\n- [ ] todo")
+ * // Returns: { total: 2, completed: 1 }
+ */
+export function countMarkdownTasks(content: string): TaskProgress {
+  // Match: - [ ] or - [x] or * [ ] or * [x] (with optional leading whitespace)
+  const all = content.match(/^[ \t]*[-*]\s+\[.\]/gm) ?? [];
+  const done = content.match(/^[ \t]*[-*]\s+\[[xX]\]/gm) ?? [];
+
+  return {
+    total: all.length,
+    completed: done.length,
+  };
+}
diff --git a/packages/tasks/src/core/types.ts b/packages/tasks/src/core/types.ts
new file mode 100644
index 0000000..2add87f
--- /dev/null
+++ b/packages/tasks/src/core/types.ts
@@ -0,0 +1,13 @@
+/**
+ * Task Types
+ *
+ * Core types for the task parsing system.
+ */
+
+/** Progress of markdown tasks in content */
+export interface TaskProgress {
+  /** Total number of tasks */
+  total: number;
+  /** Number of completed tasks */
+  completed: number;
+}
diff --git a/packages/tasks/src/index.ts b/packages/tasks/src/index.ts
new file mode 100644
index 0000000..865124a
--- /dev/null
+++ b/packages/tasks/src/index.ts
@@ -0,0 +1,12 @@
+/**
+ * @readied/tasks
+ *
+ * Task parsing for Readied.
+ * Pure domain logic - no Electron, React, or UI dependencies.
+ */
+
+// Types
+export type { TaskProgress } from './core/types.js';
+
+// Parsing
+export { countMarkdownTasks } from './core/parsing.js';
diff --git a/packages/tasks/tests/parsing.test.ts b/packages/tasks/tests/parsing.test.ts
new file mode 100644
index 0000000..0be9c4a
--- /dev/null
+++ b/packages/tasks/tests/parsing.test.ts
@@ -0,0 +1,98 @@
+/**
+ * Task Parsing Tests
+ *
+ * Pure domain tests for task counting.
+ * No mocks needed - these are pure functions.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { countMarkdownTasks } from '../src/core/parsing.js';
+
+describe('countMarkdownTasks', () => {
+  it('returns zero for content without tasks', () => {
+    const result = countMarkdownTasks('Just regular markdown content.');
+    expect(result).toEqual({ total: 0, completed: 0 });
+  });
+
+  it('returns zero for empty content', () => {
+    const result = countMarkdownTasks('');
+    expect(result).toEqual({ total: 0, completed: 0 });
+  });
+
+  it('counts single unchecked task', () => {
+    const result = countMarkdownTasks('- [ ] todo item');
+    expect(result).toEqual({ total: 1, completed: 0 });
+  });
+
+  it('counts single checked task', () => {
+    const result = countMarkdownTasks('- [x] done item');
+    expect(result).toEqual({ total: 1, completed: 1 });
+  });
+
+  it('counts uppercase X as completed', () => {
+    const result = countMarkdownTasks('- [X] done item');
+    expect(result).toEqual({ total: 1, completed: 1 });
+  });
+
+  it('counts multiple mixed tasks', () => {
+    const content = `
+- [x] done
+- [ ] todo
+- [x] also done
+- [ ] another todo
+    `;
+    const result = countMarkdownTasks(content);
+    expect(result).toEqual({ total: 4, completed: 2 });
+  });
+
+  it('handles asterisk task lists', () => {
+    const content = `
+* [x] done with asterisk
+* [ ] todo with asterisk
+    `;
+    const result = countMarkdownTasks(content);
+    expect(result).toEqual({ total: 2, completed: 1 });
+  });
+
+  it('handles mixed dash and asterisk', () => {
+    const content = `
+- [x] done dash
+* [ ] todo asterisk
+    `;
+    const result = countMarkdownTasks(content);
+    expect(result).toEqual({ total: 2, completed: 1 });
+  });
+
+  it('handles tasks with leading whitespace (nested)', () => {
+    const content = `
+- [x] parent done
+  - [ ] nested todo
+    - [x] deeply nested done
+    `;
+    const result = countMarkdownTasks(content);
+    expect(result).toEqual({ total: 3, completed: 2 });
+  });
+
+  it('ignores inline checkbox-like patterns', () => {
+    const result = countMarkdownTasks('This is [ ] not a task');
+    expect(result).toEqual({ total: 0, completed: 0 });
+  });
+
+  it('handles tasks mixed with regular text', () => {
+    const content = `
+# Title
+
+Some paragraph text.
+
+- [x] First task
+- [ ] Second task
+
+More text here.
+
+- Regular list item
+- [x] Third task
+    `;
+    const result = countMarkdownTasks(content);
+    expect(result).toEqual({ total: 3, completed: 2 });
+  });
+});
diff --git a/packages/tasks/tsconfig.json b/packages/tasks/tsconfig.json
new file mode 100644
index 0000000..c8a8761
--- /dev/null
+++ b/packages/tasks/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}
diff --git a/packages/tasks/vitest.config.ts b/packages/tasks/vitest.config.ts
new file mode 100644
index 0000000..2dcea8c
--- /dev/null
+++ b/packages/tasks/vitest.config.ts
@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: false,
+    environment: 'node',
+  },
+});
diff --git a/packages/wikilinks/package.json b/packages/wikilinks/package.json
new file mode 100644
index 0000000..a661f69
--- /dev/null
+++ b/packages/wikilinks/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "@readied/wikilinks",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Wikilink system for Readied",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@codemirror/autocomplete": "^6.0.0",
+    "@codemirror/state": "^6.0.0",
+    "@codemirror/view": "^6.0.0"
+  },
+  "dependencies": {
+    "unified": "^11.0.0",
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@codemirror/autocomplete": "^6.20.0",
+    "@codemirror/state": "^6.5.3",
+    "@codemirror/view": "^6.39.8",
+    "@types/mdast": "^4.0.4",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}
diff --git a/packages/wikilinks/src/adapters/codemirror/autocomplete.ts b/packages/wikilinks/src/adapters/codemirror/autocomplete.ts
new file mode 100644
index 0000000..998920b
--- /dev/null
+++ b/packages/wikilinks/src/adapters/codemirror/autocomplete.ts
@@ -0,0 +1,100 @@
+/**
+ * Wikilink Autocomplete Extension
+ *
+ * Provides autocomplete suggestions for wikilinks when typing [[.
+ * Shows a searchable list of note titles.
+ */
+
+import {
+  type CompletionContext,
+  type CompletionResult,
+  autocompletion,
+} from '@codemirror/autocomplete';
+import type { EditorView } from '@codemirror/view';
+import { StateField, StateEffect, type Extension } from '@codemirror/state';
+import type { WikilinkNote } from '../../core/contracts.js';
+
+/** Configuration for the autocomplete extension */
+interface WikilinkAutocompleteConfig {
+  /** Search notes by query */
+  searchNotes: (query: string) => Promise<WikilinkNote[]>;
+  /** List recent notes (no query) */
+  listNotes: () => Promise<WikilinkNote[]>;
+}
+
+/** Effect to update the current note ID in editor state */
+export const setCurrentNoteId = StateEffect.define<string | null>();
+
+/** StateField to store the current note ID (for excluding from suggestions) */
+export const currentNoteIdField = StateField.define<string | null>({
+  create: () => null,
+  update: (value, tr) => {
+    for (const effect of tr.effects) {
+      if (effect.is(setCurrentNoteId)) return effect.value;
+    }
+    return value;
+  },
+});
+
+/**
+ * Create a wikilink autocomplete extension.
+ *
+ * Uses dependency injection for note fetching to keep the extension
+ * decoupled from IPC/API implementation.
+ *
+ * @param config - Functions to search and list notes
+ * @returns CodeMirror extension array
+ */
+export function createWikilinkAutocomplete(config: WikilinkAutocompleteConfig): Extension {
+  const { searchNotes, listNotes } = config;
+
+  async function wikilinkCompletions(context: CompletionContext): Promise<CompletionResult | null> {
+    // Match [[ followed by any characters except [ and ]
+    // TODO: Don't activate inside code blocks or inline code
+    const match = context.matchBefore(/\[\[[^\][]*/);
+    if (!match) return null;
+
+    // Extract query (text after [[)
+    const query = match.text.slice(2);
+
+    // Get currentNoteId from state to exclude from suggestions
+    const currentNoteId = context.state.field(currentNoteIdField, false);
+
+    // Fetch notes using injected functions
+    let notes = query.trim() ? await searchNotes(query) : await listNotes();
+
+    // Exclude current note from suggestions
+    if (currentNoteId) {
+      notes = notes.filter(n => n.id !== currentNoteId);
+    }
+
+    // NOTE: Empty result is valid UX (matches Obsidian behavior).
+    // The autocomplete closes silently when no notes match — this is intentional.
+
+    return {
+      from: match.from,
+      options: notes.slice(0, 15).map(note => ({
+        label: note.title,
+        apply: (view: EditorView, _completion: unknown, from: number, to: number) => {
+          // CONTRACT: Wikilinks are inserted as [[title]].
+          // Future migration to [[id|title]] format must happen here only.
+          const text = `[[${note.title}]]`;
+          view.dispatch({
+            changes: { from, to, insert: text },
+            selection: { anchor: from + text.length },
+          });
+        },
+      })),
+      filter: false, // Already filtered via searchNotes()
+    };
+  }
+
+  return [
+    currentNoteIdField,
+    autocompletion({
+      override: [wikilinkCompletions],
+      activateOnTyping: true,
+      maxRenderedOptions: 15,
+    }),
+  ];
+}
diff --git a/apps/desktop/src/renderer/components/editor/wikilink-extension.ts b/packages/wikilinks/src/adapters/codemirror/highlight.ts
similarity index 96%
rename from apps/desktop/src/renderer/components/editor/wikilink-extension.ts
rename to packages/wikilinks/src/adapters/codemirror/highlight.ts
index ffbe7e6..636bf66 100644
--- a/apps/desktop/src/renderer/components/editor/wikilink-extension.ts
+++ b/packages/wikilinks/src/adapters/codemirror/highlight.ts
@@ -40,7 +40,7 @@ class WikilinkHighlighter {
     const { from, to } = view.viewport;
     const text = view.state.sliceDoc(from, to);
 
-    // IMPORTANTE: resetear lastIndex para regex global
+    // Reset lastIndex for global regex
     WIKILINK_PATTERN.lastIndex = 0;
 
     let match;
diff --git a/apps/desktop/src/renderer/components/editor/remark-wikilink.ts b/packages/wikilinks/src/adapters/remark/remark-wikilink.ts
similarity index 61%
rename from apps/desktop/src/renderer/components/editor/remark-wikilink.ts
rename to packages/wikilinks/src/adapters/remark/remark-wikilink.ts
index 3f5ca11..bfb3a33 100644
--- a/apps/desktop/src/renderer/components/editor/remark-wikilink.ts
+++ b/packages/wikilinks/src/adapters/remark/remark-wikilink.ts
@@ -3,6 +3,9 @@
  *
  * Transforms [[target]] and [[target|display]] into clickable spans.
  * Navigation is handled by parent component via click delegation.
+ *
+ * Uses mdast text nodes with data.hName/hProperties for proper inline rendering.
+ * This pattern is compatible with remark-rehype and avoids DOM nesting warnings.
  */
 
 import { visit } from 'unist-util-visit';
@@ -11,14 +14,17 @@ import type { Root, Text, Parent } from 'mdast';
 // Pattern: [[target]] or [[target|display]]
 const WIKILINK_PATTERN = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
 
-interface WikilinkNode {
-  type: 'element';
-  tagName: 'span';
-  properties: {
-    className: string[];
-    'data-target': string;
+/**
+ * Text node with hast data for rendering as span.
+ * This is the standard unified pattern for inline elements.
+ */
+interface TextWithData {
+  type: 'text';
+  value: string;
+  data?: {
+    hName: string;
+    hProperties: Record<string, string>;
   };
-  children: Array<{ type: 'text'; value: string }>;
 }
 
 export function remarkWikilink() {
@@ -29,10 +35,10 @@ export function remarkWikilink() {
       const value = node.value;
       if (!value.includes('[[')) return;
 
-      const children: Array<{ type: string; value?: string } | WikilinkNode> = [];
+      const children: TextWithData[] = [];
       let lastIndex = 0;
 
-      // IMPORTANTE: resetear lastIndex para regex global
+      // Reset lastIndex for global regex
       WIKILINK_PATTERN.lastIndex = 0;
 
       let match;
@@ -42,18 +48,20 @@ export function remarkWikilink() {
           children.push({ type: 'text', value: value.slice(lastIndex, match.index) });
         }
 
-        // Wikilink element
+        // Wikilink as text node with hast data
         const target = match[1]!.trim();
         const display = match[2]?.trim() || target;
         children.push({
-          type: 'element',
-          tagName: 'span',
-          properties: {
-            className: ['wikilink'],
-            'data-target': target,
+          type: 'text',
+          value: display,
+          data: {
+            hName: 'span',
+            hProperties: {
+              className: 'wikilink',
+              'data-target': target,
+            },
           },
-          children: [{ type: 'text', value: display }],
-        } as WikilinkNode);
+        });
 
         lastIndex = match.index + match[0].length;
       }
@@ -64,10 +72,8 @@ export function remarkWikilink() {
       }
 
       if (children.length > 0) {
-        // Cast needed: we're inserting hast-like nodes into mdast parent
-        // This works because react-markdown handles the hybrid tree
-        (parent.children as unknown[]).splice(index, 1, ...children);
-        // IMPORTANTE: retornar nuevo index para no romper traversal
+        (parent.children as TextWithData[]).splice(index, 1, ...children);
+        // Return new index to not break traversal
         return index + children.length;
       }
     });
diff --git a/packages/wikilinks/src/core/contracts.ts b/packages/wikilinks/src/core/contracts.ts
new file mode 100644
index 0000000..0a54b7b
--- /dev/null
+++ b/packages/wikilinks/src/core/contracts.ts
@@ -0,0 +1,29 @@
+/**
+ * Wikilink Contracts
+ *
+ * Pure interfaces for the wikilinks system.
+ * No dependencies on Electron, React, or any external library.
+ */
+
+/**
+ * Minimal note representation for wikilinks.
+ * The plugin doesn't need to know about full Note entity.
+ */
+export interface WikilinkNote {
+  id: string;
+  title: string;
+}
+
+/**
+ * Resolver interface - pure data fetching.
+ * No side effects. Implemented by the app.
+ */
+export interface WikilinkResolver {
+  /** Search notes by query */
+  search(query: string): Promise<WikilinkNote[]>;
+  /** List recent notes (empty query) */
+  list(): Promise<WikilinkNote[]>;
+}
+
+// NOTE: WikilinkActions (navigateTo) will be added when the first
+// side-effect is needed. We don't add parameters "just in case".
diff --git a/packages/wikilinks/src/core/parsing.ts b/packages/wikilinks/src/core/parsing.ts
new file mode 100644
index 0000000..3ff6a5b
--- /dev/null
+++ b/packages/wikilinks/src/core/parsing.ts
@@ -0,0 +1,55 @@
+/**
+ * Wikilink Parsing
+ *
+ * Pure domain logic for extracting wikilinks from markdown content.
+ * No dependencies on storage, UI, or external libraries.
+ */
+
+import type { WikilinkRef } from './types.js';
+
+/** Pattern for matching wikilinks: [[target]] or [[target|display]] */
+// Exclude [ ] | from target to avoid matching nested/unclosed brackets
+const WIKILINK_PATTERN = /\[\[([^[\]|]+)(?:\|([^\]]+))?\]\]/g;
+
+/**
+ * Extract all wikilinks from markdown content.
+ *
+ * Supports both simple [[Target]] and aliased [[Target|display text]] formats.
+ * Returns unique targets only (deduplicated).
+ *
+ * @param content - Markdown content to parse
+ * @returns Array of unique wikilink references
+ *
+ * @example
+ * extractWikilinks("See [[Note A]] and [[Note B|my note]]")
+ * // Returns: [{ target: "Note A" }, { target: "Note B", display: "my note" }]
+ */
+export function extractWikilinks(content: string): WikilinkRef[] {
+  const seen = new Set<string>();
+  const links: WikilinkRef[] = [];
+  let match: RegExpExecArray | null;
+
+  while ((match = WIKILINK_PATTERN.exec(content)) !== null) {
+    const target = match[1]?.trim();
+    if (!target) continue;
+
+    // Deduplicate by target
+    if (seen.has(target.toLowerCase())) continue;
+    seen.add(target.toLowerCase());
+
+    const display = match[2]?.trim();
+    links.push(display ? { target, display } : { target });
+  }
+
+  return links;
+}
+
+/**
+ * Extract just the target strings from content (simpler API).
+ *
+ * @param content - Markdown content to parse
+ * @returns Array of unique target strings
+ */
+export function extractWikilinkTargets(content: string): string[] {
+  return extractWikilinks(content).map(link => link.target);
+}
diff --git a/packages/wikilinks/src/core/types.ts b/packages/wikilinks/src/core/types.ts
new file mode 100644
index 0000000..c3068d2
--- /dev/null
+++ b/packages/wikilinks/src/core/types.ts
@@ -0,0 +1,13 @@
+/**
+ * Wikilink Types
+ *
+ * Core types for the wikilinks system.
+ */
+
+/** Represents a parsed wikilink from content */
+export interface WikilinkRef {
+  /** The target reference (what's inside [[...]]) */
+  target: string;
+  /** Optional display text (after | in [[target|display]]) */
+  display?: string;
+}
diff --git a/packages/wikilinks/src/index.ts b/packages/wikilinks/src/index.ts
new file mode 100644
index 0000000..7414fad
--- /dev/null
+++ b/packages/wikilinks/src/index.ts
@@ -0,0 +1,33 @@
+/**
+ * @readied/wikilinks
+ *
+ * Wikilink system for Readied.
+ * Pure domain logic - no Electron, React, or UI dependencies.
+ *
+ * USAGE:
+ *   import { createWikilinkPlugin } from '@readied/wikilinks';
+ *   const plugin = createWikilinkPlugin(resolver);
+ *
+ * The createWikilinkPlugin factory is the recommended entry point.
+ * Individual exports are available for advanced use cases only.
+ */
+
+// Core - contracts and types
+export type { WikilinkNote, WikilinkResolver } from './core/contracts.js';
+export type { WikilinkRef } from './core/types.js';
+
+// Core - parsing (pure, no deps)
+export { extractWikilinks, extractWikilinkTargets } from './core/parsing.js';
+
+// Adapters (for advanced use only)
+export {
+  createWikilinkAutocomplete,
+  setCurrentNoteId,
+  currentNoteIdField,
+} from './adapters/codemirror/autocomplete.js';
+export { wikilinkExtension } from './adapters/codemirror/highlight.js';
+export { remarkWikilink } from './adapters/remark/remark-wikilink.js';
+
+// Factory function - RECOMMENDED ENTRY POINT
+export { createWikilinkPlugin } from './plugin.js';
+export type { WikilinkPlugin } from './plugin.js';
diff --git a/packages/wikilinks/src/plugin.ts b/packages/wikilinks/src/plugin.ts
new file mode 100644
index 0000000..266f057
--- /dev/null
+++ b/packages/wikilinks/src/plugin.ts
@@ -0,0 +1,54 @@
+/**
+ * Wikilink Plugin Factory
+ *
+ * This is the ONLY public entry point of the wikilinks system.
+ * Consumers should not compose editor/remark parts manually
+ * unless they know exactly what they are doing.
+ */
+
+import type { Extension } from '@codemirror/state';
+import type { WikilinkResolver } from './core/contracts.js';
+import { createWikilinkAutocomplete } from './adapters/codemirror/autocomplete.js';
+import { wikilinkExtension } from './adapters/codemirror/highlight.js';
+import { remarkWikilink } from './adapters/remark/remark-wikilink.js';
+
+/** Minimal Plugin type - remark-compatible function */
+type RemarkPlugin = typeof remarkWikilink;
+
+export interface WikilinkPlugin {
+  /** CodeMirror extensions for editor (highlighting + autocomplete) */
+  editorExtensions: Extension[];
+  /** Remark plugin for preview */
+  remarkPlugin: RemarkPlugin;
+}
+
+/**
+ * Create a complete wikilink plugin for both editor and preview.
+ *
+ * @param resolver - Pure data fetching functions (search, list)
+ * @returns Plugin with editorExtensions and remarkPlugin
+ *
+ * @example
+ * const plugin = createWikilinkPlugin({
+ *   search: async (query) => notes.filter(n => n.title.includes(query)),
+ *   list: async () => recentNotes,
+ * });
+ *
+ * // In CodeMirror:
+ * extensions: [...plugin.editorExtensions]
+ *
+ * // In unified/remark:
+ * .use(plugin.remarkPlugin)
+ */
+export function createWikilinkPlugin(resolver: WikilinkResolver): WikilinkPlugin {
+  return {
+    editorExtensions: [
+      wikilinkExtension,
+      createWikilinkAutocomplete({
+        searchNotes: resolver.search.bind(resolver),
+        listNotes: resolver.list.bind(resolver),
+      }),
+    ],
+    remarkPlugin: remarkWikilink,
+  };
+}
diff --git a/packages/wikilinks/tests/parsing.test.ts b/packages/wikilinks/tests/parsing.test.ts
new file mode 100644
index 0000000..77f3b59
--- /dev/null
+++ b/packages/wikilinks/tests/parsing.test.ts
@@ -0,0 +1,102 @@
+/**
+ * Parsing Tests
+ *
+ * Pure domain tests for wikilink extraction.
+ * No mocks needed - these are pure functions.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { extractWikilinks, extractWikilinkTargets } from '../src/core/parsing.js';
+
+describe('extractWikilinks', () => {
+  it('extracts simple [[target]] wikilink', () => {
+    const result = extractWikilinks('See [[Note A]] for details');
+    expect(result).toEqual([{ target: 'Note A' }]);
+  });
+
+  it('extracts [[target|display]] with alias', () => {
+    const result = extractWikilinks('Check [[Note B|my note]] here');
+    expect(result).toEqual([{ target: 'Note B', display: 'my note' }]);
+  });
+
+  it('extracts multiple wikilinks from text', () => {
+    const result = extractWikilinks('See [[Note A]] and [[Note B|alias]] and [[Note C]]');
+    expect(result).toEqual([
+      { target: 'Note A' },
+      { target: 'Note B', display: 'alias' },
+      { target: 'Note C' },
+    ]);
+  });
+
+  it('deduplicates by target (case-insensitive)', () => {
+    const result = extractWikilinks('[[Note A]] and [[note a]] and [[NOTE A]]');
+    expect(result).toEqual([{ target: 'Note A' }]);
+  });
+
+  it('preserves first occurrence display text when deduplicating', () => {
+    const result = extractWikilinks('[[Note|first]] and [[Note|second]]');
+    expect(result).toEqual([{ target: 'Note', display: 'first' }]);
+  });
+
+  it('trims whitespace from target and display', () => {
+    const result = extractWikilinks('[[  Note A  |  display text  ]]');
+    expect(result).toEqual([{ target: 'Note A', display: 'display text' }]);
+  });
+
+  it('returns empty array for text without wikilinks', () => {
+    const result = extractWikilinks('Just regular text without links');
+    expect(result).toEqual([]);
+  });
+
+  it('ignores unclosed brackets', () => {
+    const result = extractWikilinks('[[unclosed and [[Valid Note]]');
+    expect(result).toEqual([{ target: 'Valid Note' }]);
+  });
+
+  it('handles wikilinks at start and end of text', () => {
+    const result = extractWikilinks('[[Start]] middle [[End]]');
+    expect(result).toEqual([{ target: 'Start' }, { target: 'End' }]);
+  });
+
+  it('handles wikilinks on multiple lines', () => {
+    const result = extractWikilinks('Line 1 [[Note A]]\nLine 2 [[Note B]]');
+    expect(result).toEqual([{ target: 'Note A' }, { target: 'Note B' }]);
+  });
+
+  it('handles wikilinks with special characters in target', () => {
+    const result = extractWikilinks('[[2024-01-15 Daily Note]]');
+    expect(result).toEqual([{ target: '2024-01-15 Daily Note' }]);
+  });
+
+  it('handles wikilinks with unicode characters', () => {
+    const result = extractWikilinks('[[日本語ノート]]');
+    expect(result).toEqual([{ target: '日本語ノート' }]);
+  });
+
+  it('ignores empty wikilinks', () => {
+    const result = extractWikilinks('[[]] and [[  ]] and [[Valid]]');
+    expect(result).toEqual([{ target: 'Valid' }]);
+  });
+
+  it('handles consecutive wikilinks without space', () => {
+    const result = extractWikilinks('[[A]][[B]][[C]]');
+    expect(result).toEqual([{ target: 'A' }, { target: 'B' }, { target: 'C' }]);
+  });
+});
+
+describe('extractWikilinkTargets', () => {
+  it('returns array of target strings', () => {
+    const result = extractWikilinkTargets('See [[Note A]] and [[Note B|alias]]');
+    expect(result).toEqual(['Note A', 'Note B']);
+  });
+
+  it('returns empty array for no wikilinks', () => {
+    const result = extractWikilinkTargets('No links here');
+    expect(result).toEqual([]);
+  });
+
+  it('deduplicates targets', () => {
+    const result = extractWikilinkTargets('[[Note]] and [[Note]] again');
+    expect(result).toEqual(['Note']);
+  });
+});
diff --git a/packages/wikilinks/tsconfig.json b/packages/wikilinks/tsconfig.json
new file mode 100644
index 0000000..e66c4fe
--- /dev/null
+++ b/packages/wikilinks/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}
diff --git a/packages/wikilinks/vitest.config.ts b/packages/wikilinks/vitest.config.ts
new file mode 100644
index 0000000..8996a04
--- /dev/null
+++ b/packages/wikilinks/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 0278c11..611d133 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -32,6 +32,9 @@ importers:
 
   apps/desktop:
     dependencies:
+      '@codemirror/autocomplete':
+        specifier: ^6.20.0
+        version: 6.20.0
       '@codemirror/commands':
         specifier: ^6.10.1
         version: 6.10.1
@@ -53,9 +56,15 @@ importers:
       '@lezer/highlight':
         specifier: ^1.2.3
         version: 1.2.3
+      '@readied/commands':
+        specifier: workspace:*
+        version: link:../../packages/commands
       '@readied/core':
         specifier: workspace:*
         version: link:../../packages/core
+      '@readied/embeds':
+        specifier: workspace:*
+        version: link:../../packages/embeds
       '@readied/licensing':
         specifier: workspace:*
         version: link:../../packages/licensing
@@ -68,6 +77,12 @@ importers:
       '@readied/storage-sqlite':
         specifier: workspace:*
         version: link:../../packages/storage-sqlite
+      '@readied/tasks':
+        specifier: workspace:*
+        version: link:../../packages/tasks
+      '@readied/wikilinks':
+        specifier: workspace:*
+        version: link:../../packages/wikilinks
       '@tanstack/react-query':
         specifier: ^5.90.16
         version: 5.90.16(react@18.3.1)
@@ -176,8 +191,29 @@ importers:
         specifier: ^1.2.64
         version: 1.2.64
 
+  packages/commands:
+    devDependencies:
+      '@codemirror/commands':
+        specifier: ^6.10.1
+        version: 6.10.1
+      '@codemirror/state':
+        specifier: ^6.5.3
+        version: 6.5.3
+      '@codemirror/view':
+        specifier: ^6.39.8
+        version: 6.39.8
+      typescript:
+        specifier: ^5.7.2
+        version: 5.9.3
+      vitest:
+        specifier: ^2.1.8
+        version: 2.1.9(@types/node@22.19.3)
+
   packages/core:
     dependencies:
+      '@readied/wikilinks':
+        specifier: workspace:*
+        version: link:../wikilinks
       zod:
         specifier: ^3.24.1
         version: 3.25.76
@@ -189,6 +225,22 @@ importers:
         specifier: ^2.1.8
         version: 2.1.9(@types/node@22.19.3)
 
+  packages/embeds:
+    dependencies:
+      unist-util-visit:
+        specifier: ^5.0.0
+        version: 5.0.0
+    devDependencies:
+      '@types/mdast':
+        specifier: ^4.0.4
+        version: 4.0.4
+      typescript:
+        specifier: ^5.7.2
+        version: 5.9.3
+      vitest:
+        specifier: ^2.1.8
+        version: 2.1.9(@types/node@22.19.3)
+
   packages/licensing:
     dependencies:
       '@noble/ed25519':
@@ -249,6 +301,43 @@ importers:
         specifier: ^2.1.8
         version: 2.1.9(@types/node@22.19.3)
 
+  packages/tasks:
+    devDependencies:
+      typescript:
+        specifier: ^5.7.2
+        version: 5.9.3
+      vitest:
+        specifier: ^2.1.8
+        version: 2.1.9(@types/node@22.19.3)
+
+  packages/wikilinks:
+    dependencies:
+      unified:
+        specifier: ^11.0.0
+        version: 11.0.5
+      unist-util-visit:
+        specifier: ^5.0.0
+        version: 5.0.0
+    devDependencies:
+      '@codemirror/autocomplete':
+        specifier: ^6.20.0
+        version: 6.20.0
+      '@codemirror/state':
+        specifier: ^6.5.3
+        version: 6.5.3
+      '@codemirror/view':
+        specifier: ^6.39.8
+        version: 6.39.8
+      '@types/mdast':
+        specifier: ^4.0.4
+        version: 4.0.4
+      typescript:
+        specifier: ^5.7.2
+        version: 5.9.3
+      vitest:
+        specifier: ^2.1.8
+        version: 2.1.9(@types/node@22.19.3)
+
 packages:
 
   7zip-bin@5.2.0: