diff --git a/apps/vscode-extension/images/annotation-gutter.svg b/apps/vscode-extension/images/annotation-gutter.svg
new file mode 100644
index 00000000..47dd2964
--- /dev/null
+++ b/apps/vscode-extension/images/annotation-gutter.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <circle cx="8" cy="8" r="5" fill="#f5a623" fill-opacity="0.85" stroke="#e8951a" stroke-width="1"/>
+</svg>
diff --git a/apps/vscode-extension/package.json b/apps/vscode-extension/package.json
index 599ecd63..c2983230 100644
--- a/apps/vscode-extension/package.json
+++ b/apps/vscode-extension/package.json
@@ -31,8 +31,53 @@
       {
         "command": "plannotator-webview.openUrl",
         "title": "Plannotator: Open URL in Editor"
+      },
+      {
+        "command": "plannotator-webview.addEditorAnnotation",
+        "title": "Plannotator: Add Annotation"
+      },
+      {
+        "command": "plannotator-webview.submitComment",
+        "title": "Submit Annotation",
+        "icon": "$(check)"
+      },
+      {
+        "command": "plannotator-webview.deleteEditorAnnotation",
+        "title": "Delete Annotation",
+        "icon": "$(trash)"
       }
     ],
+    "keybindings": [
+      {
+        "command": "plannotator-webview.addEditorAnnotation",
+        "key": "ctrl+shift+.",
+        "mac": "cmd+shift+.",
+        "when": "editorHasSelection"
+      }
+    ],
+    "menus": {
+      "editor/context": [
+        {
+          "command": "plannotator-webview.addEditorAnnotation",
+          "when": "editorHasSelection",
+          "group": "plannotator"
+        }
+      ],
+      "comments/commentThread/title": [
+        {
+          "command": "plannotator-webview.deleteEditorAnnotation",
+          "group": "inline",
+          "when": "commentController == plannotator && commentThread == plannotator-thread"
+        }
+      ],
+      "comments/commentThread/context": [
+        {
+          "command": "plannotator-webview.submitComment",
+          "group": "inline",
+          "when": "commentController == plannotator"
+        }
+      ]
+    },
     "configuration": {
       "title": "Plannotator",
       "properties": {
diff --git a/apps/vscode-extension/src/cookie-proxy.ts b/apps/vscode-extension/src/cookie-proxy.ts
index 82c7df89..77f09488 100644
--- a/apps/vscode-extension/src/cookie-proxy.ts
+++ b/apps/vscode-extension/src/cookie-proxy.ts
@@ -1,5 +1,6 @@
 import * as http from "http";
 import { EventEmitter } from "events";
+import { buildThemeListenerScript } from "./vscode-theme";
 
 export interface CookieProxyOptions {
   loadCookies: () => string;
@@ -144,10 +145,11 @@ function parseCookieString(str: string): Record<string, string> {
 
 function injectScript(html: string, savedCookies: string): string {
   const initial = JSON.stringify(parseCookieString(savedCookies));
+  const themeListener = buildThemeListenerScript();
 
   // Virtual cookie jar: overrides document.cookie so plannotator works even
   // when the browser blocks third-party cookies inside the iframe.
-  const script = `<script>(function(){
+  const script = themeListener + `<script>(function(){
       var S=${initial};S["plannotator-auto-close"]="true";
       Object.defineProperty(document,"cookie",{configurable:true,
         get:function(){return Object.keys(S).map(function(k){return k+"="+S[k]}).join("; ");},
diff --git a/apps/vscode-extension/src/editor-annotations.ts b/apps/vscode-extension/src/editor-annotations.ts
new file mode 100644
index 00000000..ac81d2a4
--- /dev/null
+++ b/apps/vscode-extension/src/editor-annotations.ts
@@ -0,0 +1,320 @@
+/**
+ * Editor Annotations — VS Code side.
+ *
+ * Uses CommentController for inline comment threads, CodeActionProvider
+ * for lightbulb discoverability, and decorations for visual highlighting.
+ * POSTs captured selections to the plannotator server through the cookie proxy.
+ */
+
+import * as vscode from "vscode";
+import * as path from "path";
+import * as http from "http";
+
+// ── State ──────────────────────────────────────────────────────────
+
+let activeProxyPort: number | null = null;
+let commentController: vscode.CommentController | null = null;
+let annotationDecorationType: vscode.TextEditorDecorationType | null = null;
+
+/** Map of CommentThread → server-side annotation id */
+const threadIds = new Map<vscode.CommentThread, string>();
+
+/** Map of file URI string → decorated ranges */
+const decoratedRanges = new Map<string, vscode.Range[]>();
+
+// ── Public API ─────────────────────────────────────────────────────
+
+export function setActiveProxyPort(port: number | null): void {
+  activeProxyPort = port;
+  if (port !== null) {
+    createController();
+  } else {
+    disposeAllThreads();
+    clearAllDecorations();
+    if (commentController) {
+      commentController.dispose();
+      commentController = null;
+    }
+  }
+}
+
+function createController(): void {
+  if (commentController) return;
+
+  commentController = vscode.comments.createCommentController(
+    "plannotator",
+    "Plannotator",
+  );
+
+  // No commentingRangeProvider — we don't show the + gutter icons on every line.
+  // Users create annotations via keyboard shortcut, right-click, or lightbulb.
+
+  commentController.options = {
+    prompt: "Add annotation comment (optional)",
+    placeHolder: "Your comment...",
+  };
+}
+
+export function registerEditorAnnotationCommand(
+  context: vscode.ExtensionContext,
+  log: vscode.LogOutputChannel,
+): void {
+  // Create decoration type with gutter icon
+  const gutterIconPath = vscode.Uri.file(
+    path.join(context.extensionPath, "images", "annotation-gutter.svg"),
+  );
+
+  annotationDecorationType = vscode.window.createTextEditorDecorationType({
+    backgroundColor: "rgba(255, 180, 50, 0.15)",
+    isWholeLine: true,
+    borderWidth: "0 0 0 4px",
+    borderStyle: "solid",
+    borderColor: "rgba(255, 180, 50, 0.7)",
+    overviewRulerColor: "rgba(255, 180, 50, 0.7)",
+    overviewRulerLane: vscode.OverviewRulerLane.Left,
+    gutterIconPath,
+    gutterIconSize: "contain",
+  });
+
+  // Submit handler — registered as a command so it works with the comment widget
+  const submitCommand = vscode.commands.registerCommand(
+    "plannotator-webview.submitComment",
+    async (reply: vscode.CommentReply) => {
+      if (activeProxyPort === null) return;
+
+      const thread = reply.thread;
+      const range = thread.range;
+      if (!range) return;
+
+      const document = await vscode.workspace.openTextDocument(thread.uri);
+      const selectedText = document.getText(range);
+      const filePath = vscode.workspace.asRelativePath(thread.uri, false);
+      const lineStart = range.start.line + 1;
+      const lineEnd = range.end.line + 1;
+
+      try {
+        const body = JSON.stringify({
+          filePath,
+          selectedText,
+          lineStart,
+          lineEnd,
+          comment: reply.text || undefined,
+        });
+
+        const responseBody = await requestProxy(
+          activeProxyPort,
+          "POST",
+          "/api/editor-annotation",
+          body,
+        );
+        const { id } = JSON.parse(responseBody);
+
+        // Set thread to preview mode with the comment
+        const comment: vscode.Comment = {
+          body: reply.text || "_(no comment)_",
+          mode: vscode.CommentMode.Preview,
+          author: { name: "You" },
+        };
+        thread.comments = [comment];
+        thread.canReply = false;
+        thread.contextValue = "plannotator-thread";
+        threadIds.set(thread, id);
+
+        // Add decoration
+        addDecoration(thread.uri, range);
+
+        log.info(
+          `[editor-annotation] added: ${filePath}:${lineStart}-${lineEnd}`,
+        );
+      } catch (err) {
+        log.error(`[editor-annotation] failed: ${err}`);
+        vscode.window.showErrorMessage(
+          "Plannotator: Failed to add annotation",
+        );
+        thread.dispose();
+      }
+    },
+  );
+  context.subscriptions.push(submitCommand);
+
+  // ── Delete command ─────────────────────────────────────────────
+
+  const deleteCommand = vscode.commands.registerCommand(
+    "plannotator-webview.deleteEditorAnnotation",
+    async (thread: vscode.CommentThread) => {
+      if (activeProxyPort === null) return;
+
+      const id = threadIds.get(thread);
+      if (id) {
+        try {
+          await requestProxy(
+            activeProxyPort,
+            "DELETE",
+            `/api/editor-annotation?id=${encodeURIComponent(id)}`,
+          );
+        } catch (err) {
+          log.error(`[editor-annotation] delete failed: ${err}`);
+        }
+        threadIds.delete(thread);
+      }
+
+      if (thread.range) {
+        removeDecoration(thread.uri, thread.range);
+      }
+      thread.dispose();
+    },
+  );
+  context.subscriptions.push(deleteCommand);
+
+  // ── Add Annotation command (keyboard shortcut / context menu) ──
+
+  const addCommand = vscode.commands.registerCommand(
+    "plannotator-webview.addEditorAnnotation",
+    async () => {
+      if (activeProxyPort === null) {
+        vscode.window.showInformationMessage(
+          "No active Plannotator session. Open a plan review first.",
+        );
+        return;
+      }
+
+      const editor = vscode.window.activeTextEditor;
+      if (!editor || editor.selection.isEmpty) {
+        vscode.window.showInformationMessage(
+          "Select text in the editor first.",
+        );
+        return;
+      }
+
+      // Create a comment thread at the selection — opens expanded with input ready
+      const range = new vscode.Range(
+        editor.selection.start,
+        editor.selection.end,
+      );
+      const thread = commentController!.createCommentThread(editor.document.uri, range, []);
+      thread.collapsibleState = vscode.CommentThreadCollapsibleState.Expanded;
+    },
+  );
+  context.subscriptions.push(addCommand);
+
+  // ── CodeActionProvider (lightbulb menu) ────────────────────────
+
+  const codeActionProvider = vscode.languages.registerCodeActionsProvider(
+    "*",
+    {
+      provideCodeActions(document, range) {
+        if (activeProxyPort === null || range.isEmpty) return [];
+
+        const action = new vscode.CodeAction(
+          "Plannotator: Annotate Selection",
+          vscode.CodeActionKind.RefactorInline,
+        );
+        action.command = {
+          command: "plannotator-webview.addEditorAnnotation",
+          title: "Plannotator: Annotate Selection",
+        };
+        return [action];
+      },
+    },
+    { providedCodeActionKinds: [vscode.CodeActionKind.RefactorInline] },
+  );
+  context.subscriptions.push(codeActionProvider);
+
+  // Refresh decorations when switching editor tabs
+  context.subscriptions.push(
+    vscode.window.onDidChangeActiveTextEditor((editor) => {
+      if (editor) refreshDecorations(editor);
+    }),
+  );
+}
+
+// ── Decoration helpers ─────────────────────────────────────────────
+
+function addDecoration(uri: vscode.Uri, range: vscode.Range): void {
+  const key = uri.toString();
+  const ranges = decoratedRanges.get(key) ?? [];
+  ranges.push(range);
+  decoratedRanges.set(key, ranges);
+
+  // Apply to visible editor if it matches
+  const editor = vscode.window.visibleTextEditors.find(
+    (e) => e.document.uri.toString() === key,
+  );
+  if (editor) refreshDecorations(editor);
+}
+
+function removeDecoration(uri: vscode.Uri, range: vscode.Range): void {
+  const key = uri.toString();
+  const ranges = decoratedRanges.get(key);
+  if (!ranges) return;
+
+  const idx = ranges.findIndex(
+    (r) => r.isEqual(range),
+  );
+  if (idx !== -1) ranges.splice(idx, 1);
+  if (ranges.length === 0) decoratedRanges.delete(key);
+
+  const editor = vscode.window.visibleTextEditors.find(
+    (e) => e.document.uri.toString() === key,
+  );
+  if (editor) refreshDecorations(editor);
+}
+
+function refreshDecorations(editor: vscode.TextEditor): void {
+  if (!annotationDecorationType) return;
+  const uri = editor.document.uri.toString();
+  const ranges = decoratedRanges.get(uri) ?? [];
+  editor.setDecorations(annotationDecorationType, ranges);
+}
+
+function clearAllDecorations(): void {
+  if (!annotationDecorationType) return;
+  for (const editor of vscode.window.visibleTextEditors) {
+    editor.setDecorations(annotationDecorationType, []);
+  }
+  decoratedRanges.clear();
+}
+
+// ── Thread helpers ─────────────────────────────────────────────────
+
+function disposeAllThreads(): void {
+  for (const [thread] of threadIds) {
+    thread.dispose();
+  }
+  threadIds.clear();
+}
+
+// ── HTTP helpers ───────────────────────────────────────────────────
+
+function requestProxy(
+  port: number,
+  method: string,
+  urlPath: string,
+  body?: string,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const headers: Record<string, string | number> = {};
+    if (body) {
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = Buffer.byteLength(body);
+    }
+
+    const req = http.request(
+      { hostname: "127.0.0.1", port, path: urlPath, method, headers },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk: string) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(data);
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
diff --git a/apps/vscode-extension/src/extension.ts b/apps/vscode-extension/src/extension.ts
index e000fe2a..7c189b77 100644
--- a/apps/vscode-extension/src/extension.ts
+++ b/apps/vscode-extension/src/extension.ts
@@ -3,6 +3,7 @@ import * as path from "path";
 import { createIpcServer } from "./ipc-server";
 import { createCookieProxy } from "./cookie-proxy";
 import { PanelManager } from "./panel-manager";
+import { setActiveProxyPort, registerEditorAnnotationCommand } from "./editor-annotations";
 
 const COOKIE_KEY = "plannotator-cookies";
 
@@ -33,12 +34,16 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     });
 
     const panel = await panelManager.open(proxy.rewriteUrl(url));
+    setActiveProxyPort(proxy.port);
 
     // Auto-close this specific panel when plannotator signals completion
     proxy.events.on("close", () => panel.dispose());
 
-    // Clean up proxy server when the panel is closed
-    panel.onDidDispose(() => proxy.server.close());
+    // Clean up proxy server and editor annotations state when the panel is closed
+    panel.onDidDispose(() => {
+      proxy.server.close();
+      setActiveProxyPort(null);
+    });
 
     vscode.window.showInformationMessage("Plannotator panel opened");
   };
@@ -90,6 +95,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     },
   );
   context.subscriptions.push(openCommand);
+
+  // Register editor annotation command
+  registerEditorAnnotationCommand(context, log);
 }
 
 export function deactivate(): void {}
diff --git a/apps/vscode-extension/src/panel-manager.ts b/apps/vscode-extension/src/panel-manager.ts
index d475184a..46541a1d 100644
--- a/apps/vscode-extension/src/panel-manager.ts
+++ b/apps/vscode-extension/src/panel-manager.ts
@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 import * as path from "path";
+import { buildWrapperThemeScript } from "./vscode-theme";
 
 export class PanelManager {
   private panels: Set<vscode.WebviewPanel> = new Set();
@@ -39,13 +40,14 @@ export class PanelManager {
 }
 
 function getHtml(url: string, origin: string): string {
+  const themeScript = buildWrapperThemeScript();
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <meta http-equiv="Content-Security-Policy"
-        content="default-src 'none'; style-src 'unsafe-inline'; frame-src ${origin};">
+        content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; frame-src ${origin};">
   <style>
     body { margin: 0; padding: 0; height: 100vh; display: flex; flex-direction: column; overflow: hidden; }
     iframe { flex: 1; width: 100%; border: none; }
@@ -53,6 +55,7 @@ function getHtml(url: string, origin: string): string {
 </head>
 <body>
   <iframe src="${url}"></iframe>
+  ${themeScript}
 </body>
 </html>`;
 }
diff --git a/apps/vscode-extension/src/vscode-theme.ts b/apps/vscode-extension/src/vscode-theme.ts
new file mode 100644
index 00000000..b2851ada
--- /dev/null
+++ b/apps/vscode-extension/src/vscode-theme.ts
@@ -0,0 +1,105 @@
+/**
+ * VS Code Theme Bridge
+ *
+ * Maps VS Code CSS custom properties to Plannotator's CSS variable system.
+ * Used by the cookie proxy to inject a theme listener into the webview iframe,
+ * and by the panel manager to read+send theme tokens from the wrapper page.
+ */
+
+// Each VS Code CSS variable can map to multiple Plannotator variables
+// (e.g., editor foreground → foreground, card-foreground, popover-foreground).
+const TOKEN_PAIRS: [string, string][] = [
+  ["--vscode-editor-background", "--background"],
+  ["--vscode-editor-foreground", "--foreground"],
+  ["--vscode-sideBar-background", "--card"],
+  ["--vscode-editor-foreground", "--card-foreground"],
+  ["--vscode-editorWidget-background", "--popover"],
+  ["--vscode-editor-foreground", "--popover-foreground"],
+  ["--vscode-button-background", "--primary"],
+  ["--vscode-button-foreground", "--primary-foreground"],
+  ["--vscode-input-background", "--input"],
+  ["--vscode-panel-border", "--border"],
+  ["--vscode-focusBorder", "--ring"],
+  ["--vscode-errorForeground", "--destructive"],
+  ["--vscode-testing-iconPassed", "--success"],
+  ["--vscode-editorWarning-foreground", "--warning"],
+  ["--vscode-textLink-foreground", "--accent"],
+  ["--vscode-descriptionForeground", "--muted-foreground"],
+];
+
+/** VS Code variable names the wrapper page needs to read */
+export const VSCODE_VARS = [...new Set(TOKEN_PAIRS.map(([v]) => v))];
+
+/**
+ * Returns inline JS for the wrapper page (panel-manager.ts).
+ * Reads VS Code CSS variables and posts them to the iframe.
+ */
+export function buildWrapperThemeScript(): string {
+  const varsJson = JSON.stringify(VSCODE_VARS);
+  return `<script>(function(){
+  var vars=${varsJson};
+  function readTheme(){
+    var s=getComputedStyle(document.documentElement);
+    var t={};
+    for(var i=0;i<vars.length;i++){
+      var v=s.getPropertyValue(vars[i]).trim();
+      if(v)t[vars[i]]=v;
+    }
+    var kind=document.body.getAttribute("data-vscode-theme-kind")||"vscode-dark";
+    return{type:"plannotator-vscode-theme",tokens:t,themeKind:kind};
+  }
+  function send(){
+    var f=document.querySelector("iframe");
+    if(f&&f.contentWindow)f.contentWindow.postMessage(readTheme(),"*");
+  }
+  window.addEventListener("load",function(){send();setTimeout(send,300);});
+  var ob=new MutationObserver(function(){send();});
+  ob.observe(document.documentElement,{attributes:true,attributeFilter:["style","class"]});
+  ob.observe(document.body,{attributes:true,attributeFilter:["data-vscode-theme-kind"]});
+})();</script>`;
+}
+
+/**
+ * Returns inline JS injected into the iframe HTML (via cookie proxy).
+ * Listens for theme messages from the wrapper and applies CSS overrides.
+ */
+export function buildThemeListenerScript(): string {
+  const pairsJson = JSON.stringify(TOKEN_PAIRS);
+  return `<script>(function(){
+  window.__PLANNOTATOR_VSCODE=true;
+  var pairs=${pairsJson};
+  function hexToComponents(h){
+    h=h.replace("#","");
+    if(h.length===3)h=h[0]+h[0]+h[1]+h[1]+h[2]+h[2];
+    return[parseInt(h.slice(0,2),16),parseInt(h.slice(2,4),16),parseInt(h.slice(4,6),16)];
+  }
+  function adjustBrightness(color,amount){
+    if(!color)return null;
+    var c=hexToComponents(color);
+    var r=Math.min(255,Math.max(0,c[0]+amount));
+    var g=Math.min(255,Math.max(0,c[1]+amount));
+    var b=Math.min(255,Math.max(0,c[2]+amount));
+    return"rgb("+r+","+g+","+b+")";
+  }
+  window.addEventListener("message",function(e){
+    if(!e.data||e.data.type!=="plannotator-vscode-theme")return;
+    var tokens=e.data.tokens;
+    var kind=e.data.themeKind;
+    var root=document.documentElement;
+    for(var i=0;i<pairs.length;i++){
+      var val=tokens[pairs[i][0]];
+      if(val)root.style.setProperty(pairs[i][1],val);
+    }
+    var bg=tokens["--vscode-editor-background"];
+    if(bg){
+      var isDark=kind==="vscode-dark"||kind==="vscode-high-contrast";
+      var muted=adjustBrightness(bg,isDark?20:-20);
+      if(muted)root.style.setProperty("--muted",muted);
+    }
+    root.classList.remove("light");
+    if(kind==="vscode-light"||kind==="vscode-high-contrast-light"){
+      root.classList.add("light");
+    }
+  });
+})();</script>`;
+}
diff --git a/packages/editor/App.tsx b/packages/editor/App.tsx
index a4407ee0..676a0763 100644
--- a/packages/editor/App.tsx
+++ b/packages/editor/App.tsx
@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useMemo, useRef } from 'react';
-import { parseMarkdownToBlocks, exportAnnotations, exportLinkedDocAnnotations, extractFrontmatter, Frontmatter } from '@plannotator/ui/utils/parser';
+import { parseMarkdownToBlocks, exportAnnotations, exportLinkedDocAnnotations, exportEditorAnnotations, extractFrontmatter, Frontmatter } from '@plannotator/ui/utils/parser';
 import { Viewer, ViewerHandle } from '@plannotator/ui/components/Viewer';
 import { AnnotationPanel } from '@plannotator/ui/components/AnnotationPanel';
 import { ExportModal } from '@plannotator/ui/components/ExportModal';
@@ -47,6 +47,7 @@ import { usePlanDiff, type VersionInfo } from '@plannotator/ui/hooks/usePlanDiff
 import { useLinkedDoc } from '@plannotator/ui/hooks/useLinkedDoc';
 import { useVaultBrowser } from '@plannotator/ui/hooks/useVaultBrowser';
 import { useAnnotationDraft } from '@plannotator/ui/hooks/useAnnotationDraft';
+import { useEditorAnnotations } from '@plannotator/ui/hooks/useEditorAnnotations';
 import { isVaultBrowserEnabled } from '@plannotator/ui/utils/obsidian';
 import { SidebarTabs } from '@plannotator/ui/components/sidebar/SidebarTabs';
 import { SidebarContainer } from '@plannotator/ui/components/sidebar/SidebarContainer';
@@ -563,6 +564,8 @@ const App: React.FC = () => {
     submitted: !!submitted,
   });
 
+  const { editorAnnotations, deleteEditorAnnotation } = useEditorAnnotations();
+
   const handleRestoreDraft = React.useCallback(() => {
     const { annotations: restored, globalAttachments: restoredGlobal } = restoreDraft();
     if (restored.length > 0) {
@@ -822,7 +825,7 @@ const App: React.FC = () => {
       const hasDocAnnotations = Array.from(linkedDocHook.getDocAnnotations().values()).some(
         (d) => d.annotations.length > 0 || d.globalAttachments.length > 0
       );
-      if (annotations.length > 0 || globalAttachments.length > 0 || hasDocAnnotations) {
+      if (annotations.length > 0 || globalAttachments.length > 0 || hasDocAnnotations || editorAnnotations.length > 0) {
         body.feedback = annotationsOutput;
       }
 
@@ -912,7 +915,7 @@ const App: React.FC = () => {
       }
 
       // No annotations → Approve, otherwise → Send Feedback
-      if (annotations.length === 0) {
+      if (annotations.length === 0 && editorAnnotations.length === 0) {
         // Check if agent exists for OpenCode users
         if (origin === 'opencode') {
           const warning = getAgentWarning();
@@ -981,8 +984,9 @@ const App: React.FC = () => {
       (d) => d.annotations.length > 0 || d.globalAttachments.length > 0
     );
     const hasPlanAnnotations = annotations.length > 0 || globalAttachments.length > 0;
+    const hasEditorAnnotations = editorAnnotations.length > 0;
 
-    if (!hasPlanAnnotations && !hasDocAnnotations) {
+    if (!hasPlanAnnotations && !hasDocAnnotations && !hasEditorAnnotations) {
       return 'No changes detected.';
     }
 
@@ -994,8 +998,12 @@ const App: React.FC = () => {
       output += exportLinkedDocAnnotations(docAnnotations);
     }
 
+    if (hasEditorAnnotations) {
+      output += exportEditorAnnotations(editorAnnotations);
+    }
+
     return output;
-  }, [blocks, annotations, globalAttachments, linkedDocHook.getDocAnnotations]);
+  }, [blocks, annotations, globalAttachments, linkedDocHook.getDocAnnotations, editorAnnotations]);
 
   // Quick-save handlers for export dropdown and keyboard shortcut
   const handleDownloadAnnotations = () => {
@@ -1152,7 +1160,7 @@ const App: React.FC = () => {
               <>
                 <button
                   onClick={() => {
-                    if (annotations.length === 0) {
+                    if (annotations.length === 0 && editorAnnotations.length === 0) {
                       setShowFeedbackPrompt(true);
                     } else if (annotateMode) {
                       handleAnnotateFeedback();
@@ -1485,6 +1493,8 @@ const App: React.FC = () => {
             shareUrl={shareUrl}
             sharingEnabled={sharingEnabled}
             width={panelResize.width}
+            editorAnnotations={editorAnnotations}
+            onDeleteEditorAnnotation={deleteEditorAnnotation}
           />
         </div>
 
diff --git a/packages/review-editor/App.tsx b/packages/review-editor/App.tsx
index 50435d3a..0357a855 100644
--- a/packages/review-editor/App.tsx
+++ b/packages/review-editor/App.tsx
@@ -11,6 +11,8 @@ import { getAgentSwitchSettings, getEffectiveAgentName } from '@plannotator/ui/u
 import { CodeAnnotation, CodeAnnotationType, SelectedLineRange } from '@plannotator/ui/types';
 import { useResizablePanel } from '@plannotator/ui/hooks/useResizablePanel';
 import { useCodeAnnotationDraft } from '@plannotator/ui/hooks/useCodeAnnotationDraft';
+import { useEditorAnnotations } from '@plannotator/ui/hooks/useEditorAnnotations';
+import { exportEditorAnnotations } from '@plannotator/ui/utils/parser';
 import { ResizeHandle } from '@plannotator/ui/components/ResizeHandle';
 import { DiffViewer } from './components/DiffViewer';
 import { ReviewPanel } from './components/ReviewPanel';
@@ -172,6 +174,9 @@ const ReviewApp: React.FC = () => {
     if (restored.length > 0) setAnnotations(restored);
   }, [restoreDraft]);
 
+  // VS Code editor annotations (only polls when inside VS Code webview)
+  const { editorAnnotations, deleteEditorAnnotation } = useEditorAnnotations();
+
   // Resizable panels
   const panelResize = useResizablePanel({ storageKey: 'plannotator-review-panel-width' });
   const fileTreeResize = useResizablePanel({
@@ -449,15 +454,25 @@ const ReviewApp: React.FC = () => {
     }
   }, [annotations, files]);
 
+  const activeFile = files[activeFileIndex];
+  const feedbackMarkdown = useMemo(() => {
+    let output = exportReviewFeedback(annotations, files);
+    if (editorAnnotations.length > 0) {
+      output += exportEditorAnnotations(editorAnnotations);
+    }
+    return output;
+  }, [annotations, files, editorAnnotations]);
+
+  const totalAnnotationCount = annotations.length + editorAnnotations.length;
+
   // Send feedback to OpenCode via API
   const handleSendFeedback = useCallback(async () => {
-    if (annotations.length === 0) {
+    if (totalAnnotationCount === 0) {
       setShowNoAnnotationsDialog(true);
       return;
     }
     setIsSendingFeedback(true);
     try {
-      const feedback = exportReviewFeedback(annotations, files);
       const agentSwitchSettings = getAgentSwitchSettings();
       const effectiveAgent = getEffectiveAgentName(agentSwitchSettings);
 
@@ -465,7 +480,7 @@ const ReviewApp: React.FC = () => {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          feedback,
+          feedback: feedbackMarkdown,
           annotations,
           ...(effectiveAgent && { agentSwitch: effectiveAgent }),
         }),
@@ -481,7 +496,7 @@ const ReviewApp: React.FC = () => {
       setTimeout(() => setCopyFeedback(null), 2000);
       setIsSendingFeedback(false);
     }
-  }, [annotations, files]);
+  }, [totalAnnotationCount, feedbackMarkdown, annotations]);
 
   // Approve without feedback (LGTM)
   const handleApprove = useCallback(async () => {
@@ -522,7 +537,7 @@ const ReviewApp: React.FC = () => {
       e.preventDefault();
 
       // No annotations → Approve, otherwise → Send Feedback
-      if (annotations.length === 0) {
+      if (totalAnnotationCount === 0) {
         handleApprove();
       } else {
         handleSendFeedback();
@@ -533,16 +548,10 @@ const ReviewApp: React.FC = () => {
     return () => window.removeEventListener('keydown', handleKeyDown);
   }, [
     showExportModal, showNoAnnotationsDialog, showApproveWarning,
-    submitted, isSendingFeedback, isApproving, origin, annotations.length,
+    submitted, isSendingFeedback, isApproving, origin, totalAnnotationCount,
     handleApprove, handleSendFeedback
   ]);
 
-  const activeFile = files[activeFileIndex];
-  const feedbackMarkdown = useMemo(() =>
-    exportReviewFeedback(annotations, files),
-    [annotations, files]
-  );
-
   if (isLoading) {
     return (
       <ThemeProvider defaultTheme="dark">
@@ -650,15 +659,15 @@ const ReviewApp: React.FC = () => {
                 {/* Send Feedback button - accent color, disabled if no annotations */}
                 <button
                   onClick={handleSendFeedback}
-                  disabled={isSendingFeedback || isApproving || annotations.length === 0}
+                  disabled={isSendingFeedback || isApproving || totalAnnotationCount === 0}
                   className={`p-1.5 md:px-2.5 md:py-1 rounded-md text-xs font-medium transition-all ${
                     isSendingFeedback || isApproving
                       ? 'opacity-50 cursor-not-allowed bg-muted text-muted-foreground'
-                      : annotations.length === 0
+                      : totalAnnotationCount === 0
                         ? 'opacity-50 cursor-not-allowed bg-accent/10 text-accent/50'
                         : 'bg-accent/15 text-accent hover:bg-accent/25 border border-accent/30'
                   }`}
-                  title={annotations.length === 0 ? "Add annotations to send feedback" : "Send feedback"}
+                  title={totalAnnotationCount === 0 ? "Add annotations to send feedback" : "Send feedback"}
                 >
                   <svg className="w-4 h-4 md:hidden" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
                     <path strokeLinecap="round" strokeLinejoin="round" d="M8 12h.01M12 12h.01M16 12h.01M21 12c0 4.418-4.03 8-9 8a9.863 9.863 0 01-4.255-.949L3 20l1.395-3.72C3.512 15.042 3 13.574 3 12c0-4.418 4.03-8 9-8s9 3.582 9 8z" />
@@ -670,7 +679,7 @@ const ReviewApp: React.FC = () => {
                 <div className="relative group/approve">
                   <button
                     onClick={() => {
-                      if (annotations.length > 0) {
+                      if (totalAnnotationCount > 0) {
                         setShowApproveWarning(true);
                       } else {
                         handleApprove();
@@ -680,7 +689,7 @@ const ReviewApp: React.FC = () => {
                     className={`px-2 py-1 md:px-2.5 rounded-md text-xs font-medium transition-all ${
                       isSendingFeedback || isApproving
                         ? 'opacity-50 cursor-not-allowed bg-muted text-muted-foreground'
-                        : annotations.length > 0
+                        : totalAnnotationCount > 0
                           ? 'bg-success/50 text-success-foreground/70 hover:bg-success hover:text-success-foreground'
                           : 'bg-success text-success-foreground hover:opacity-90'
                     }`}
@@ -689,11 +698,11 @@ const ReviewApp: React.FC = () => {
                     <span className="md:hidden">{isApproving ? '...' : 'OK'}</span>
                     <span className="hidden md:inline">{isApproving ? 'Approving...' : 'Approve'}</span>
                   </button>
-                  {annotations.length > 0 && (
+                  {totalAnnotationCount > 0 && (
                     <div className="absolute top-full right-0 mt-2 px-3 py-2 bg-popover border border-border rounded-lg shadow-xl text-xs text-foreground w-56 text-center opacity-0 invisible group-hover/approve:opacity-100 group-hover/approve:visible transition-all pointer-events-none z-50">
                       <div className="absolute bottom-full right-4 border-4 border-transparent border-b-border" />
                       <div className="absolute bottom-full right-4 mt-px border-4 border-transparent border-b-popover" />
-                      Your {annotations.length} annotation{annotations.length !== 1 ? 's' : ''} won't be sent if you approve.
+                      Your {totalAnnotationCount} annotation{totalAnnotationCount !== 1 ? 's' : ''} won't be sent if you approve.
                     </div>
                   )}
                 </div>
@@ -878,6 +887,8 @@ const ReviewApp: React.FC = () => {
             onDeleteAnnotation={handleDeleteAnnotation}
             feedbackMarkdown={feedbackMarkdown}
             width={panelResize.width}
+            editorAnnotations={editorAnnotations}
+            onDeleteEditorAnnotation={deleteEditorAnnotation}
           />
         </div>
 
@@ -936,7 +947,7 @@ const ReviewApp: React.FC = () => {
             handleApprove();
           }}
           title="Annotations Won't Be Sent"
-          message={<>You have {annotations.length} annotation{annotations.length !== 1 ? 's' : ''} that will be lost if you approve.</>}
+          message={<>You have {totalAnnotationCount} annotation{totalAnnotationCount !== 1 ? 's' : ''} that will be lost if you approve.</>}
           subMessage="To send your feedback, use Send Feedback instead."
           confirmText="Approve Anyway"
           cancelText="Cancel"
diff --git a/packages/review-editor/components/ReviewPanel.tsx b/packages/review-editor/components/ReviewPanel.tsx
index a7128f5d..9c199cba 100644
--- a/packages/review-editor/components/ReviewPanel.tsx
+++ b/packages/review-editor/components/ReviewPanel.tsx
@@ -1,6 +1,7 @@
 import React, { useState } from 'react';
-import { CodeAnnotation } from '@plannotator/ui/types';
+import { CodeAnnotation, type EditorAnnotation } from '@plannotator/ui/types';
 import { isCurrentUser } from '@plannotator/ui/utils/identity';
+import { EditorAnnotationCard } from '@plannotator/ui/components/EditorAnnotationCard';
 import { HighlightedCode } from './HighlightedCode';
 import { detectLanguage } from '../utils/detectLanguage';
 import { renderInlineMarkdown } from '../utils/renderInlineMarkdown';
@@ -21,6 +22,8 @@ interface ReviewPanelProps {
   onDeleteAnnotation: (id: string) => void;
   feedbackMarkdown?: string;
   width?: number;
+  editorAnnotations?: EditorAnnotation[];
+  onDeleteEditorAnnotation?: (id: string) => void;
 }
 
 const SuggestionPreview: React.FC<{ code: string; originalCode?: string; language?: string }> = ({ code, originalCode, language }) => {
@@ -75,7 +78,10 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
   onDeleteAnnotation,
   feedbackMarkdown,
   width,
+  editorAnnotations,
+  onDeleteEditorAnnotation,
 }) => {
+  const totalCount = annotations.length + (editorAnnotations?.length ?? 0);
   const [copied, setCopied] = useState(false);
 
   const handleQuickCopy = async () => {
@@ -114,14 +120,14 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
               Annotations
             </h2>
             <span className="text-[10px] font-mono bg-muted px-1.5 py-0.5 rounded text-muted-foreground">
-              {annotations.length}
+              {totalCount}
             </span>
           </div>
         </div>
 
         {/* Content */}
         <div className="flex-1 overflow-y-auto p-2 space-y-1.5">
-          {annotations.length === 0 ? (
+          {totalCount === 0 ? (
             <div className="flex flex-col items-center justify-center h-40 text-center px-4">
               <div className="w-10 h-10 rounded-full bg-muted/50 flex items-center justify-center mb-3">
                 <svg className="w-5 h-5 text-muted-foreground" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={1.5}>
@@ -208,10 +214,30 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
               ))}
             </div>
           )}
+
+          {/* Editor annotations (VS Code) */}
+          {editorAnnotations && editorAnnotations.length > 0 && (
+            <>
+              {annotations.length > 0 && (
+                <div className="flex items-center gap-2 pt-2 pb-1">
+                  <div className="flex-1 border-t border-border/30" />
+                  <span className="text-[9px] font-semibold uppercase tracking-wider text-muted-foreground/60">Editor</span>
+                  <div className="flex-1 border-t border-border/30" />
+                </div>
+              )}
+              {editorAnnotations.map(ann => (
+                <EditorAnnotationCard
+                  key={ann.id}
+                  annotation={ann}
+                  onDelete={() => onDeleteEditorAnnotation?.(ann.id)}
+                />
+              ))}
+            </>
+          )}
         </div>
 
         {/* Quick Copy Footer */}
-        {feedbackMarkdown && annotations.length > 0 && (
+        {feedbackMarkdown && totalCount > 0 && (
           <div className="p-2 border-t border-border/50">
             <button
               onClick={handleQuickCopy}
diff --git a/packages/server/editor-annotations.ts b/packages/server/editor-annotations.ts
new file mode 100644
index 00000000..cd01f2fc
--- /dev/null
+++ b/packages/server/editor-annotations.ts
@@ -0,0 +1,76 @@
+/**
+ * Editor Annotations — ephemeral in-memory store for VS Code editor selections.
+ *
+ * The VS Code extension POSTs annotations from the editor; the webview app
+ * polls to pick them up. The array lives in this closure and dies when the
+ * server stops. No disk persistence.
+ */
+
+import type { EditorAnnotation } from "@plannotator/shared/types";
+
+export type { EditorAnnotation };
+
+export interface EditorAnnotationHandler {
+  handle: (req: Request, url: URL) => Promise<Response | null>;
+}
+
+export function createEditorAnnotationHandler(): EditorAnnotationHandler {
+  const annotations: EditorAnnotation[] = [];
+
+  return {
+    async handle(req: Request, url: URL): Promise<Response | null> {
+      // GET /api/editor-annotations — return all
+      if (url.pathname === "/api/editor-annotations" && req.method === "GET") {
+        return Response.json({ annotations });
+      }
+
+      // POST /api/editor-annotation — add one
+      if (url.pathname === "/api/editor-annotation" && req.method === "POST") {
+        try {
+          const body = (await req.json()) as {
+            filePath?: string;
+            selectedText?: string;
+            lineStart?: number;
+            lineEnd?: number;
+            comment?: string;
+          };
+
+          if (!body.filePath || !body.selectedText || !body.lineStart || !body.lineEnd) {
+            return Response.json({ error: "Missing required fields" }, { status: 400 });
+          }
+
+          const annotation: EditorAnnotation = {
+            id: crypto.randomUUID(),
+            filePath: body.filePath,
+            selectedText: body.selectedText,
+            lineStart: body.lineStart,
+            lineEnd: body.lineEnd,
+            comment: body.comment,
+            createdAt: Date.now(),
+          };
+
+          annotations.push(annotation);
+          return Response.json({ id: annotation.id });
+        } catch {
+          return Response.json({ error: "Invalid JSON" }, { status: 400 });
+        }
+      }
+
+      // DELETE /api/editor-annotation?id=xxx — remove one
+      if (url.pathname === "/api/editor-annotation" && req.method === "DELETE") {
+        const id = url.searchParams.get("id");
+        if (!id) {
+          return Response.json({ error: "Missing id parameter" }, { status: 400 });
+        }
+        const idx = annotations.findIndex((a) => a.id === id);
+        if (idx !== -1) {
+          annotations.splice(idx, 1);
+        }
+        return Response.json({ ok: true });
+      }
+
+      // Not handled
+      return null;
+    },
+  };
+}
diff --git a/packages/server/index.ts b/packages/server/index.ts
index d2bddbf6..e8fe38d7 100644
--- a/packages/server/index.ts
+++ b/packages/server/index.ts
@@ -36,6 +36,7 @@ import { detectProjectName } from "./project";
 import { handleImage, handleUpload, handleAgents, handleServerReady, handleDraftSave, handleDraftLoad, handleDraftDelete, type OpencodeClient } from "./shared-handlers";
 import { contentHash, deleteDraft } from "./draft";
 import { handleDoc, handleObsidianVaults, handleObsidianFiles, handleObsidianDoc } from "./reference-handlers";
+import { createEditorAnnotationHandler } from "./editor-annotations";
 
 // Re-export utilities
 export { isRemoteSession, getServerPort } from "./remote";
@@ -109,6 +110,7 @@ export async function startPlannotatorServer(
   const isRemote = isRemoteSession();
   const configuredPort = getServerPort();
   const draftKey = contentHash(plan);
+  const editorAnnotations = createEditorAnnotationHandler();
 
   // Generate slug for potential saving (actual save happens on decision)
   const slug = generateSlug(plan);
@@ -266,6 +268,10 @@ export async function startPlannotatorServer(
             return handleDraftLoad(draftKey);
           }
 
+          // API: Editor annotations (VS Code extension)
+          const editorResponse = await editorAnnotations.handle(req, url);
+          if (editorResponse) return editorResponse;
+
           // API: Save to notes (decoupled from approve/deny)
           if (url.pathname === "/api/save-notes" && req.method === "POST") {
             const results: { obsidian?: IntegrationResult; bear?: IntegrationResult } = {};
diff --git a/packages/server/review.ts b/packages/server/review.ts
index 2b60c95e..7668e7c2 100644
--- a/packages/server/review.ts
+++ b/packages/server/review.ts
@@ -14,6 +14,7 @@ import { type DiffType, type GitContext, runGitDiff, getWorktreeDiffOptions } fr
 import { getRepoInfo } from "./repo";
 import { handleImage, handleUpload, handleAgents, handleServerReady, handleDraftSave, handleDraftLoad, handleDraftDelete, type OpencodeClient } from "./shared-handlers";
 import { contentHash, deleteDraft } from "./draft";
+import { createEditorAnnotationHandler } from "./editor-annotations";
 
 // Re-export utilities
 export { isRemoteSession, getServerPort } from "./remote";
@@ -84,6 +85,7 @@ export async function startReviewServer(
   const { htmlContent, origin, gitContext, sharingEnabled = true, shareBaseUrl, onReady } = options;
 
   const draftKey = contentHash(options.rawPatch);
+  const editorAnnotations = createEditorAnnotationHandler();
 
   // Mutable state for diff switching
   let currentPatch = options.rawPatch;
@@ -218,6 +220,10 @@ export async function startReviewServer(
             return handleDraftLoad(draftKey);
           }
 
+          // API: Editor annotations (VS Code extension)
+          const editorResponse = await editorAnnotations.handle(req, url);
+          if (editorResponse) return editorResponse;
+
           // API: Submit review feedback
           if (url.pathname === "/api/feedback" && req.method === "POST") {
             try {
diff --git a/packages/shared/types.ts b/packages/shared/types.ts
new file mode 100644
index 00000000..c5451579
--- /dev/null
+++ b/packages/shared/types.ts
@@ -0,0 +1,10 @@
+// Editor annotations from VS Code extension (ephemeral, in-memory only)
+export interface EditorAnnotation {
+  id: string;
+  filePath: string;     // workspace-relative (e.g., "src/auth.ts")
+  selectedText: string;
+  lineStart: number;    // 1-based
+  lineEnd: number;      // 1-based
+  comment?: string;
+  createdAt: number;
+}
diff --git a/packages/ui/components/AnnotationPanel.tsx b/packages/ui/components/AnnotationPanel.tsx
index ec8d7f7f..b496fd71 100644
--- a/packages/ui/components/AnnotationPanel.tsx
+++ b/packages/ui/components/AnnotationPanel.tsx
@@ -1,7 +1,8 @@
 import React, { useState, useRef, useEffect } from 'react';
-import { Annotation, AnnotationType, Block } from '../types';
+import { Annotation, AnnotationType, Block, type EditorAnnotation } from '../types';
 import { isCurrentUser } from '../utils/identity';
 import { ImageThumbnail } from './ImageThumbnail';
+import { EditorAnnotationCard } from './EditorAnnotationCard';
 
 interface PanelProps {
   isOpen: boolean;
@@ -14,6 +15,8 @@ interface PanelProps {
   shareUrl?: string;
   sharingEnabled?: boolean;
   width?: number;
+  editorAnnotations?: EditorAnnotation[];
+  onDeleteEditorAnnotation?: (id: string) => void;
 }
 
 export const AnnotationPanel: React.FC<PanelProps> = ({
@@ -27,9 +30,12 @@ export const AnnotationPanel: React.FC<PanelProps> = ({
   shareUrl,
   sharingEnabled = true,
   width,
+  editorAnnotations,
+  onDeleteEditorAnnotation,
 }) => {
   const [copied, setCopied] = useState(false);
   const sortedAnnotations = [...annotations].sort((a, b) => a.createdA - b.createdA);
+  const totalCount = annotations.length + (editorAnnotations?.length ?? 0);
 
   const handleQuickShare = async () => {
     if (!shareUrl) return;
@@ -53,14 +59,14 @@ export const AnnotationPanel: React.FC<PanelProps> = ({
             Annotations
           </h2>
           <span className="text-[10px] font-mono bg-muted px-1.5 py-0.5 rounded text-muted-foreground">
-            {annotations.length}
+            {totalCount}
           </span>
         </div>
       </div>
 
       {/* List */}
       <div className="flex-1 overflow-y-auto p-2 space-y-1.5">
-        {sortedAnnotations.length === 0 ? (
+        {totalCount === 0 ? (
           <div className="flex flex-col items-center justify-center h-40 text-center px-4">
             <div className="w-10 h-10 rounded-full bg-muted/50 flex items-center justify-center mb-3">
               <svg className="w-5 h-5 text-muted-foreground" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={1.5}>
@@ -72,21 +78,41 @@ export const AnnotationPanel: React.FC<PanelProps> = ({
             </p>
           </div>
         ) : (
-          sortedAnnotations.map(ann => (
-            <AnnotationCard
-              key={ann.id}
-              annotation={ann}
-              isSelected={selectedId === ann.id}
-              onSelect={() => onSelect(ann.id)}
-              onDelete={() => onDelete(ann.id)}
-              onEdit={onEdit ? (updates: Partial<Annotation>) => onEdit(ann.id, updates) : undefined}
-            />
-          ))
+          <>
+            {sortedAnnotations.map(ann => (
+              <AnnotationCard
+                key={ann.id}
+                annotation={ann}
+                isSelected={selectedId === ann.id}
+                onSelect={() => onSelect(ann.id)}
+                onDelete={() => onDelete(ann.id)}
+                onEdit={onEdit ? (updates: Partial<Annotation>) => onEdit(ann.id, updates) : undefined}
+              />
+            ))}
+            {editorAnnotations && editorAnnotations.length > 0 && (
+              <>
+                {sortedAnnotations.length > 0 && (
+                  <div className="flex items-center gap-2 pt-2 pb-1">
+                    <div className="flex-1 border-t border-border/30" />
+                    <span className="text-[9px] font-semibold uppercase tracking-wider text-muted-foreground/60">Editor</span>
+                    <div className="flex-1 border-t border-border/30" />
+                  </div>
+                )}
+                {editorAnnotations.map(ann => (
+                  <EditorAnnotationCard
+                    key={ann.id}
+                    annotation={ann}
+                    onDelete={() => onDeleteEditorAnnotation?.(ann.id)}
+                  />
+                ))}
+              </>
+            )}
+          </>
         )}
       </div>
 
       {/* Quick Share Footer */}
-      {sharingEnabled && shareUrl && annotations.length > 0 && (
+      {sharingEnabled && shareUrl && totalCount > 0 && (
         <div className="p-2 border-t border-border/50">
           <button
             onClick={handleQuickShare}
diff --git a/packages/ui/components/EditorAnnotationCard.tsx b/packages/ui/components/EditorAnnotationCard.tsx
new file mode 100644
index 00000000..230df7ef
--- /dev/null
+++ b/packages/ui/components/EditorAnnotationCard.tsx
@@ -0,0 +1,52 @@
+import React from 'react';
+import type { EditorAnnotation } from '../types';
+
+interface EditorAnnotationCardProps {
+  annotation: EditorAnnotation;
+  onDelete: () => void;
+}
+
+export const EditorAnnotationCard: React.FC<EditorAnnotationCardProps> = ({ annotation, onDelete }) => {
+  const lineRange = annotation.lineStart === annotation.lineEnd
+    ? `L${annotation.lineStart}`
+    : `L${annotation.lineStart}-${annotation.lineEnd}`;
+
+  return (
+    <div className="group relative p-2.5 rounded-lg border border-transparent hover:bg-muted/50 hover:border-border/50 transition-all">
+      {/* File path + line range */}
+      <div className="flex items-center justify-between mb-2">
+        <div className="flex items-center gap-1.5 min-w-0">
+          <span className="p-1 rounded bg-amber-500/10 text-amber-600 dark:text-amber-400">
+            <svg className="w-3 h-3" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+              <path strokeLinecap="round" strokeLinejoin="round" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+            </svg>
+          </span>
+          <span className="text-[10px] font-mono text-muted-foreground truncate" title={annotation.filePath}>
+            {annotation.filePath}:{lineRange}
+          </span>
+        </div>
+        <button
+          onClick={(e) => { e.stopPropagation(); onDelete(); }}
+          className="p-1 rounded hover:bg-destructive/10 text-muted-foreground hover:text-destructive transition-all opacity-0 group-hover:opacity-100"
+          title="Delete annotation"
+        >
+          <svg className="w-3 h-3" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+            <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
+          </svg>
+        </button>
+      </div>
+
+      {/* Selected text */}
+      <div className="text-[11px] font-mono text-muted-foreground bg-muted/50 rounded px-2 py-1.5 whitespace-pre-wrap max-h-24 overflow-y-auto">
+        {annotation.selectedText}
+      </div>
+
+      {/* Comment */}
+      {annotation.comment && (
+        <div className="mt-2 text-xs text-foreground/90 pl-2 border-l-2 border-amber-500/50 whitespace-pre-wrap">
+          {annotation.comment}
+        </div>
+      )}
+    </div>
+  );
+};
diff --git a/packages/ui/hooks/useEditorAnnotations.ts b/packages/ui/hooks/useEditorAnnotations.ts
new file mode 100644
index 00000000..0265be3c
--- /dev/null
+++ b/packages/ui/hooks/useEditorAnnotations.ts
@@ -0,0 +1,64 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type { EditorAnnotation } from '../types';
+
+const POLL_INTERVAL = 500;
+const IS_VSCODE = typeof window !== 'undefined' && (window as any).__PLANNOTATOR_VSCODE === true;
+
+interface UseEditorAnnotationsReturn {
+  editorAnnotations: EditorAnnotation[];
+  deleteEditorAnnotation: (id: string) => void;
+}
+
+/**
+ * Polls the server for editor annotations created by the VS Code extension.
+ *
+ * Only activates when running inside a VS Code webview (detected via
+ * window.__PLANNOTATOR_VSCODE set by the theme bridge). In browser/shared URL
+ * contexts, returns an empty array with zero network cost.
+ */
+export function useEditorAnnotations(): UseEditorAnnotationsReturn {
+  const [annotations, setAnnotations] = useState<EditorAnnotation[]>([]);
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const fetchAnnotations = useCallback(async () => {
+    try {
+      const res = await fetch('/api/editor-annotations');
+      if (!res.ok) return;
+      const data = await res.json();
+      const incoming: EditorAnnotation[] = data.annotations ?? [];
+      setAnnotations((prev) => {
+        if (prev.length === incoming.length && prev.every((a, i) => a.id === incoming[i].id)) return prev;
+        return incoming;
+      });
+    } catch {
+      // Silently fail — next poll will retry
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!IS_VSCODE) return;
+
+    // Initial fetch + start polling
+    fetchAnnotations();
+    intervalRef.current = setInterval(fetchAnnotations, POLL_INTERVAL);
+
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [fetchAnnotations]);
+
+  const deleteEditorAnnotation = useCallback(async (id: string) => {
+    if (!IS_VSCODE) return;
+    try {
+      await fetch(`/api/editor-annotation?id=${encodeURIComponent(id)}`, { method: 'DELETE' });
+      setAnnotations((prev) => prev.filter((a) => a.id !== id));
+    } catch {
+      // Silently fail — next poll will reconcile
+    }
+  }, []);
+
+  return { editorAnnotations: annotations, deleteEditorAnnotation };
+}
diff --git a/packages/ui/types.ts b/packages/ui/types.ts
index 28408bb9..1329efec 100644
--- a/packages/ui/types.ts
+++ b/packages/ui/types.ts
@@ -96,3 +96,5 @@ export interface VaultNode {
   type: "file" | "folder";
   children?: VaultNode[];
 }
+
+export type { EditorAnnotation } from '@plannotator/shared/types';
diff --git a/packages/ui/utils/parser.ts b/packages/ui/utils/parser.ts
index 655bedb1..cc77b50a 100644
--- a/packages/ui/utils/parser.ts
+++ b/packages/ui/utils/parser.ts
@@ -1,4 +1,4 @@
-import { Block, type Annotation, type ImageAttachment } from '../types';
+import { Block, type Annotation, type EditorAnnotation, type ImageAttachment } from '../types';
 
 /**
  * Parsed YAML frontmatter as key-value pairs.
@@ -392,6 +392,30 @@ export const exportLinkedDocAnnotations = (
     });
   }
 
+  output += `---\n`;
+  return output;
+};
+
+export const exportEditorAnnotations = (editorAnnotations: EditorAnnotation[]): string => {
+  if (editorAnnotations.length === 0) return '';
+
+  let output = `\n# Editor File Annotations\n\nThe following annotations reference code files in the project.\n\n`;
+
+  editorAnnotations.forEach((ann, index) => {
+    const lineRange = ann.lineStart === ann.lineEnd
+      ? `line ${ann.lineStart}`
+      : `lines ${ann.lineStart}-${ann.lineEnd}`;
+
+    output += `## ${index + 1}. ${ann.filePath} (${lineRange})\n`;
+    output += `\`\`\`\n${ann.selectedText}\n\`\`\`\n`;
+
+    if (ann.comment) {
+      output += `> ${ann.comment}\n`;
+    }
+
+    output += '\n';
+  });
+
   output += `---\n`;
   return output;
 };
\ No newline at end of file