diff --git a/.sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md b/.sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md
new file mode 100644
index 00000000..09a45a5a
--- /dev/null
+++ b/.sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md
@@ -0,0 +1,658 @@
+---
+version: 1.1.0
+status: Approved
+created: 2026-01-20
+last_updated: 2026-01-20
+authored_by:
+  - Ronald Roy <gsdwig@gmail.com>
+spec: .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md
+---
+
+# Pair Writing Mode Technical Plan
+
+## Overview
+
+This plan addresses spec v1.2.0 requirements for two complementary capabilities:
+
+1. **Quick Actions**: Transformative text actions (Tighten, Embellish, Correct, Polish) available in Browse mode's editor, working on both desktop and mobile via context menu
+2. **Pair Writing Mode**: Desktop-only split-screen with advisory actions (Validate, Critique), freeform chat, and snapshot comparison
+
+## Architecture
+
+### High-Level Component Structure
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         BrowseMode                               │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │                    MemoryEditor                            │  │
+│  │  ┌─────────────────────────────────────────────────────┐  │  │
+│  │  │              EditorContextMenu                       │  │  │
+│  │  │  (Quick Actions: Tighten, Embellish, Correct, Polish)│  │  │
+│  │  └─────────────────────────────────────────────────────┘  │  │
+│  └───────────────────────────────────────────────────────────┘  │
+│                              │                                   │
+│                    [Enter Pair Writing]                          │
+│                              ▼                                   │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │                   PairWritingMode (Desktop Only)           │  │
+│  │  ┌─────────────────┐     ┌─────────────────────────────┐  │  │
+│  │  │   Editor Pane    │     │    Conversation Pane        │  │  │
+│  │  │  (MemoryEditor)  │     │  (Reuses Discussion UI)     │  │  │
+│  │  │  + Snapshot btn  │     │  + Freeform chat input      │  │  │
+│  │  │  + Full context  │     │  + Selection context        │  │  │
+│  │  │    menu (6 items)│     │                             │  │  │
+│  │  └─────────────────┘     └─────────────────────────────┘  │  │
+│  └───────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Data Flow: Quick Actions
+
+```
+User selects text → Right-click/Long-press → Context menu appears
+        │
+        ▼
+    Select action (e.g., "Tighten")
+        │
+        ▼
+    Frontend extracts:
+      - File path, selection text, line numbers
+      - Paragraph context (before/after)
+        │
+        ▼
+    Send `quick_action_request` via WebSocket
+        │
+        ▼
+    Backend creates task-scoped Claude session:
+      - System prompt: Action-specific instructions (be efficient)
+      - Read + Edit tools available (scoped to vault)
+        │
+        ▼
+    Claude executes (typically 3-5 turns):
+      Turn 1: "I'll tighten this." → Read tool
+      Turn 2: "I see the text." → Edit tool
+      Turn 3: "Done. Removed 3 filler phrases."
+        │
+        ▼
+    Backend streams events to frontend:
+      - tool_start/tool_end (Read)
+      - tool_start/tool_end (Edit - file written)
+      - response_chunk (brief confirmation)
+      - response_end
+        │
+        ▼
+    File is already updated on disk
+    Frontend reloads file content, shows toast with confirmation
+```
+
+### Data Flow: Advisory Actions (Pair Writing Mode)
+
+```
+User selects text → Right-click → Choose "Validate" or "Critique"
+        │
+        ▼
+    Frontend extracts selection + context
+        │
+        ▼
+    Send `advisory_action_request` via WebSocket
+        │
+        ▼
+    Backend creates Claude request (streamed):
+      - System prompt: Advisory instructions
+      - User message: Selection + context
+        │
+        ▼
+    Stream response chunks to conversation pane
+        │
+        ▼
+    User reads feedback, manually edits document
+```
+
+## Technical Decisions
+
+### TD-1: Context Menu Implementation
+
+**Decision**: Create a new `EditorContextMenu` component rather than extending FileTree's menu.
+
+**Rationale**: FileTree's menu operates on file paths; editor menu operates on text selections. Different data models and positioning logic. The long-press timer pattern from FileTree (500ms timeout, touch event handling) will be extracted into a reusable hook.
+
+**Implementation**:
+- New `useLongPress` hook in `frontend/src/hooks/useLongPress.ts`
+- New `EditorContextMenu.tsx` component with portal rendering
+- Position calculated from Selection API's `getBoundingClientRect()`
+
+*Addresses*: REQ-F-2, REQ-F-3, REQ-NF-3, REQ-NF-6
+
+### TD-2: Quick Actions via Claude Tool Use
+
+**Decision**: Quick Actions use Claude's Read and Edit tools to modify the file directly, leveraging the existing SDK streaming infrastructure.
+
+**Rationale**:
+- Claude already knows how to use file editing tools
+- Tool use pattern is already implemented in the Discussion flow
+- Claude handles the complexity of determining exact edit boundaries
+- Consistent mental model: "Claude edits your file" (not "Claude suggests, you apply")
+- File is immediately persisted - no "unsaved changes" state for Quick Actions
+
+**Expected turn sequence** (typically 3-5 turns):
+1. User message with prompt + context
+2. Claude acknowledges task, uses Read tool to see current file
+3. Claude confirms what it sees, uses Edit tool to make change
+4. Claude confirms completion (brief)
+
+**Backend Flow**:
+1. Receive `quick_action_request` with action type, file path, selection, line numbers
+2. Create task-scoped Claude session with Read/Edit tools available
+3. System prompt instructs Claude to work efficiently (read → edit → confirm)
+4. Stream tool_start/tool_end events to frontend (reuse existing infrastructure)
+5. Claude's Edit tool invocation writes directly to vault file
+6. Session ends; optional commentary shown as toast
+
+**Why not one-shot text-in/text-out**:
+- Would require backend to apply the edit (duplicating Edit tool logic)
+- Loses Claude's reasoning about edit boundaries and context
+- Misses opportunity to show tool use in UI (transparency)
+
+*Addresses*: REQ-F-4, REQ-F-5, REQ-F-6
+
+### TD-3: Action-Specific System Prompts
+
+**Decision**: Store action prompts in a configuration object on the backend, not in the vault.
+
+**Rationale**:
+- Spec requires fixed actions (no user customization in v1)
+- Backend control ensures consistent behavior across vaults
+- Easy to tune prompts without user intervention
+- Future: could expose in vault config when customization is added
+
+**Prompt Structure** (example for "Tighten"):
+```
+You are a writing assistant performing a Quick Action. Be efficient: read the file, make the edit, confirm briefly.
+
+Task: Tighten the selected text in "{filePath}" (lines {startLine}-{endLine}).
+
+Rules for "Tighten":
+- Preserve the core meaning
+- Remove filler words, redundant phrases, unnecessary qualifiers
+- Maintain the author's voice and the document's tone
+
+Selected text to revise:
+{selectedText}
+
+Surrounding context (for tone matching - do not modify this):
+{contextBefore}
+[SELECTION TO EDIT]
+{contextAfter}
+
+Workflow:
+1. Read the file to see current state
+2. Use Edit tool to replace the selection with tightened version
+3. Confirm with one sentence (e.g., "Removed 3 filler phrases.")
+
+Keep responses brief. No lengthy explanations.
+```
+
+**Efficiency guidance in prompt**:
+- Explicitly states "be efficient" and "keep responses brief"
+- Provides workflow steps to minimize wandering
+- Asks for one-sentence confirmation, not paragraphs
+
+**Position hint logic**: Based on line numbers relative to document length:
+- Lines 1-20% → "near the beginning of"
+- Lines 20-80% → "in the middle of"
+- Lines 80-100% → "near the end of"
+
+**Tool availability**: Quick Action requests provide Claude with Read and Edit tools scoped to the current vault.
+
+*Addresses*: REQ-F-1, REQ-F-4
+
+### TD-4: Selection Context Extraction
+
+**Decision**: Extract one paragraph before and after the selection, where paragraphs are delimited by double newlines (`\n\n`).
+
+**Rationale**:
+- Spec explicitly defines paragraph boundaries as blank lines (REQ-F-4)
+- One paragraph provides sufficient context for tone/style matching
+- Prevents sending entire document to Claude (cost, latency, privacy)
+- Consistent behavior regardless of document size
+
+**Implementation**:
+```typescript
+interface SelectionContext {
+  before: string;      // Paragraph before selection
+  selection: string;   // Selected text
+  after: string;       // Paragraph after selection
+  startLine: number;   // 1-indexed line number of selection start
+  endLine: number;     // 1-indexed line number of selection end
+  totalLines: number;  // Total lines in document
+}
+
+function extractContext(content: string, selectionStart: number, selectionEnd: number): SelectionContext {
+  // Find paragraph boundaries using \n\n as delimiter
+  // Count newlines to determine line numbers
+  // Return context with text and line metadata
+}
+```
+
+*Addresses*: REQ-F-4, REQ-F-8
+
+### TD-5: Pair Writing Mode State Management
+
+**Decision**: Pair Writing Mode state managed in BrowseMode component, not in SessionContext.
+
+**Rationale**:
+- Pair Writing is a Browse sub-mode, not a top-level mode
+- Session-scoped state (conversation, snapshot) fits naturally in component state
+- SessionContext manages cross-mode concerns (vault, session ID); Pair Writing is single-mode
+- Simplifies cleanup: unmounting PairWritingMode clears all state
+
+**State Shape**:
+```typescript
+interface PairWritingState {
+  isActive: boolean;
+  content: string;           // Current editor content
+  snapshot: string | null;   // Manual snapshot for comparison
+  conversation: Message[];   // Session-scoped chat history
+  selection: Selection | null; // Current text selection
+  hasUnsavedChanges: boolean;
+}
+```
+
+*Addresses*: REQ-F-22, REQ-F-23, REQ-F-24, REQ-F-27
+
+### TD-6: Split-Screen Layout
+
+**Decision**: CSS Grid with two columns; no drag-to-resize in v1.
+
+**Rationale**:
+- Simpler implementation than draggable divider
+- Open question in spec ("Should split be resizable?") leaves room for v1 simplicity
+- 50/50 split is reasonable default for editor + conversation
+- Can add resize handle in future iteration
+
+**CSS**:
+```css
+.pair-writing {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 1rem;
+  height: 100%;
+}
+```
+
+*Addresses*: REQ-F-11
+
+### TD-7: Conversation Pane Reuse
+
+**Decision**: Extract conversation display logic from Discussion.tsx into a shared `ConversationPane` component.
+
+**Rationale**:
+- REQ-NF-4 requires conversation pane styling to match Discussion mode
+- Discussion.tsx currently bundles conversation display with mode-specific logic
+- Extracting shared component ensures visual consistency and reduces duplication
+- Pair Writing conversation is simpler (no tool invocations display needed for advisory actions)
+
+**Extraction**:
+```
+Discussion.tsx
+    ├── uses → ConversationPane (new shared component)
+    │              ├── MessageList
+    │              ├── ChatInput
+    │              └── Streaming indicator
+    └── mode-specific logic (slash commands, tool permissions)
+
+PairWritingConversation.tsx
+    └── uses → ConversationPane (same shared component)
+```
+
+*Addresses*: REQ-F-13, REQ-NF-4
+
+### TD-8: Snapshot Implementation
+
+**Decision**: Store snapshot as a string in PairWritingState; comparison performed client-side with diff sent to Claude for analysis.
+
+**Rationale**:
+- Single snapshot (REQ-F-24) simplifies to one string field
+- Client has both current and snapshot content; can compute diff without backend
+- Send diff (not full documents) to Claude for "what changed" analysis
+- Keeps snapshot ephemeral (session-scoped per REQ-F-27)
+
+**Flow**:
+1. User clicks "Snapshot" → `snapshot = content`
+2. User edits document → `content` changes
+3. User selects text, clicks "Compare to snapshot"
+4. Frontend finds corresponding region in snapshot (by line numbers or fuzzy match)
+5. If found: send before/after to backend for Claude analysis
+6. If not found: show "No corresponding text in snapshot" (REQ-F-26)
+
+*Addresses*: REQ-F-23, REQ-F-24, REQ-F-25, REQ-F-26, REQ-F-27
+
+### TD-9: Desktop-Only Detection
+
+**Decision**: Use CSS media query combined with touch event detection.
+
+**Rationale**:
+- `@media (hover: hover) and (pointer: fine)` targets devices with mouse
+- Additional runtime check for `'ontouchstart' in window` catches edge cases
+- Hides "Pair Writing" button via CSS on touch devices (REQ-F-10)
+- Touch detection also used to show/hide context menu items appropriately
+
+**Implementation**:
+```css
+@media (hover: none), (pointer: coarse) {
+  .pair-writing-button { display: none; }
+  .advisory-actions { display: none; }
+}
+```
+
+*Addresses*: REQ-F-10, REQ-NF-1
+
+### TD-10: Loading State During Quick Actions
+
+**Decision**: Apply visual indicator (opacity reduction + spinner) to the selected text range while Claude processes.
+
+**Rationale**:
+- REQ-F-7 requires loading indicator on selection
+- Can't use global spinner (user might think whole app is frozen)
+- Selection highlight with reduced opacity + small spinner near cursor provides clear feedback
+- Indicator shows during Claude's reasoning + tool execution (typically 2-5 seconds)
+
+**Implementation**:
+- On `quick_action_request` send: apply loading state to selection
+- Show spinner near selection while streaming (tool_start → tool_end)
+- On `response_end`: remove loading state, reload file content from disk
+- If error: remove loading state, show error toast
+
+*Addresses*: REQ-F-7
+
+### TD-11: Document Save Flow
+
+**Decision**: Quick Actions are immediately persisted (Claude uses Edit tool). Pair Writing Mode manual edits use existing `write_file` for saving.
+
+**Rationale**:
+- Quick Actions: Claude's Edit tool writes directly to disk - no "unsaved" state
+- Manual edits in Pair Writing Mode: User types in editor, needs explicit save
+- `hasUnsavedChanges` only tracks manual edits, not Quick Action results
+- Last-write-wins per spec (REQ-F-29); no conflict detection needed
+
+**Implementation**:
+- Quick Actions: File updated by Claude's tool invocation; frontend reloads content
+- Manual edits: PairWritingToolbar Save button calls existing `write_file` handler
+- Exit button checks `hasUnsavedChanges` for manual edits only
+- After Quick Action completes, editor reloads file from disk (not from response)
+
+*Addresses*: REQ-F-8, REQ-F-28, REQ-F-29, REQ-F-30
+
+### TD-12: Keyboard Accessibility
+
+**Decision**: EditorContextMenu supports keyboard navigation via arrow keys and Enter/Escape.
+
+**Rationale**:
+- REQ-NF-5 requires keyboard-navigable context menu
+- Pattern matches native browser context menus and accessibility expectations
+- Focus trap while menu is open; Escape dismisses
+
+**Implementation**:
+- Menu items are focusable `<button>` elements
+- Arrow Up/Down moves focus between items
+- Enter activates focused item
+- Escape closes menu, returns focus to editor
+- `role="menu"` and `role="menuitem"` ARIA attributes
+
+*Addresses*: REQ-NF-5
+
+### TD-13: Snapshot Comparison Logic
+
+**Decision**: Use line-based offset matching for finding corresponding text in snapshot.
+
+**Rationale**:
+- Character-based matching breaks when content shifts (adds/deletes)
+- Line-based approach: find selection's line range in current, look for similar lines in snapshot
+- If exact line content match not found, use fuzzy line matching (Levenshtein within threshold)
+- If no match found after fuzzy search, return "no corresponding text" message
+
+**Algorithm**:
+1. Get line numbers of current selection (startLine, endLine)
+2. Extract those lines from snapshot content
+3. If exact match: use snapshot lines as "before"
+4. If no exact match: search snapshot for lines with >80% similarity
+5. If still no match: return null (triggers "no corresponding text" UI)
+
+**Fallback**: For heavily restructured documents, comparison may not find matches. This is acceptable; user can take new snapshot after major edits.
+
+*Addresses*: REQ-F-26
+
+## WebSocket Protocol Additions
+
+### New Client Messages
+
+```typescript
+// Quick Action request (all platforms)
+interface QuickActionRequest {
+  type: "quick_action_request";
+  action: "tighten" | "embellish" | "correct" | "polish";
+  selection: string;
+  contextBefore: string;
+  contextAfter: string;
+  filePath: string;           // Included in prompt for document type context
+  selectionStartLine: number; // 1-indexed line number
+  selectionEndLine: number;   // 1-indexed line number
+  totalLines: number;         // For position hint calculation
+}
+
+// Advisory Action request (Pair Writing Mode, desktop)
+interface AdvisoryActionRequest {
+  type: "advisory_action_request";
+  action: "validate" | "critique" | "compare";
+  selection: string;
+  contextBefore: string;
+  contextAfter: string;
+  filePath: string;
+  selectionStartLine: number;
+  selectionEndLine: number;
+  totalLines: number;
+  // For compare action only:
+  snapshotSelection?: string;
+}
+
+// Freeform chat in Pair Writing (desktop)
+interface PairChatRequest {
+  type: "pair_chat_request";
+  text: string;
+  selection?: string;
+  contextBefore?: string;
+  contextAfter?: string;
+  filePath: string;
+  selectionStartLine?: number;
+  selectionEndLine?: number;
+  totalLines?: number;
+}
+```
+
+### Server Messages
+
+Quick Actions, Advisory Actions, and Pair Chat all use **existing streaming messages**:
+- `response_start` - Claude turn begins
+- `tool_start` - Tool invocation started (e.g., Edit tool for Quick Actions)
+- `tool_input` - Tool parameters
+- `tool_end` - Tool completed (file written for Quick Actions)
+- `response_chunk` - Text content (commentary for Quick Actions, feedback for Advisory)
+- `response_end` - Claude turn complete
+
+No new server message types needed. This reuses the Discussion infrastructure.
+
+### Schema Location
+
+Add to `shared/src/protocol.ts`:
+- New message types in `ClientMessageSchema` discriminated union
+- New message types in `ServerMessageSchema` discriminated union
+- Action type enums for validation
+
+*Addresses*: REQ-F-1 through REQ-F-8, REQ-F-15, REQ-F-16, REQ-F-21
+
+## Backend Handler Structure
+
+### New Handler File: `pair-writing-handlers.ts`
+
+```typescript
+// handlers/pair-writing-handlers.ts
+export async function handleQuickAction(ctx: HandlerContext, request: QuickActionRequest): Promise<void>
+export async function handleAdvisoryAction(ctx: HandlerContext, request: AdvisoryActionRequest): Promise<void>
+export async function handlePairChat(ctx: HandlerContext, request: PairChatRequest): Promise<void>
+```
+
+### Quick Action Handler Logic
+
+1. Validate request fields (file path within vault, selection not empty)
+2. Build system prompt from action-specific template (include file path, selection, context)
+3. Create task-scoped Claude session with Read + Edit tools available
+4. Claude runs multiple turns (typically 3-5): acknowledge → read → edit → confirm
+5. Stream all events to frontend (reuse existing streaming infrastructure)
+6. Session auto-terminates after Claude confirms completion
+7. `response_end` signals completion; frontend reloads file from disk
+
+### Advisory Action Handler Logic
+
+1. Validate request fields (must have vault selected)
+2. Build system prompt for advisory action
+3. Use existing streaming infrastructure (similar to Discussion)
+4. Stream response to `response_chunk` messages
+5. No persistence (conversation is frontend-managed)
+
+*Addresses*: REQ-F-4, REQ-F-5, REQ-F-6, REQ-F-16, REQ-F-17
+
+## Component Structure
+
+### New Components
+
+| Component | Location | Purpose |
+|-----------|----------|---------|
+| `EditorContextMenu` | `components/EditorContextMenu.tsx` | Context menu for text selections |
+| `PairWritingMode` | `components/PairWritingMode.tsx` | Split-screen container (desktop) |
+| `PairWritingToolbar` | `components/PairWritingToolbar.tsx` | Snapshot, Save, Exit buttons |
+| `ConversationPane` | `components/ConversationPane.tsx` | Shared message display (extracted from Discussion) |
+| `SelectionQuote` | `components/SelectionQuote.tsx` | Quoted selection above chat input |
+
+### New Hooks
+
+| Hook | Location | Purpose |
+|------|----------|---------|
+| `useLongPress` | `hooks/useLongPress.ts` | Long-press detection for mobile context menu |
+| `useTextSelection` | `hooks/useTextSelection.ts` | Track current selection in editor (text, start/end line numbers) |
+| `usePairWritingState` | `hooks/usePairWritingState.ts` | Manage pair writing session state |
+
+### Modified Components
+
+| Component | Changes |
+|-----------|---------|
+| `BrowseMode` | Add "Pair Writing" button, render PairWritingMode when active |
+| `MemoryEditor` | Add context menu trigger, selection tracking |
+| `Discussion` | Extract ConversationPane (no behavior change) |
+
+## Testing Strategy
+
+### Unit Tests
+
+- `useLongPress.test.ts`: Timer behavior, cancel on move/end, 500ms threshold
+- `useTextSelection.test.ts`: Selection change detection, range extraction
+- `extractContext.test.ts`: Paragraph boundary detection, edge cases
+- `pair-writing-handlers.test.ts`: Action dispatch, prompt building, response parsing
+
+### Integration Tests
+
+- Quick Action flow: Select → Menu → Response → Replacement
+- Advisory Action flow: Select → Menu → Streaming → Conversation display
+- Snapshot flow: Create → Edit → Compare → Analysis display
+- Unsaved changes warning: Edit → Exit → Confirm dialog
+
+### Platform Tests
+
+- Desktop: Right-click triggers menu
+- Mobile: Long-press triggers menu (Quick Actions only)
+- Touch device: "Pair Writing" button hidden
+
+*Addresses*: Acceptance tests 1-12 in spec
+
+## Security Considerations
+
+- **File Path Validation**: Reuse existing `validatePath` from file-browser.ts for `filePath` field
+- **Content Size Limits**: Enforce max selection size (e.g., 10KB) to prevent abuse
+- **Rate Limiting**: Quick Actions are stateless; consider per-connection rate limit
+- **Prompt Injection**: Selection text is inserted into prompts; use clear delimiters and instructions
+
+## Performance Considerations
+
+- **REQ-NF-2**: Editor performance (60fps) maintained by using existing MemoryEditor
+- **REQ-NF-3**: Context menu appears <100ms (menu is pre-rendered, shown on trigger)
+- **Quick Action Latency**: One-shot requests typically complete in 1-3 seconds
+- **Large Files**: Context extraction is O(n) but n is bounded by file size limit (50KB per spec)
+
+## Migration/Rollout
+
+No database migrations needed. Feature is additive:
+1. Deploy backend with new handlers
+2. Deploy frontend with new components
+3. Feature available immediately; no vault config changes required
+
+## Risks and Mitigations
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| Selection API inconsistencies across browsers | Medium | Medium | Test on Chrome, Firefox, Safari; use Selection polyfill if needed |
+| Long-press conflicts with text selection on mobile | Medium | High | Carefully tune timing; test on iOS Safari and Android Chrome |
+| Claude returns malformed responses (no text, wrong format) | Low | Medium | Validate response format; fall back to showing raw response |
+| Large selections cause slow/expensive Claude calls | Medium | Medium | Enforce selection size limit; show warning for large selections |
+| Snapshot comparison fails to find matches after edits | Medium | Low | "No corresponding text" message is acceptable; user can take new snapshot |
+
+## Open Questions Resolution
+
+| Question | Decision | Rationale |
+|----------|----------|-----------|
+| Hotkey for "jump to chat" | `Tab` when selection exists | Tab is intuitive for "move focus"; already used for form navigation |
+| Resizable split? | No in v1 | Simplifies implementation; can add in future iteration |
+
+## Requirements Traceability
+
+| Requirement | Addressed By |
+|-------------|--------------|
+| REQ-F-1 | TD-3 (Action-specific prompts) |
+| REQ-F-2 | TD-1 (Context menu implementation) |
+| REQ-F-3 | TD-1 (Long-press via useLongPress hook) |
+| REQ-F-4 | TD-2, TD-3, TD-4 (Claude request with context, Edit tool available) |
+| REQ-F-5 | TD-2 (Claude Edit tool writes directly to file) |
+| REQ-F-6 | TD-2 (Toast for commentary) |
+| REQ-F-7 | TD-10 (Loading indicator) |
+| REQ-F-8 | TD-2, TD-11 (Quick Actions persist immediately via Claude Edit tool) |
+| REQ-F-9 | Modified Components: BrowseMode adds "Pair Writing" button |
+| REQ-F-10 | TD-9 (Desktop-only detection) |
+| REQ-F-11 | TD-6 (Split-screen layout) |
+| REQ-F-12 | Component Structure: PairWritingMode uses MemoryEditor |
+| REQ-F-13 | TD-7 (ConversationPane reuse) |
+| REQ-F-14 | Component Structure: PairWritingToolbar with Exit button |
+| REQ-F-15 | WebSocket Protocol: AdvisoryActionRequest |
+| REQ-F-16 | Backend Handler: handleAdvisoryAction |
+| REQ-F-17 | Data Flow: Advisory Actions (manual editing after feedback) |
+| REQ-F-18 | EditorContextMenu shows all 6 actions in Pair Writing Mode |
+| REQ-F-19 | Open Questions Resolution: Tab hotkey |
+| REQ-F-20 | Component Structure: SelectionQuote component |
+| REQ-F-21 | WebSocket Protocol: PairChatRequest |
+| REQ-F-22 | TD-5 (Session-scoped conversation) |
+| REQ-F-23 | TD-5, TD-8 (Snapshot button and storage) |
+| REQ-F-24 | TD-8 (Single snapshot design) |
+| REQ-F-25 | TD-8 (Compare action in context menu) |
+| REQ-F-26 | TD-8, TD-13 (Comparison logic with fallback) |
+| REQ-F-27 | TD-5 (Session-scoped state) |
+| REQ-F-28 | TD-11 (No auto-save) |
+| REQ-F-29 | TD-11 (Reuse write_file handler) |
+| REQ-F-30 | TD-11 (Exit warning via hasUnsavedChanges) |
+| REQ-NF-1 | TD-9 (Platform detection) |
+| REQ-NF-2 | Performance Considerations (existing MemoryEditor) |
+| REQ-NF-3 | TD-1 (Pre-rendered menu), Performance Considerations |
+| REQ-NF-4 | TD-7 (Shared ConversationPane) |
+| REQ-NF-5 | TD-12 (Keyboard accessibility) |
+| REQ-NF-6 | TD-1 (500ms long-press threshold) |
+
+---
+
+**Next Phase**: Once approved, use `/task-breakdown` to decompose into implementable tasks.
diff --git a/.sdd/progress/memory-loop/2026-01-20-pair-writing-mode-progress.md b/.sdd/progress/memory-loop/2026-01-20-pair-writing-mode-progress.md
new file mode 100644
index 00000000..8600652d
--- /dev/null
+++ b/.sdd/progress/memory-loop/2026-01-20-pair-writing-mode-progress.md
@@ -0,0 +1,138 @@
+---
+specification: [.sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md](../../specs/memory-loop/2026-01-20-pair-writing-mode.md)
+plan: [.sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md](../../plans/memory-loop/2026-01-20-pair-writing-mode-plan.md)
+tasks: [.sdd/tasks/memory-loop/2026-01-20-pair-writing-mode-tasks.md](../../tasks/memory-loop/2026-01-20-pair-writing-mode-tasks.md)
+status: In Progress
+version: 1.0.0
+created: 2026-01-20
+last_updated: 2026-01-20
+authored_by:
+  - Ronald Roy <gsdwig@gmail.com>
+---
+
+# Pair Writing Mode - Implementation Progress
+
+**Last Updated**: 2026-01-20 | **Status**: 100% complete (14 of 14 tasks)
+
+## Current Session
+**Date**: 2026-01-20 | **Working On**: Implementation Complete | **Blockers**: None
+
+## Completed Today
+- TASK-001: WebSocket Protocol Extensions (352 tests passing)
+- TASK-002: Long-Press Hook (14 tests passing)
+- TASK-003: Text Selection Hook (50 tests passing)
+- TASK-006: Quick Action Prompts Configuration (60 tests passing)
+- TASK-009: Pair Writing State Management (27 tests passing)
+- TASK-010: Conversation Pane Extraction (17 tests passing)
+- TASK-004: Editor Context Menu Component (28 tests passing)
+- TASK-005: Integrate Context Menu into PairWritingEditor (created new component)
+- TASK-007: Quick Action Handler (16 tests passing)
+- TASK-008: Quick Action Frontend Flow (25 tests passing)
+- TASK-011: Pair Writing Mode Layout (31 tests passing)
+- TASK-012: Pair Writing Entry Point in BrowseMode (integrated)
+- TASK-013: Advisory Action Handlers (backend handlers + streaming)
+- TASK-014: Full Context Menu in Pair Writing Mode (icons + height calc)
+
+## Discovered Issues
+- None
+
+---
+
+## Overall Progress
+
+### Phase 1: Foundation (Parallel)
+
+**Completed** ✅
+- [x] TASK-001: WebSocket Protocol Extensions - *Completed 2026-01-20*
+- [x] TASK-002: Long-Press Hook - *Completed 2026-01-20*
+- [x] TASK-003: Text Selection Hook - *Completed 2026-01-20*
+- [x] TASK-006: Quick Action Prompts Configuration - *Completed 2026-01-20*
+- [x] TASK-009: Pair Writing State Management - *Completed 2026-01-20*
+- [x] TASK-010: Conversation Pane Extraction - *Completed 2026-01-20*
+
+### Phase 2: Context Menu
+
+**Completed** ✅
+- [x] TASK-004: Editor Context Menu Component - *Completed 2026-01-20*
+- [x] TASK-005: Integrate Context Menu into MemoryEditor - *Completed 2026-01-20*
+
+### Phase 3: Quick Actions
+
+**Completed** ✅
+- [x] TASK-007: Quick Action Handler - *Completed 2026-01-20*
+- [x] TASK-008: Quick Action Frontend Flow - *Completed 2026-01-20*
+
+### Phase 4: Pair Writing Mode
+
+**Completed** ✅
+- [x] TASK-011: Pair Writing Mode Layout - *Completed 2026-01-20*
+- [x] TASK-012: Pair Writing Entry Point in BrowseMode - *Completed 2026-01-20*
+- [x] TASK-013: Advisory Action Handlers - *Completed 2026-01-20*
+- [x] TASK-014: Full Context Menu in Pair Writing Mode - *Completed 2026-01-20*
+
+---
+
+## Deviations from Plan
+
+**PairWritingEditor created instead of using MemoryEditor**
+
+The original implementation incorrectly embedded MemoryEditor in PairWritingMode.
+MemoryEditor is hardcoded to load memory.md (a Claude context file), not the file
+being viewed in BrowseMode.
+
+Fix: Created new PairWritingEditor component that:
+- Receives content via props (initialContent)
+- Displays and edits the actual file content
+- Supports Quick Actions and Advisory Actions via context menu
+- Reverted MemoryEditor and its tests to original state
+
+---
+
+## Technical Discoveries
+
+(none yet)
+
+---
+
+## Test Coverage
+
+| Component | Status |
+|-----------|--------|
+| Protocol schemas | ✅ Complete (352 tests) |
+| useLongPress hook | ✅ Complete (14 tests) |
+| useTextSelection hook | ✅ Complete (50 tests) |
+| Quick Action prompts | ✅ Complete (60 tests) |
+| usePairWritingState hook | ✅ Complete (27 tests) |
+| ConversationPane | ✅ Complete (17 tests) |
+| EditorContextMenu | ✅ Complete (28 tests) |
+| PairWritingEditor | ✅ Complete (new component) |
+| pair-writing-handlers | ✅ Complete (16 tests) |
+| PairWritingMode | ✅ Complete (18 tests) |
+| PairWritingToolbar | ✅ Complete (7 tests) |
+| BrowseMode (pair writing integration) | ✅ Complete (8 tests) |
+
+---
+
+## Implementation Summary
+
+All 14 tasks across 4 phases completed successfully. The Pair Writing Mode feature is fully implemented with:
+
+**Quick Actions** (all platforms):
+- Context menu with Tighten, Embellish, Correct, Polish actions
+- Claude Agent SDK integration for inline text edits via Edit tool
+- Toast notifications for action feedback
+
+**Pair Writing Mode** (desktop only):
+- Split-screen layout with markdown editor and conversation pane
+- Advisory Actions (Validate, Critique) in context menu
+- Freeform chat for discussing writing
+- Snapshot comparison when snapshot exists
+- Tab hotkey for jumping to chat input
+- Responsive toolbar with "Done Editing" exit
+
+**Backend**:
+- WebSocket protocol extensions for all action types
+- Streaming response support via Anthropic API
+- Configurable prompt templates
+
+All checks passing: typecheck, lint, 548 unit tests.
diff --git a/.sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md b/.sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md
new file mode 100644
index 00000000..e60c2d0c
--- /dev/null
+++ b/.sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md
@@ -0,0 +1,168 @@
+---
+version: 1.2.0
+status: Approved
+created: 2026-01-20
+last_updated: 2026-01-20
+authored_by:
+  - Ronald Roy <gsdwig@gmail.com>
+---
+
+# Pair Writing Mode Specification
+
+## Executive Summary
+
+This feature adds AI-assisted text revision to Memory Loop through two complementary capabilities:
+
+1. **Quick Actions** (all platforms): Four transformative actions (Tighten, Embellish, Correct, Polish) available via context menu when editing any markdown file. AI directly replaces the selected text with the improved version.
+
+2. **Pair Writing Mode** (desktop only): A split-screen editor with conversation pane for advisory actions (Validate, Critique), freeform chat about selections, and "What Changed?" comparisons.
+
+Quick Actions reduce friction for common revision tasks. Pair Writing Mode enables deeper collaboration where the user reads AI feedback and manually applies changes, preserving the learning loop.
+
+## User Story
+
+As a writer using Memory Loop, I want AI to help me revise text in place for quick edits, and provide advisory feedback in a side-by-side view for deeper revision, so that I can choose the right level of AI involvement for each situation.
+
+## Stakeholders
+
+- **Primary**: Writers using Memory Loop for knowledge work and drafting
+- **Secondary**: Memory Loop maintainers (new component patterns, state management)
+
+## Success Criteria
+
+1. User can invoke Quick Actions on selected text in any markdown file (desktop and mobile)
+2. AI directly replaces selected text for transformative actions
+3. User can enter Pair Writing Mode for advisory actions and freeform chat (desktop)
+4. User can snapshot and compare edits in Pair Writing Mode
+
+## Functional Requirements
+
+### Quick Actions (All Platforms)
+
+- **REQ-F-1**: When editing a markdown file in Browse mode, provide context menu with four transformative actions:
+  - **Tighten**: Make more concise without losing meaning
+  - **Embellish**: Add detail, nuance, or context
+  - **Correct**: Fix typos and grammar only
+  - **Polish**: Correct + improve prose (controlled improvements)
+- **REQ-F-2**: On desktop, context menu appears on right-click when text is selected
+- **REQ-F-3**: On mobile, context menu appears on long-press when text is selected (prevent system context menu)
+- **REQ-F-4**: Invoking a Quick Action sends selection + surrounding context to Claude. Context includes the paragraph containing the selection plus one paragraph before and after (paragraphs delimited by blank lines)
+- **REQ-F-5**: Claude returns revised text; system replaces the selection with the revised text in-place
+- **REQ-F-6**: If Claude includes commentary, display as toast notification
+- **REQ-F-7**: Show loading indicator on the selection while AI is processing
+- **REQ-F-8**: Quick Action edits persist immediately to disk (Claude uses Edit tool directly); no explicit save required for Quick Actions
+
+### Pair Writing Mode Entry and Layout (Desktop Only)
+
+- **REQ-F-9**: When viewing a markdown file in Browse mode on desktop, display "Pair Writing" button to enter the mode
+- **REQ-F-10**: Hide "Pair Writing" button on mobile/touch devices
+- **REQ-F-11**: Pair Writing Mode displays split-screen layout: left pane (editor), right pane (conversation)
+- **REQ-F-12**: Left pane contains an editable markdown editor with the current file content
+- **REQ-F-13**: Right pane contains a conversation log and chat input
+- **REQ-F-14**: Provide "Exit" button to return to standard Browse view, with warning if manual edits are unsaved
+
+### Advisory Actions (Desktop Only, Pair Writing Mode)
+
+- **REQ-F-15**: In Pair Writing Mode, context menu includes two additional advisory actions:
+  - **Validate**: Fact-check the claim
+  - **Critique**: Analyze clarity, voice, structure
+- **REQ-F-16**: Advisory actions send selection + context to Claude; response appears in conversation pane
+- **REQ-F-17**: User reads feedback and manually applies changes by editing the document
+- **REQ-F-18**: Quick Actions (Tighten, Embellish, Correct, Polish) also available in Pair Writing Mode context menu, behaving the same as in Browse mode (direct replacement)
+
+### Freeform Chat (Desktop Only, Pair Writing Mode)
+
+- **REQ-F-19**: User can highlight text and press a hotkey to jump to chat input
+- **REQ-F-20**: When chat input is focused with a selection, display the selection as a quoted block above the input
+- **REQ-F-21**: User types a freeform question; Claude responds with selection context attached
+- **REQ-F-22**: Conversation history persists for the session (lost on exit or file switch)
+
+### Shadow Versioning (Desktop Only, Pair Writing Mode)
+
+- **REQ-F-23**: Provide "Snapshot" button to manually capture the current document state
+- **REQ-F-24**: Only one snapshot exists at a time; new snapshot replaces previous
+- **REQ-F-25**: When a snapshot exists and text is selected, enable "Compare to snapshot" action in context menu
+- **REQ-F-26**: "Compare to snapshot" displays a diff in the conversation pane showing:
+  - BEFORE (snapshot): original text at that location
+  - AFTER (current): user's current text
+  - ANALYSIS: Claude's description of what changed (objective, not judgmental)
+  - If selection location has no corresponding text in snapshot (new content), display "No corresponding text in snapshot" message
+- **REQ-F-27**: Snapshot is session-scoped (cleared on exit or file switch)
+
+### Document Persistence
+
+- **REQ-F-28**: Manual edits in Pair Writing Mode are not auto-saved; Quick Actions persist immediately via Claude's Edit tool
+- **REQ-F-29**: Provide "Save" button to write manual edits back to the vault file (last write wins; no conflict detection in v1)
+- **REQ-F-30**: Warn user if exiting Pair Writing Mode with unsaved manual edits
+
+## Non-Functional Requirements
+
+- **REQ-NF-1** (Platform): Quick Actions work on desktop and mobile; Pair Writing Mode is desktop-only
+- **REQ-NF-2** (Performance): Editor must maintain 60fps (16ms per frame) when typing in files up to 50KB
+- **REQ-NF-3** (Responsiveness): Context menu appears within 100ms of trigger (right-click or long-press)
+- **REQ-NF-4** (Consistency): Conversation pane styling matches existing Discussion mode
+- **REQ-NF-5** (Accessibility): Context menu is keyboard-navigable after opening
+- **REQ-NF-6** (Mobile UX): Long-press duration matches platform convention (~500ms)
+
+## Explicit Constraints (DO NOT)
+
+- Do NOT auto-apply advisory action responses (Validate, Critique) to the document
+- Do NOT persist conversation history to the vault (session-only)
+- Do NOT show Pair Writing Mode entry point on mobile/touch devices
+- Do NOT allow custom user-defined actions in v1 (fixed set of 6)
+- Do NOT auto-save manual edits (explicit save required); Quick Actions persist immediately by design
+- Do NOT support multiple simultaneous snapshots (one snapshot at a time)
+
+## Technical Context
+
+- **Existing Stack**: React 19 frontend, Hono backend, WebSocket communication, Claude Agent SDK
+- **Integration Points**:
+  - Browse mode adjust/edit flow (entry point for Quick Actions)
+  - FileTree context menu pattern (long-press implementation reference)
+  - WebSocket protocol (new message types for pair writing actions)
+  - Session management (conversation history uses existing patterns)
+- **Patterns to Respect**:
+  - State management via SessionContext (useReducer pattern)
+  - Zod-validated message schemas in shared/
+  - CSS modules for component styling
+
+## Acceptance Tests
+
+### Quick Actions (All Platforms)
+1. **Desktop Quick Action**: Edit markdown file → select text → right-click → choose "Tighten" → selection replaced with tightened text
+2. **Mobile Quick Action**: Edit markdown file → select text → long-press → choose "Polish" → selection replaced with polished text
+3. **Quick Action Toast**: Invoke "Correct" → AI includes commentary → toast appears with commentary
+4. **Quick Action Loading**: Invoke action → loading indicator visible on selection → indicator clears when complete
+
+### Pair Writing Mode (Desktop Only)
+5. **Enter Pair Writing**: Open markdown file on desktop → click "Pair Writing" → split-screen layout appears
+6. **Advisory Action**: In Pair Writing Mode → select text → right-click → choose "Validate" → response appears in conversation pane (not inline)
+7. **Freeform Chat**: Select text → press hotkey → cursor in chat with selection quoted → type question → response includes selection context
+8. **Snapshot + Compare**: Click "Snapshot" → edit text → select edited region → "Compare to snapshot" → diff with analysis appears in conversation pane
+
+### Document Persistence
+9. **Quick Action Persistence**: Invoke Quick Action on text → file immediately updated on disk (verify by re-opening file)
+10. **Manual Edit Save Flow**: In Pair Writing Mode → type manual edits → click "Save" → changes written to vault
+11. **Exit Warning**: In Pair Writing Mode → type manual edits without saving → click "Exit" → confirmation dialog appears
+
+### Platform Behavior
+12. **Desktop-Only Pair Writing**: Load Memory Loop on touch device → "Pair Writing" button not visible
+13. **Mobile Quick Actions Available**: Load Memory Loop on touch device → edit markdown → select text → long-press → context menu with Quick Actions appears
+
+## Open Questions
+
+- [ ] Exact hotkey for "jump to chat" in Pair Writing Mode (Tab vs Cmd+Enter vs configurable)
+- [ ] Should the split be resizable by dragging the divider?
+
+## Out of Scope
+
+- Custom user-defined actions
+- Persistent conversation history (stored in vault)
+- Multiple snapshots / full version history
+- Rich text / WYSIWYG editing (markdown source only)
+- Collaborative multi-user editing
+- Undo/redo for Quick Action replacements (uses standard editor undo)
+
+---
+
+**Next Phase**: Once approved, use `/spiral-grove:plan-generation` to create technical implementation plan.
diff --git a/.sdd/specs/memory-loop/2025-12-26-chat.md b/.sdd/specs/memory-loop/completed/2025-12-26-chat.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-26-chat.md
rename to .sdd/specs/memory-loop/completed/2025-12-26-chat.md
diff --git a/.sdd/specs/memory-loop/2025-12-26-home.md b/.sdd/specs/memory-loop/completed/2025-12-26-home.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-26-home.md
rename to .sdd/specs/memory-loop/completed/2025-12-26-home.md
diff --git a/.sdd/specs/memory-loop/2025-12-26-navigation-bar.md b/.sdd/specs/memory-loop/completed/2025-12-26-navigation-bar.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-26-navigation-bar.md
rename to .sdd/specs/memory-loop/completed/2025-12-26-navigation-bar.md
diff --git a/.sdd/specs/memory-loop/2025-12-26-note-capture.md b/.sdd/specs/memory-loop/completed/2025-12-26-note-capture.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-26-note-capture.md
rename to .sdd/specs/memory-loop/completed/2025-12-26-note-capture.md
diff --git a/.sdd/specs/memory-loop/2025-12-26-vault-selection.md b/.sdd/specs/memory-loop/completed/2025-12-26-vault-selection.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-26-vault-selection.md
rename to .sdd/specs/memory-loop/completed/2025-12-26-vault-selection.md
diff --git a/.sdd/specs/memory-loop/2025-12-26-view.md b/.sdd/specs/memory-loop/completed/2025-12-26-view.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-26-view.md
rename to .sdd/specs/memory-loop/completed/2025-12-26-view.md
diff --git a/.sdd/specs/memory-loop/2025-12-31-task-list.md b/.sdd/specs/memory-loop/completed/2025-12-31-task-list.md
similarity index 100%
rename from .sdd/specs/memory-loop/2025-12-31-task-list.md
rename to .sdd/specs/memory-loop/completed/2025-12-31-task-list.md
diff --git a/.sdd/specs/memory-loop/2026-01-04-slashcommand-ux.md b/.sdd/specs/memory-loop/completed/2026-01-04-slashcommand-ux.md
similarity index 100%
rename from .sdd/specs/memory-loop/2026-01-04-slashcommand-ux.md
rename to .sdd/specs/memory-loop/completed/2026-01-04-slashcommand-ux.md
diff --git a/.sdd/specs/memory-loop/2026-01-05-vault-setup.md b/.sdd/specs/memory-loop/completed/2026-01-05-vault-setup.md
similarity index 100%
rename from .sdd/specs/memory-loop/2026-01-05-vault-setup.md
rename to .sdd/specs/memory-loop/completed/2026-01-05-vault-setup.md
diff --git a/.sdd/specs/memory-loop/2026-01-07-recall-search.md b/.sdd/specs/memory-loop/completed/2026-01-07-recall-search.md
similarity index 100%
rename from .sdd/specs/memory-loop/2026-01-07-recall-search.md
rename to .sdd/specs/memory-loop/completed/2026-01-07-recall-search.md
diff --git a/.sdd/specs/memory-loop/2026-01-12-dag-dependency-resolution.md b/.sdd/specs/memory-loop/completed/2026-01-12-dag-dependency-resolution.md
similarity index 100%
rename from .sdd/specs/memory-loop/2026-01-12-dag-dependency-resolution.md
rename to .sdd/specs/memory-loop/completed/2026-01-12-dag-dependency-resolution.md
diff --git a/.sdd/specs/memory-loop/2026-01-14-vault-config-editor.md b/.sdd/specs/memory-loop/completed/2026-01-14-vault-config-editor.md
similarity index 100%
rename from .sdd/specs/memory-loop/2026-01-14-vault-config-editor.md
rename to .sdd/specs/memory-loop/completed/2026-01-14-vault-config-editor.md
diff --git a/.sdd/specs/memory-loop/2026-01-18-memory-extraction.md b/.sdd/specs/memory-loop/completed/2026-01-18-memory-extraction.md
similarity index 100%
rename from .sdd/specs/memory-loop/2026-01-18-memory-extraction.md
rename to .sdd/specs/memory-loop/completed/2026-01-18-memory-extraction.md
diff --git a/.sdd/tasks/memory-loop/2026-01-20-pair-writing-mode-tasks.md b/.sdd/tasks/memory-loop/2026-01-20-pair-writing-mode-tasks.md
new file mode 100644
index 00000000..ed82777f
--- /dev/null
+++ b/.sdd/tasks/memory-loop/2026-01-20-pair-writing-mode-tasks.md
@@ -0,0 +1,333 @@
+---
+specification: [.sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md](../specs/memory-loop/2026-01-20-pair-writing-mode.md)
+plan: [.sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md](../plans/memory-loop/2026-01-20-pair-writing-mode-plan.md)
+status: Draft
+version: 1.0.0
+created: 2026-01-20
+last_updated: 2026-01-20
+authored_by:
+  - Ronald Roy <gsdwig@gmail.com>
+---
+
+# Pair Writing Mode - Task Breakdown
+
+## Task Summary
+Total: 14 tasks | Complexity Distribution: 3xS, 8xM, 3xL
+
+## Foundation Layer
+
+### TASK-001: WebSocket Protocol Extensions
+**Priority**: Critical | **Complexity**: S | **Dependencies**: None
+
+**Description**: Add new message types to shared protocol for Quick Actions, Advisory Actions, and Pair Chat.
+
+**Acceptance Criteria**:
+- [ ] `QuickActionRequest` schema with action type, selection, context, filePath, line numbers
+- [ ] `AdvisoryActionRequest` schema with action type, selection, context, snapshotSelection
+- [ ] `PairChatRequest` schema with text, optional selection context
+- [ ] Schemas integrated into `ClientMessageSchema` discriminated union
+- [ ] Type exports for frontend/backend consumption
+
+**Files**: Modify: `shared/src/protocol.ts`
+
+**Testing**: Unit tests for schema validation (valid/invalid payloads)
+
+---
+
+### TASK-002: Long-Press Hook
+**Priority**: High | **Complexity**: S | **Dependencies**: None
+
+**Description**: Extract long-press timer logic from FileTree into reusable `useLongPress` hook.
+
+**Acceptance Criteria**:
+- [ ] Hook accepts callback and optional duration (default 500ms)
+- [ ] Returns touch event handlers (onTouchStart, onTouchMove, onTouchEnd)
+- [ ] Cancels timer on move or end events
+- [ ] Calls `e.preventDefault()` in onTouchStart to suppress system context menu
+
+**Files**: Create: `frontend/src/hooks/useLongPress.ts`
+
+**Testing**: Unit tests for timer behavior, cancellation, 500ms threshold
+
+---
+
+### TASK-003: Text Selection Hook
+**Priority**: High | **Complexity**: M | **Dependencies**: None
+
+**Description**: Create `useTextSelection` hook to track current selection in editor with line number metadata.
+
+**Acceptance Criteria**:
+- [ ] Tracks selection changes via Selection API
+- [ ] Returns `SelectionContext`: text, startLine, endLine, totalLines, contextBefore, contextAfter
+- [ ] `contextBefore`/`contextAfter` are full paragraphs (delimited by `\n\n`)
+- [ ] Returns null for empty selection
+
+**Files**: Create: `frontend/src/hooks/useTextSelection.ts`
+
+**Testing**: Unit tests for line counting, paragraph extraction at document boundaries
+
+---
+
+## Context Menu
+
+### TASK-004: Editor Context Menu Component
+**Priority**: Critical | **Complexity**: M | **Dependencies**: TASK-002, TASK-003
+
+**Description**: Create `EditorContextMenu` with right-click (desktop) and long-press (mobile) triggers.
+
+**Acceptance Criteria**:
+- [ ] Renders via portal at selection position
+- [ ] Shows Quick Actions (Tighten, Embellish, Correct, Polish) on all platforms
+- [ ] Uses `useLongPress` for mobile trigger
+- [ ] Dismisses on click outside or Escape
+- [ ] Keyboard navigable (arrow keys, Enter, Escape) per REQ-NF-5
+- [ ] Appears within 100ms of trigger per REQ-NF-3
+
+**Files**:
+- Create: `frontend/src/components/EditorContextMenu.tsx`
+- Create: `frontend/src/components/EditorContextMenu.module.css`
+
+**Testing**: Unit tests for rendering, keyboard navigation; manual test: verify long-press triggers menu on iOS/Android, system menu suppressed
+
+---
+
+### TASK-005: Integrate Context Menu into MemoryEditor
+**Priority**: Critical | **Complexity**: M | **Dependencies**: TASK-004
+
+**Description**: Wire `EditorContextMenu` into `MemoryEditor` component with selection tracking.
+
+**Acceptance Criteria**:
+- [ ] Right-click with selection opens context menu
+- [ ] Long-press with selection opens context menu (mobile)
+- [ ] Menu position follows selection bounding rect
+- [ ] Selection state passed to menu for action dispatch
+- [ ] Prevents browser default context menu when our menu opens
+
+**Files**: Modify: `frontend/src/components/MemoryEditor.tsx`
+
+**Testing**: Integration test: select text -> right-click -> menu appears
+
+---
+
+## Quick Actions
+
+### TASK-006: Quick Action Prompts Configuration
+**Priority**: High | **Complexity**: S | **Dependencies**: None
+
+**Description**: Create action-specific prompt templates for Tighten, Embellish, Correct, Polish on backend.
+
+**Acceptance Criteria**:
+- [ ] Prompt config object with all 4 action types
+- [ ] Each prompt includes action rules, context placeholders, efficiency guidance
+- [ ] Position hint logic (beginning/middle/end based on line numbers)
+- [ ] Prompts instruct Claude to use Read then Edit tool
+
+**Files**: Create: `backend/src/pair-writing-prompts.ts`
+
+**Testing**: Unit test for prompt template generation
+
+---
+
+### TASK-007: Quick Action Handler
+**Priority**: Critical | **Complexity**: L | **Dependencies**: TASK-001, TASK-006
+
+**Description**: Implement `handleQuickAction` in backend to create task-scoped Claude session with Read/Edit tools.
+
+**Acceptance Criteria**:
+- [ ] Validates file path within vault
+- [ ] Builds prompt from action template + request context
+- [ ] Creates Claude session with Read and Edit tools scoped to vault
+- [ ] Streams all events (tool_start, tool_end, response_chunk, response_end)
+- [ ] Session terminates after Claude confirms completion
+
+**Files**:
+- Create: `backend/src/handlers/pair-writing-handlers.ts`
+- Modify: `backend/src/websocket-handler.ts` (route new message type)
+
+**Testing**: Unit tests with mocked SDK (MOCK_SDK=true); manual integration test with real Claude verifies file is modified
+
+---
+
+### TASK-008: Quick Action Frontend Flow
+**Priority**: Critical | **Complexity**: M | **Dependencies**: TASK-005, TASK-007
+
+**Description**: Wire context menu actions to WebSocket requests, handle streaming response, reload file on completion.
+
+**Acceptance Criteria**:
+- [ ] Menu action triggers `quick_action_request` with selection context
+- [ ] Loading indicator shown on selection during processing
+- [ ] Tool events displayed (optional: show "editing..." indicator)
+- [ ] On `response_end`, reload file content from disk
+- [ ] Toast displays Claude's brief confirmation message
+
+**Files**:
+- Modify: `frontend/src/components/EditorContextMenu.tsx`
+- Modify: `frontend/src/components/MemoryEditor.tsx`
+
+**Testing**: Unit tests with mocked WebSocket; manual E2E: select text -> Tighten -> verify file content changed on disk, toast displayed
+
+---
+
+## Pair Writing Mode
+
+### TASK-009: Pair Writing State Management
+**Priority**: High | **Complexity**: M | **Dependencies**: None
+
+**Description**: Create `usePairWritingState` hook to manage session state (content, snapshot, conversation).
+
+**Acceptance Criteria**:
+- [ ] State includes: isActive, content, snapshot, conversation[], selection, hasUnsavedChanges
+- [ ] Actions: setContent, takeSnapshot, addMessage, setSelection, clearAll
+- [ ] Conversation cleared on exit (session-scoped per REQ-F-27)
+
+**Files**: Create: `frontend/src/hooks/usePairWritingState.ts`
+
+**Testing**: Unit tests for state transitions
+
+---
+
+### TASK-010: Conversation Pane Extraction
+**Priority**: High | **Complexity**: M | **Dependencies**: None
+
+**Description**: Extract shared conversation display from Discussion.tsx into reusable `ConversationPane`.
+
+**Acceptance Criteria**:
+- [ ] Renders message list, streaming indicator
+- [ ] Accepts messages prop and onSendMessage callback
+- [ ] Matches existing Discussion styling per REQ-NF-4
+- [ ] Discussion.tsx refactored to use extracted component
+
+**Files**:
+- Create: `frontend/src/components/ConversationPane.tsx`
+- Modify: `frontend/src/components/Discussion.tsx`
+
+**Testing**: Unit tests for message rendering; manual visual check that Discussion mode appearance unchanged
+
+---
+
+### TASK-011: Pair Writing Mode Layout
+**Priority**: High | **Complexity**: L | **Dependencies**: TASK-009, TASK-010
+
+**Description**: Create `PairWritingMode` container with split-screen layout, toolbar, and desktop-only visibility.
+
+**Acceptance Criteria**:
+- [ ] Split-screen: editor (left), conversation (right) per REQ-F-11
+- [ ] CSS Grid layout, 50/50 split
+- [ ] PairWritingToolbar with Snapshot, Save, Exit buttons
+- [ ] Exit warns if hasUnsavedChanges (manual edits only; Quick Actions persist immediately)
+- [ ] Hidden via CSS media query on touch devices per REQ-F-10
+
+**Files**:
+- Create: `frontend/src/components/PairWritingMode.tsx`
+- Create: `frontend/src/components/PairWritingToolbar.tsx`
+- Create: `frontend/src/components/PairWritingMode.module.css`
+
+**Testing**: Unit tests for layout, exit warning; manual desktop/mobile visibility test
+
+---
+
+### TASK-012: Pair Writing Entry Point in BrowseMode
+**Priority**: Medium | **Complexity**: S | **Dependencies**: TASK-011
+
+**Description**: Add "Pair Writing" button to BrowseMode that toggles into PairWritingMode.
+
+**Acceptance Criteria**:
+- [ ] Button visible when viewing markdown file on desktop
+- [ ] Button hidden on mobile/touch devices
+- [ ] Click enters Pair Writing Mode with current file
+- [ ] Exiting Pair Writing returns to standard Browse view
+
+**Files**: Modify: `frontend/src/components/BrowseMode.tsx`
+
+**Testing**: Integration test: open file -> click button -> split view appears
+
+---
+
+## Advisory Actions & Chat
+
+### TASK-013: Advisory Action Handlers
+**Priority**: Medium | **Complexity**: M | **Dependencies**: TASK-001, TASK-007
+
+**Description**: Implement `handleAdvisoryAction` and `handlePairChat` for Validate, Critique, Compare, and freeform chat.
+
+**Acceptance Criteria**:
+- [ ] Advisory actions use streaming (no tool use, just response)
+- [ ] Compare action includes snapshot selection if provided
+- [ ] Pair chat includes optional selection context
+- [ ] All use existing response_chunk streaming
+
+**Files**:
+- Modify: `backend/src/handlers/pair-writing-handlers.ts`
+- Modify: `backend/src/websocket-handler.ts`
+
+**Testing**: Unit tests for each action type
+
+---
+
+### TASK-014: Full Context Menu in Pair Writing Mode
+**Priority**: Medium | **Complexity**: L | **Dependencies**: TASK-004, TASK-011, TASK-013
+
+**Description**: Extend EditorContextMenu to show all 6 actions in Pair Writing Mode, plus Compare when snapshot exists.
+
+**Acceptance Criteria**:
+- [ ] Menu receives mode flag (browse vs pair-writing)
+- [ ] In Pair Writing: shows Quick Actions + Validate + Critique
+- [ ] If snapshot exists: shows "Compare to snapshot"
+- [ ] Advisory actions dispatch to conversation pane (not inline)
+- [ ] SelectionQuote component shows selection above chat input
+- [ ] Tab hotkey jumps to chat input per REQ-F-19
+
+**Files**:
+- Modify: `frontend/src/components/EditorContextMenu.tsx`
+- Create: `frontend/src/components/SelectionQuote.tsx`
+- Modify: `frontend/src/components/PairWritingMode.tsx`
+
+**Testing**: Unit tests with mocked WebSocket; manual E2E for each: Validate selection shows response in conversation, Critique shows feedback, Compare shows diff analysis
+
+---
+
+## Dependency Graph
+```
+TASK-001 (Protocol) ─────────────────────────────┐
+                                                  │
+TASK-002 (LongPress) ───┐                        │
+                        ├──> TASK-004 (Menu) ────┼──> TASK-005 (Integrate) ──> TASK-008 (Quick Frontend)
+TASK-003 (Selection) ───┘                        │
+                                                  │
+TASK-006 (Prompts) ──────────────────────────────┼──> TASK-007 (Quick Handler) ──> TASK-008
+                                                  │
+TASK-009 (State) ────────────────────────────────┼──> TASK-011 (Layout) ──> TASK-012 (Entry)
+                                                  │                    │
+TASK-010 (ConvoPane) ────────────────────────────┘                    │
+                                                                       │
+TASK-013 (Advisory Handlers) ──────────────────────────────────────────┼──> TASK-014 (Full Menu)
+```
+
+## Implementation Order
+
+**Phase 1** (Foundation, parallel):
+- TASK-001: Protocol extensions
+- TASK-002: Long-press hook
+- TASK-003: Selection hook
+- TASK-006: Prompt config
+- TASK-009: State management
+- TASK-010: Conversation pane extraction
+
+**Phase 2** (Context Menu):
+- TASK-004: Context menu component
+- TASK-005: Menu integration into editor
+
+**Phase 3** (Quick Actions):
+- TASK-007: Quick action backend handler
+- TASK-008: Quick action frontend flow
+
+**Phase 4** (Pair Writing Mode):
+- TASK-011: Layout + toolbar
+- TASK-012: Entry point in BrowseMode
+- TASK-013: Advisory handlers
+- TASK-014: Full context menu
+
+## Notes
+
+- **Parallelization**: Phase 1 tasks have no interdependencies and can all be worked in parallel
+- **Critical path**: TASK-001 -> TASK-007 -> TASK-008 (Quick Actions must work before Pair Writing)
diff --git a/backend/src/__tests__/pair-writing-prompts.test.ts b/backend/src/__tests__/pair-writing-prompts.test.ts
new file mode 100644
index 00000000..1c87de88
--- /dev/null
+++ b/backend/src/__tests__/pair-writing-prompts.test.ts
@@ -0,0 +1,434 @@
+/**
+ * Tests for Pair Writing Prompt Templates
+ *
+ * Tests cover:
+ * - Position hint calculation (beginning/middle/end thresholds)
+ * - Prompt building for all 4 action types
+ * - Context validation
+ * - Action config retrieval
+ * - Type guard for action types
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  calculatePositionHint,
+  formatPositionHint,
+  buildQuickActionPrompt,
+  validateQuickActionContext,
+  getActionConfig,
+  isQuickActionType,
+  type QuickActionContext,
+} from "../pair-writing-prompts.js";
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+function createMockContext(overrides: Partial<QuickActionContext> = {}): QuickActionContext {
+  return {
+    filePath: "docs/notes/meeting-notes.md",
+    selectedText: "This is the text that needs revision.",
+    contextBefore: "The previous paragraph provides context.",
+    contextAfter: "The following paragraph continues the thought.",
+    startLine: 15,
+    endLine: 17,
+    totalLines: 100,
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// calculatePositionHint Tests
+// =============================================================================
+
+describe("calculatePositionHint", () => {
+  describe("beginning threshold (1-20%)", () => {
+    it("should return 'beginning' for line 1 of 100", () => {
+      expect(calculatePositionHint(1, 1, 100)).toBe("beginning");
+    });
+
+    it("should return 'beginning' for lines 1-5 of 100", () => {
+      expect(calculatePositionHint(1, 5, 100)).toBe("beginning");
+    });
+
+    it("should return 'beginning' for line 20 of 100 (boundary)", () => {
+      expect(calculatePositionHint(20, 20, 100)).toBe("beginning");
+    });
+
+    it("should return 'beginning' for lines 15-25 of 100 (midpoint = 20)", () => {
+      expect(calculatePositionHint(15, 25, 100)).toBe("beginning");
+    });
+  });
+
+  describe("middle threshold (20-80%)", () => {
+    it("should return 'middle' for line 50 of 100", () => {
+      expect(calculatePositionHint(50, 50, 100)).toBe("middle");
+    });
+
+    it("should return 'middle' for lines 30-40 of 100", () => {
+      expect(calculatePositionHint(30, 40, 100)).toBe("middle");
+    });
+
+    it("should return 'middle' for line 21 of 100 (just past beginning)", () => {
+      expect(calculatePositionHint(21, 21, 100)).toBe("middle");
+    });
+
+    it("should return 'middle' for line 79 of 100 (just before end)", () => {
+      expect(calculatePositionHint(79, 79, 100)).toBe("middle");
+    });
+  });
+
+  describe("end threshold (80-100%)", () => {
+    it("should return 'end' for line 100 of 100", () => {
+      expect(calculatePositionHint(100, 100, 100)).toBe("end");
+    });
+
+    it("should return 'end' for lines 90-100 of 100", () => {
+      expect(calculatePositionHint(90, 100, 100)).toBe("end");
+    });
+
+    it("should return 'end' for line 80 of 100 (boundary)", () => {
+      expect(calculatePositionHint(80, 80, 100)).toBe("end");
+    });
+
+    it("should return 'end' for lines 75-85 of 100 (midpoint = 80)", () => {
+      expect(calculatePositionHint(75, 85, 100)).toBe("end");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle single-line documents", () => {
+      expect(calculatePositionHint(1, 1, 1)).toBe("end");
+    });
+
+    it("should handle very short documents (5 lines)", () => {
+      expect(calculatePositionHint(1, 1, 5)).toBe("beginning");
+      expect(calculatePositionHint(3, 3, 5)).toBe("middle");
+      expect(calculatePositionHint(5, 5, 5)).toBe("end");
+    });
+
+    it("should handle totalLines of 0 gracefully", () => {
+      expect(calculatePositionHint(1, 1, 0)).toBe("middle");
+    });
+
+    it("should handle negative totalLines gracefully", () => {
+      expect(calculatePositionHint(1, 1, -10)).toBe("middle");
+    });
+
+    it("should use selection midpoint for multi-line selections", () => {
+      // Lines 10-30 of 100, midpoint = 20 (boundary of beginning)
+      expect(calculatePositionHint(10, 30, 100)).toBe("beginning");
+      // Lines 70-90 of 100, midpoint = 80 (boundary of end)
+      expect(calculatePositionHint(70, 90, 100)).toBe("end");
+    });
+  });
+});
+
+// =============================================================================
+// formatPositionHint Tests
+// =============================================================================
+
+describe("formatPositionHint", () => {
+  it("should format 'beginning' correctly", () => {
+    expect(formatPositionHint("beginning")).toBe("near the beginning of");
+  });
+
+  it("should format 'middle' correctly", () => {
+    expect(formatPositionHint("middle")).toBe("in the middle of");
+  });
+
+  it("should format 'end' correctly", () => {
+    expect(formatPositionHint("end")).toBe("near the end of");
+  });
+});
+
+// =============================================================================
+// buildQuickActionPrompt Tests
+// =============================================================================
+
+describe("buildQuickActionPrompt", () => {
+  describe("common prompt structure", () => {
+    it("should include efficiency guidance", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain("Be efficient");
+      expect(prompt).toContain("read the file, make the edit, confirm briefly");
+    });
+
+    it("should include file path in task description", () => {
+      const context = createMockContext({ filePath: "notes/important.md" });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain('"notes/important.md"');
+    });
+
+    it("should include line numbers in task description", () => {
+      const context = createMockContext({ startLine: 25, endLine: 30 });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain("(lines 25-30)");
+    });
+
+    it("should include selected text", () => {
+      const context = createMockContext({ selectedText: "Unique selection text here." });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain("Unique selection text here.");
+    });
+
+    it("should include context before and after", () => {
+      const context = createMockContext({
+        contextBefore: "BEFORE_CONTEXT_TEXT",
+        contextAfter: "AFTER_CONTEXT_TEXT",
+      });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain("BEFORE_CONTEXT_TEXT");
+      expect(prompt).toContain("AFTER_CONTEXT_TEXT");
+      expect(prompt).toContain("[SELECTION TO EDIT]");
+    });
+
+    it("should include workflow instructions", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain("1. Read the file to see current state");
+      expect(prompt).toContain("2. Use Edit tool to replace the selection");
+      expect(prompt).toContain("3. Confirm with one sentence");
+    });
+
+    it("should include brief response guidance", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain("Keep responses brief. No lengthy explanations.");
+    });
+
+    it("should include context tone matching note", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain("for tone matching - do not modify this");
+    });
+  });
+
+  describe("position hint integration", () => {
+    it("should include position hint for beginning", () => {
+      const context = createMockContext({ startLine: 5, endLine: 10, totalLines: 100 });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain("near the beginning of");
+    });
+
+    it("should include position hint for middle", () => {
+      const context = createMockContext({ startLine: 45, endLine: 55, totalLines: 100 });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain("in the middle of");
+    });
+
+    it("should include position hint for end", () => {
+      const context = createMockContext({ startLine: 90, endLine: 100, totalLines: 100 });
+      const prompt = buildQuickActionPrompt("tighten", context);
+      expect(prompt).toContain("near the end of");
+    });
+  });
+
+  describe("tighten action", () => {
+    it("should include tighten-specific rules", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain('Rules for "Tighten"');
+      expect(prompt).toContain("Preserve the core meaning");
+      expect(prompt).toContain("Remove filler words, redundant phrases, unnecessary qualifiers");
+      expect(prompt).toContain("Maintain the author's voice");
+    });
+
+    it("should include tighten task description", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain("Task: Tighten the selected text");
+    });
+
+    it("should reference tightened version in workflow", () => {
+      const prompt = buildQuickActionPrompt("tighten", createMockContext());
+      expect(prompt).toContain("with tightened version");
+    });
+  });
+
+  describe("embellish action", () => {
+    it("should include embellish-specific rules", () => {
+      const prompt = buildQuickActionPrompt("embellish", createMockContext());
+      expect(prompt).toContain('Rules for "Embellish"');
+      expect(prompt).toContain("Add vivid details, examples, or explanatory content");
+      expect(prompt).toContain("Enhance clarity and engagement");
+      expect(prompt).toContain("Avoid purple prose");
+    });
+
+    it("should include embellish task description", () => {
+      const prompt = buildQuickActionPrompt("embellish", createMockContext());
+      expect(prompt).toContain("Task: Embellish the selected text");
+    });
+
+    it("should reference embellished version in workflow", () => {
+      const prompt = buildQuickActionPrompt("embellish", createMockContext());
+      expect(prompt).toContain("with embellished version");
+    });
+  });
+
+  describe("correct action", () => {
+    it("should include correct-specific rules", () => {
+      const prompt = buildQuickActionPrompt("correct", createMockContext());
+      expect(prompt).toContain('Rules for "Correct"');
+      expect(prompt).toContain("Fix spelling, grammar, and punctuation errors");
+      expect(prompt).toContain("Correct word usage and syntax issues");
+      expect(prompt).toContain("Do not change the meaning, style, or voice");
+      expect(prompt).toContain("Only fix clear errors");
+    });
+
+    it("should include correct task description", () => {
+      const prompt = buildQuickActionPrompt("correct", createMockContext());
+      expect(prompt).toContain("Task: Correct errors in the selected text");
+    });
+
+    it("should reference corrected version in workflow", () => {
+      const prompt = buildQuickActionPrompt("correct", createMockContext());
+      expect(prompt).toContain("with corrected version");
+    });
+  });
+
+  describe("polish action", () => {
+    it("should include polish-specific rules", () => {
+      const prompt = buildQuickActionPrompt("polish", createMockContext());
+      expect(prompt).toContain('Rules for "Polish"');
+      expect(prompt).toContain("Improve sentence flow and readability");
+      expect(prompt).toContain("Smooth awkward phrasing");
+      expect(prompt).toContain("Enhance word choices");
+      expect(prompt).toContain("Maintain the author's voice");
+    });
+
+    it("should include polish task description", () => {
+      const prompt = buildQuickActionPrompt("polish", createMockContext());
+      expect(prompt).toContain("Task: Polish the selected text");
+    });
+
+    it("should reference polished version in workflow", () => {
+      const prompt = buildQuickActionPrompt("polish", createMockContext());
+      expect(prompt).toContain("with polished version");
+    });
+  });
+});
+
+// =============================================================================
+// validateQuickActionContext Tests
+// =============================================================================
+
+describe("validateQuickActionContext", () => {
+  it("should return true for valid context", () => {
+    expect(validateQuickActionContext(createMockContext())).toBe(true);
+  });
+
+  it("should throw for empty filePath", () => {
+    const context = createMockContext({ filePath: "" });
+    expect(() => validateQuickActionContext(context)).toThrow("filePath is required");
+  });
+
+  it("should throw for empty selectedText", () => {
+    const context = createMockContext({ selectedText: "" });
+    expect(() => validateQuickActionContext(context)).toThrow("selectedText is required");
+  });
+
+  it("should throw for startLine < 1", () => {
+    const context = createMockContext({ startLine: 0 });
+    expect(() => validateQuickActionContext(context)).toThrow("startLine must be >= 1");
+  });
+
+  it("should throw for negative startLine", () => {
+    const context = createMockContext({ startLine: -5 });
+    expect(() => validateQuickActionContext(context)).toThrow("startLine must be >= 1");
+  });
+
+  it("should throw for endLine < startLine", () => {
+    const context = createMockContext({ startLine: 20, endLine: 15 });
+    expect(() => validateQuickActionContext(context)).toThrow("endLine must be >= startLine");
+  });
+
+  it("should allow endLine == startLine (single line selection)", () => {
+    const context = createMockContext({ startLine: 10, endLine: 10 });
+    expect(validateQuickActionContext(context)).toBe(true);
+  });
+
+  it("should throw for totalLines < 1", () => {
+    const context = createMockContext({ totalLines: 0 });
+    expect(() => validateQuickActionContext(context)).toThrow("totalLines must be >= 1");
+  });
+
+  it("should throw for negative totalLines", () => {
+    const context = createMockContext({ totalLines: -10 });
+    expect(() => validateQuickActionContext(context)).toThrow("totalLines must be >= 1");
+  });
+});
+
+// =============================================================================
+// getActionConfig Tests
+// =============================================================================
+
+describe("getActionConfig", () => {
+  it("should return config for tighten", () => {
+    const config = getActionConfig("tighten");
+    expect(config.name).toBe("Tighten");
+    expect(config.taskDescription).toContain("Tighten");
+    expect(config.rules.length).toBeGreaterThan(0);
+  });
+
+  it("should return config for embellish", () => {
+    const config = getActionConfig("embellish");
+    expect(config.name).toBe("Embellish");
+    expect(config.taskDescription).toContain("Embellish");
+    expect(config.rules.length).toBeGreaterThan(0);
+  });
+
+  it("should return config for correct", () => {
+    const config = getActionConfig("correct");
+    expect(config.name).toBe("Correct");
+    expect(config.taskDescription).toContain("Correct");
+    expect(config.rules.length).toBeGreaterThan(0);
+  });
+
+  it("should return config for polish", () => {
+    const config = getActionConfig("polish");
+    expect(config.name).toBe("Polish");
+    expect(config.taskDescription).toContain("Polish");
+    expect(config.rules.length).toBeGreaterThan(0);
+  });
+
+  it("should have unique rules for each action", () => {
+    const tightenRules = getActionConfig("tighten").rules.join("");
+    const embellishRules = getActionConfig("embellish").rules.join("");
+    const correctRules = getActionConfig("correct").rules.join("");
+    const polishRules = getActionConfig("polish").rules.join("");
+
+    expect(tightenRules).not.toBe(embellishRules);
+    expect(tightenRules).not.toBe(correctRules);
+    expect(tightenRules).not.toBe(polishRules);
+    expect(embellishRules).not.toBe(correctRules);
+    expect(embellishRules).not.toBe(polishRules);
+    expect(correctRules).not.toBe(polishRules);
+  });
+});
+
+// =============================================================================
+// isQuickActionType Tests
+// =============================================================================
+
+describe("isQuickActionType", () => {
+  it("should return true for valid action types", () => {
+    expect(isQuickActionType("tighten")).toBe(true);
+    expect(isQuickActionType("embellish")).toBe(true);
+    expect(isQuickActionType("correct")).toBe(true);
+    expect(isQuickActionType("polish")).toBe(true);
+  });
+
+  it("should return false for invalid action types", () => {
+    expect(isQuickActionType("invalid")).toBe(false);
+    expect(isQuickActionType("TIGHTEN")).toBe(false);
+    expect(isQuickActionType("Tighten")).toBe(false);
+    expect(isQuickActionType("")).toBe(false);
+    expect(isQuickActionType("rewrite")).toBe(false);
+    expect(isQuickActionType("summarize")).toBe(false);
+  });
+
+  it("should work as type guard", () => {
+    const action = "tighten" as string;
+    if (isQuickActionType(action)) {
+      // TypeScript should recognize action as QuickActionType here
+      const config = getActionConfig(action);
+      expect(config.name).toBe("Tighten");
+    }
+  });
+});
diff --git a/backend/src/handlers/__tests__/browser-handlers.test.ts b/backend/src/handlers/__tests__/browser-handlers.test.ts
index 521019d4..811fc0d8 100644
--- a/backend/src/handlers/__tests__/browser-handlers.test.ts
+++ b/backend/src/handlers/__tests__/browser-handlers.test.ts
@@ -82,6 +82,9 @@ function createMockDeps(
     getAllTasks: () => Promise.resolve({ tasks: [], incomplete: 0, total: 0 }),
     toggleTask: () => Promise.resolve({ success: true }),
     getRecentSessions: () => Promise.resolve([]),
+    createSession: () => Promise.resolve({ sessionId: "mock-session", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    resumeSession: () => Promise.resolve({ sessionId: "", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    appendMessage: () => Promise.resolve(),
     loadVaultConfig: () => Promise.resolve({}),
   };
 }
@@ -281,6 +284,9 @@ function createMockDepsWithRename(
     getAllTasks: () => Promise.resolve({ tasks: [], incomplete: 0, total: 0 }),
     toggleTask: () => Promise.resolve({ success: true }),
     getRecentSessions: () => Promise.resolve([]),
+    createSession: () => Promise.resolve({ sessionId: "mock-session", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    resumeSession: () => Promise.resolve({ sessionId: "", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    appendMessage: () => Promise.resolve(),
     loadVaultConfig: () => Promise.resolve({}),
   };
 }
@@ -493,6 +499,9 @@ function createMockDepsWithMove(
     getAllTasks: () => Promise.resolve({ tasks: [], incomplete: 0, total: 0 }),
     toggleTask: () => Promise.resolve({ success: true }),
     getRecentSessions: () => Promise.resolve([]),
+    createSession: () => Promise.resolve({ sessionId: "mock-session", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    resumeSession: () => Promise.resolve({ sessionId: "", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    appendMessage: () => Promise.resolve(),
     loadVaultConfig: () => Promise.resolve({}),
   };
 }
@@ -735,6 +744,9 @@ function createMockDepsWithGetDirContents(
     getAllTasks: () => Promise.resolve({ tasks: [], incomplete: 0, total: 0 }),
     toggleTask: () => Promise.resolve({ success: true }),
     getRecentSessions: () => Promise.resolve([]),
+    createSession: () => Promise.resolve({ sessionId: "mock-session", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    resumeSession: () => Promise.resolve({ sessionId: "", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    appendMessage: () => Promise.resolve(),
     loadVaultConfig: () => Promise.resolve({}),
   };
 }
@@ -925,6 +937,9 @@ function createMockDepsWithDeleteDir(
     getAllTasks: () => Promise.resolve({ tasks: [], incomplete: 0, total: 0 }),
     toggleTask: () => Promise.resolve({ success: true }),
     getRecentSessions: () => Promise.resolve([]),
+    createSession: () => Promise.resolve({ sessionId: "mock-session", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    resumeSession: () => Promise.resolve({ sessionId: "", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    appendMessage: () => Promise.resolve(),
     loadVaultConfig: () => Promise.resolve({}),
   };
 }
diff --git a/backend/src/handlers/__tests__/pair-writing-handlers.test.ts b/backend/src/handlers/__tests__/pair-writing-handlers.test.ts
new file mode 100644
index 00000000..99644639
--- /dev/null
+++ b/backend/src/handlers/__tests__/pair-writing-handlers.test.ts
@@ -0,0 +1,779 @@
+/**
+ * Tests for Pair Writing WebSocket Handlers
+ *
+ * Tests cover:
+ * - handleQuickAction message handling
+ * - Vault selection validation
+ * - Path validation within vault
+ * - Prompt building and session creation
+ * - Streaming event handling
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { VaultInfo, ServerMessage, QuickActionRequestMessage, AdvisoryActionRequestMessage } from "@memory-loop/shared";
+import type { HandlerContext, ConnectionState, RequiredHandlerDependencies } from "../types.js";
+import { handleQuickAction, handleAdvisoryAction } from "../pair-writing-handlers.js";
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+let tempDir: string;
+let mockVault: VaultInfo;
+let sentMessages: ServerMessage[];
+let sentErrors: Array<{ code: string; message: string }>;
+let mockState: ConnectionState;
+
+beforeEach(async () => {
+  // Create a real temp directory for path validation tests
+  tempDir = await mkdtemp(join(tmpdir(), "pair-writing-test-"));
+
+  // Create test directory structure
+  await mkdir(join(tempDir, "notes"), { recursive: true });
+  await writeFile(join(tempDir, "notes", "test-file.md"), "# Test File\n\nSome content here.");
+  await writeFile(join(tempDir, "CLAUDE.md"), "# Test Vault");
+
+  mockVault = {
+    id: "test-vault",
+    name: "Test Vault",
+    path: tempDir,
+    contentRoot: tempDir,
+    hasClaudeMd: true,
+    inboxPath: "00_Inbox",
+    metadataPath: "06_Metadata/memory-loop",
+    attachmentPath: "attachments",
+    setupComplete: true,
+    promptsPerGeneration: 5,
+    maxPoolSize: 50,
+    quotesPerWeek: 1,
+    badges: [],
+    order: 0,
+  };
+  sentMessages = [];
+  sentErrors = [];
+  mockState = {
+    currentVault: mockVault,
+    currentSessionId: null,
+    activeQuery: null,
+    pendingPermissions: new Map(),
+    pendingAskUserQuestions: new Map(),
+    searchIndex: null,
+    activeModel: null,
+    cumulativeTokens: 0,
+    contextWindow: null,
+    healthCollector: null,
+    activeMeeting: null,
+  };
+});
+
+afterEach(async () => {
+  if (tempDir) {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+function createMockDeps(): RequiredHandlerDependencies {
+  return {
+    captureToDaily: () => Promise.resolve({ success: true, timestamp: "", notePath: "" }),
+    getRecentNotes: () => Promise.resolve([]),
+    listDirectory: () => Promise.resolve([]),
+    readMarkdownFile: () => Promise.resolve({ content: "", truncated: false }),
+    writeMarkdownFile: () => Promise.resolve(),
+    deleteFile: () => Promise.resolve(),
+    getDirectoryContents: () => Promise.resolve({ files: [], directories: [], totalFiles: 0, totalDirectories: 0, truncated: false }),
+    deleteDirectory: () => Promise.resolve({ path: "", filesDeleted: 0, directoriesDeleted: 0 }),
+    archiveFile: () => Promise.resolve({ originalPath: "", archivePath: "" }),
+    createDirectory: () => Promise.resolve(""),
+    createFile: () => Promise.resolve(""),
+    renameFile: () => Promise.resolve({ oldPath: "", newPath: "" }),
+    moveFile: () => Promise.resolve({ oldPath: "", newPath: "", isDirectory: false }),
+    updateReferences: () => Promise.resolve({ filesModified: 0, referencesUpdated: 0 }),
+    getInspiration: () => Promise.resolve({ contextual: null, quote: { text: "", attribution: "" } }),
+    getAllTasks: () => Promise.resolve({ tasks: [], incomplete: 0, total: 0 }),
+    toggleTask: () => Promise.resolve({ success: true }),
+    getRecentSessions: () => Promise.resolve([]),
+    createSession: () => Promise.resolve({ sessionId: "mock-session", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    resumeSession: () => Promise.resolve({ sessionId: "", events: (async function* () {})(), interrupt: async () => {}, supportedCommands: () => Promise.resolve([]) }),
+    appendMessage: () => Promise.resolve(),
+    loadVaultConfig: () => Promise.resolve({}),
+  };
+}
+
+/**
+ * Creates a mock createSession function that simulates SDK events.
+ */
+function createMockCreateSession(events: Array<{
+  type: string;
+  [key: string]: unknown;
+}>) {
+  return () => {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async function* generator() {
+      for (const event of events) {
+        yield event;
+      }
+    }
+    // Cast to satisfy SessionQueryResult type - test events don't need full SDK message structure
+    return Promise.resolve({
+      sessionId: "mock-session-id",
+      events: generator() as AsyncGenerator<import("@anthropic-ai/claude-agent-sdk").SDKMessage, void, unknown>,
+      interrupt: () => Promise.resolve(),
+      supportedCommands: () => Promise.resolve([]),
+    });
+  };
+}
+
+function createMockContext(
+  state: ConnectionState = mockState,
+  createSessionOverride?: ReturnType<typeof createMockCreateSession>
+): HandlerContext {
+  const deps = createMockDeps();
+  if (createSessionOverride) {
+    deps.createSession = createSessionOverride;
+  }
+  return {
+    state,
+    send: (message: ServerMessage) => {
+      sentMessages.push(message);
+    },
+    sendError: (code, message) => {
+      sentErrors.push({ code, message });
+    },
+    deps,
+  };
+}
+
+function createMockRequest(overrides: Partial<QuickActionRequestMessage> = {}): QuickActionRequestMessage {
+  return {
+    type: "quick_action_request",
+    action: "tighten",
+    selection: "This is some text that needs to be tightened.",
+    contextBefore: "The previous paragraph sets up context.",
+    contextAfter: "The following paragraph continues the thought.",
+    filePath: "notes/test-file.md",
+    selectionStartLine: 10,
+    selectionEndLine: 12,
+    totalLines: 50,
+    ...overrides,
+  };
+}
+
+function createAdvisoryRequest(overrides: Partial<AdvisoryActionRequestMessage> = {}): AdvisoryActionRequestMessage {
+  return {
+    type: "advisory_action_request",
+    action: "validate",
+    selection: "This text needs to be validated for accuracy.",
+    contextBefore: "The previous paragraph provides context.",
+    contextAfter: "The following paragraph continues.",
+    filePath: "notes/test-file.md",
+    selectionStartLine: 5,
+    selectionEndLine: 7,
+    totalLines: 30,
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// handleQuickAction Tests - Validation
+// =============================================================================
+
+describe("handleQuickAction - validation", () => {
+  it("requires vault to be selected", async () => {
+    const ctx = createMockContext({
+      ...mockState,
+      currentVault: null,
+    });
+
+    await handleQuickAction(ctx, createMockRequest());
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("VAULT_NOT_FOUND");
+    expect(error?.message).toContain("No vault selected");
+  });
+
+  it("validates action type", async () => {
+    const ctx = createMockContext();
+    const request = createMockRequest({
+      action: "invalid" as "tighten",
+    });
+
+    await handleQuickAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("VALIDATION_ERROR");
+    expect(error?.message).toContain("Invalid action type");
+  });
+
+  it("validates selection is not empty", async () => {
+    const ctx = createMockContext();
+    const request = createMockRequest({
+      selection: "",
+    });
+
+    // Selection validation happens before path validation, no mock needed
+    await handleQuickAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("VALIDATION_ERROR");
+    expect(error?.message).toContain("Selection is required");
+  });
+
+  it("rejects path traversal attempts", async () => {
+    const ctx = createMockContext();
+    const request = createMockRequest({
+      filePath: "../../../etc/passwd",
+    });
+
+    await handleQuickAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("PATH_TRAVERSAL");
+    expect(error?.message).toContain("not within vault");
+  });
+});
+
+// =============================================================================
+// handleQuickAction Tests - Streaming
+// =============================================================================
+
+describe("handleQuickAction - streaming", () => {
+  it("sends response_start at beginning", async () => {
+    const request = createMockRequest();
+
+    // Mock SDK with minimal events
+    const mockCreateSession = createMockCreateSession([
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    const startMsg = sentMessages.find((m) => m.type === "response_start");
+    expect(startMsg).toBeDefined();
+    expect(startMsg?.type).toBe("response_start");
+  });
+
+  it("sends response_end at completion", async () => {
+    const request = createMockRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    const endMsg = sentMessages.find((m) => m.type === "response_end");
+    expect(endMsg).toBeDefined();
+    expect(endMsg?.type).toBe("response_end");
+  });
+
+  it("streams text deltas as response_chunk", async () => {
+    const request = createMockRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      {
+        type: "stream_event",
+        event: { type: "content_block_start", index: 0, content_block: { type: "text" } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Tightened" } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: " the text." } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_stop", index: 0 },
+      },
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    const chunks = sentMessages.filter((m) => m.type === "response_chunk");
+    expect(chunks.length).toBe(2);
+    expect((chunks[0] as { content: string }).content).toBe("Tightened");
+    expect((chunks[1] as { content: string }).content).toBe(" the text.");
+  });
+
+  it("streams tool_start and tool_end events", async () => {
+    const request = createMockRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      {
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          index: 0,
+          content_block: { type: "tool_use", id: "tool_123", name: "Read" },
+        },
+      },
+      {
+        type: "stream_event",
+        event: {
+          type: "content_block_delta",
+          index: 0,
+          delta: { type: "input_json_delta", partial_json: '{"file_path":"test.md"}' },
+        },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_stop", index: 0 },
+      },
+      {
+        type: "user",
+        session_id: "test",
+        message: {
+          content: [
+            { type: "tool_result", tool_use_id: "tool_123", content: "File content here" },
+          ],
+        },
+      },
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    const toolStart = sentMessages.find((m) => m.type === "tool_start");
+    expect(toolStart).toBeDefined();
+    expect((toolStart as { toolName: string }).toolName).toBe("Read");
+    expect((toolStart as { toolUseId: string }).toolUseId).toBe("tool_123");
+
+    const toolInput = sentMessages.find((m) => m.type === "tool_input");
+    expect(toolInput).toBeDefined();
+    expect((toolInput as { toolUseId: string }).toolUseId).toBe("tool_123");
+
+    const toolEnd = sentMessages.find((m) => m.type === "tool_end");
+    expect(toolEnd).toBeDefined();
+    expect((toolEnd as { toolUseId: string }).toolUseId).toBe("tool_123");
+  });
+});
+
+// =============================================================================
+// handleQuickAction Tests - Error Handling
+// =============================================================================
+
+describe("handleQuickAction - error handling", () => {
+  it("sends SDK_ERROR on createSession failure", async () => {
+    const request = createMockRequest();
+
+    // Mock createSession that throws an error
+    const mockCreateSession = () => Promise.reject(new Error("SDK connection failed"));
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("SDK_ERROR");
+    expect(error?.message).toContain("SDK connection failed");
+  });
+
+  it("handles empty events gracefully", async () => {
+    const request = createMockRequest();
+
+    const mockCreateSession = createMockCreateSession([]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    // Should still send response_start and response_end
+    const startMsg = sentMessages.find((m) => m.type === "response_start");
+    const endMsg = sentMessages.find((m) => m.type === "response_end");
+    expect(startMsg).toBeDefined();
+    expect(endMsg).toBeDefined();
+  });
+});
+
+// =============================================================================
+// handleQuickAction Tests - Action Types
+// =============================================================================
+
+describe("handleQuickAction - action types", () => {
+  const actions: Array<"tighten" | "embellish" | "correct" | "polish"> = [
+    "tighten",
+    "embellish",
+    "correct",
+    "polish",
+  ];
+
+  for (const action of actions) {
+    it(`accepts ${action} action type`, async () => {
+      const request = createMockRequest({ action });
+
+      const mockCreateSession = createMockCreateSession([
+        { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+      ]);
+      const ctx = createMockContext(mockState, mockCreateSession);
+
+      await handleQuickAction(ctx, request);
+
+      // No validation errors for valid action types
+      expect(sentErrors.filter((e) => e.code === "VALIDATION_ERROR")).toHaveLength(0);
+
+      // Should have sent response_start and response_end
+      const startMsg = sentMessages.find((m) => m.type === "response_start");
+      const endMsg = sentMessages.find((m) => m.type === "response_end");
+      expect(startMsg).toBeDefined();
+      expect(endMsg).toBeDefined();
+    });
+  }
+});
+
+// =============================================================================
+// handleQuickAction Tests - Context Usage
+// =============================================================================
+
+describe("handleQuickAction - context usage", () => {
+  it("calculates context usage from result event", async () => {
+    const request = createMockRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      {
+        type: "result",
+        subtype: "success",
+        usage: { input_tokens: 1000, output_tokens: 500 },
+        modelUsage: {
+          "claude-sonnet-4-20250514": { contextWindow: 200000 },
+        },
+      },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    const endMsg = sentMessages.find((m) => m.type === "response_end") as {
+      type: "response_end";
+      contextUsage?: number;
+    };
+    expect(endMsg).toBeDefined();
+    // 1500 / 200000 * 100 = 0.75%, rounds to 1%
+    expect(endMsg.contextUsage).toBeDefined();
+    expect(endMsg.contextUsage).toBeLessThanOrEqual(100);
+  });
+
+  it("includes durationMs in response_end", async () => {
+    const request = createMockRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleQuickAction(ctx, request);
+
+    const endMsg = sentMessages.find((m) => m.type === "response_end") as {
+      type: "response_end";
+      durationMs?: number;
+    };
+    expect(endMsg).toBeDefined();
+    expect(endMsg.durationMs).toBeDefined();
+    expect(endMsg.durationMs).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// =============================================================================
+// handleAdvisoryAction Tests - Validation
+// =============================================================================
+
+describe("handleAdvisoryAction - validation", () => {
+  it("requires vault to be selected", async () => {
+    const ctx = createMockContext({
+      ...mockState,
+      currentVault: null,
+    });
+
+    await handleAdvisoryAction(ctx, createAdvisoryRequest());
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("VAULT_NOT_FOUND");
+    expect(error?.message).toContain("No vault selected");
+  });
+
+  it("validates action type", async () => {
+    const ctx = createMockContext();
+    const request = createAdvisoryRequest({
+      action: "invalid" as "validate",
+    });
+
+    await handleAdvisoryAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("VALIDATION_ERROR");
+    expect(error?.message).toContain("Invalid advisory action type");
+  });
+
+  it("validates selection is not empty", async () => {
+    const ctx = createMockContext();
+    const request = createAdvisoryRequest({
+      selection: "",
+    });
+
+    await handleAdvisoryAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("VALIDATION_ERROR");
+    expect(error?.message).toContain("Selection is required");
+  });
+
+  it("rejects path traversal attempts", async () => {
+    const ctx = createMockContext();
+    const request = createAdvisoryRequest({
+      filePath: "../../../etc/passwd",
+    });
+
+    await handleAdvisoryAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("PATH_TRAVERSAL");
+    expect(error?.message).toContain("not within vault");
+  });
+});
+
+// =============================================================================
+// handleAdvisoryAction Tests - Streaming
+// =============================================================================
+
+describe("handleAdvisoryAction - streaming", () => {
+  it("sends response_start at beginning", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    const startMsg = sentMessages.find((m) => m.type === "response_start");
+    expect(startMsg).toBeDefined();
+    expect(startMsg?.type).toBe("response_start");
+  });
+
+  it("sends response_end at completion", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    const endMsg = sentMessages.find((m) => m.type === "response_end");
+    expect(endMsg).toBeDefined();
+    expect(endMsg?.type).toBe("response_end");
+  });
+
+  it("streams text deltas as response_chunk", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      {
+        type: "stream_event",
+        event: { type: "content_block_start", index: 0, content_block: { type: "text" } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Your text is " } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "accurate." } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_stop", index: 0 },
+      },
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    const chunks = sentMessages.filter((m) => m.type === "response_chunk");
+    expect(chunks.length).toBe(2);
+    expect((chunks[0] as { content: string }).content).toBe("Your text is ");
+    expect((chunks[1] as { content: string }).content).toBe("accurate.");
+  });
+});
+
+// =============================================================================
+// handleAdvisoryAction Tests - Error Handling
+// =============================================================================
+
+describe("handleAdvisoryAction - error handling", () => {
+  it("sends SDK_ERROR on createSession failure", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = () => Promise.reject(new Error("SDK connection failed"));
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    expect(sentErrors.length).toBe(1);
+    const error = sentErrors[0];
+    expect(error).toBeDefined();
+    expect(error?.code).toBe("SDK_ERROR");
+    expect(error?.message).toContain("SDK connection failed");
+  });
+
+  it("handles empty events gracefully", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    const startMsg = sentMessages.find((m) => m.type === "response_start");
+    const endMsg = sentMessages.find((m) => m.type === "response_end");
+    expect(startMsg).toBeDefined();
+    expect(endMsg).toBeDefined();
+  });
+});
+
+// =============================================================================
+// handleAdvisoryAction Tests - Action Types
+// =============================================================================
+
+describe("handleAdvisoryAction - action types", () => {
+  const actions: Array<"validate" | "critique" | "compare"> = [
+    "validate",
+    "critique",
+    "compare",
+  ];
+
+  for (const action of actions) {
+    it(`accepts ${action} action type`, async () => {
+      const request = createAdvisoryRequest({ action });
+
+      const mockCreateSession = createMockCreateSession([
+        { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+      ]);
+      const ctx = createMockContext(mockState, mockCreateSession);
+
+      await handleAdvisoryAction(ctx, request);
+
+      // No validation errors for valid action types
+      expect(sentErrors.filter((e) => e.code === "VALIDATION_ERROR")).toHaveLength(0);
+
+      // Should have sent response_start and response_end
+      const startMsg = sentMessages.find((m) => m.type === "response_start");
+      const endMsg = sentMessages.find((m) => m.type === "response_end");
+      expect(startMsg).toBeDefined();
+      expect(endMsg).toBeDefined();
+    });
+  }
+});
+
+// =============================================================================
+// handleAdvisoryAction Tests - Context Usage
+// =============================================================================
+
+describe("handleAdvisoryAction - context usage", () => {
+  it("calculates context usage from result event", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      {
+        type: "result",
+        subtype: "success",
+        usage: { input_tokens: 1000, output_tokens: 500 },
+        modelUsage: {
+          "claude-sonnet-4-20250514": { contextWindow: 200000 },
+        },
+      },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    const endMsg = sentMessages.find((m) => m.type === "response_end") as {
+      type: "response_end";
+      contextUsage?: number;
+    };
+    expect(endMsg).toBeDefined();
+    expect(endMsg.contextUsage).toBeDefined();
+    expect(endMsg.contextUsage).toBeLessThanOrEqual(100);
+  });
+
+  it("includes durationMs in response_end", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    const endMsg = sentMessages.find((m) => m.type === "response_end") as {
+      type: "response_end";
+      durationMs?: number;
+    };
+    expect(endMsg).toBeDefined();
+    expect(endMsg.durationMs).toBeDefined();
+    expect(endMsg.durationMs).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// =============================================================================
+// handleAdvisoryAction Tests - No Tool Events
+// =============================================================================
+
+describe("handleAdvisoryAction - no tool events", () => {
+  it("does not send tool_start for advisory actions", async () => {
+    const request = createAdvisoryRequest();
+
+    const mockCreateSession = createMockCreateSession([
+      {
+        type: "stream_event",
+        event: { type: "content_block_start", index: 0, content_block: { type: "text" } },
+      },
+      {
+        type: "stream_event",
+        event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Analysis complete." } },
+      },
+      { type: "result", subtype: "success", usage: { input_tokens: 100, output_tokens: 50 }, modelUsage: {} },
+    ]);
+    const ctx = createMockContext(mockState, mockCreateSession);
+
+    await handleAdvisoryAction(ctx, request);
+
+    // Advisory actions are text-only, no tool events
+    const toolStart = sentMessages.find((m) => m.type === "tool_start");
+    const toolEnd = sentMessages.find((m) => m.type === "tool_end");
+    expect(toolStart).toBeUndefined();
+    expect(toolEnd).toBeUndefined();
+  });
+});
diff --git a/backend/src/handlers/index.ts b/backend/src/handlers/index.ts
index 23fe72bc..0eb9092f 100644
--- a/backend/src/handlers/index.ts
+++ b/backend/src/handlers/index.ts
@@ -47,3 +47,9 @@ export {
   handleGetMeetingState,
   handleMeetingCapture,
 } from "./meeting-handlers.js";
+
+// Pair writing handlers
+export {
+  handleQuickAction,
+  handleAdvisoryAction,
+} from "./pair-writing-handlers.js";
diff --git a/backend/src/handlers/pair-writing-handlers.ts b/backend/src/handlers/pair-writing-handlers.ts
new file mode 100644
index 00000000..b5ea8145
--- /dev/null
+++ b/backend/src/handlers/pair-writing-handlers.ts
@@ -0,0 +1,742 @@
+/**
+ * Pair Writing Mode Handlers
+ *
+ * Handles:
+ * - Quick Actions (Tighten, Embellish, Correct, Polish) via existing discussion session
+ * - Advisory Actions (Validate, Critique, Compare) via existing discussion session
+ *
+ * Both action types use the existing discussion session (same as Think tab) so that:
+ * - Quick Actions appear in the conversation history with tool usage
+ * - Advisory Actions appear as regular conversation turns
+ * - Full session context is maintained for coherent assistance
+ *
+ * Note: pair_chat_request has been removed - users can type directly in Discussion.
+ *
+ * See: .sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md (TD-2)
+ */
+
+import { join } from "node:path";
+import type { Options, SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  QuickActionRequestMessage,
+  AdvisoryActionRequestMessage,
+} from "@memory-loop/shared";
+import { createLogger } from "../logger.js";
+import { validatePath } from "../file-browser.js";
+import {
+  resumeSession as defaultResumeSession,
+  appendMessage as defaultAppendMessage,
+} from "../session-manager.js";
+import {
+  buildQuickActionPrompt,
+  buildAdvisoryActionPrompt,
+  isQuickActionType,
+  isAdvisoryActionType,
+  type QuickActionContext,
+  type AdvisoryActionContext,
+} from "../pair-writing-prompts.js";
+import { type HandlerContext, requireVault, generateMessageId } from "./types.js";
+
+const log = createLogger("PairWriting");
+
+/**
+ * Dependencies for pair writing handlers (injectable for testing).
+ */
+export interface PairWritingDependencies {
+  resumeSession?: typeof defaultResumeSession;
+  appendMessage?: typeof defaultAppendMessage;
+}
+
+/**
+ * SDK options for Quick Action sessions (when no existing session).
+ *
+ * Quick Actions are task-scoped: Claude reads the file, makes an edit, confirms.
+ * - Read and Edit tools available (scoped to vault via cwd)
+ * - acceptEdits: Allow file modifications without user prompts
+ * - maxTurns: Limit to prevent runaway sessions (typical flow is 3-5 turns)
+ * - Budget capped at $0.50 for single edits
+ */
+const QUICK_ACTION_OPTIONS: Partial<Options> = {
+  allowedTools: ["Read", "Edit"],
+  permissionMode: "acceptEdits",
+  maxTurns: 10,
+  maxBudgetUsd: 0.5,
+  includePartialMessages: true,
+};
+
+/**
+ * Formats a Quick Action as a user-visible message.
+ * This appears in the Discussion conversation.
+ */
+function formatQuickActionUserMessage(
+  action: string,
+  selection: string
+): string {
+  const actionDisplay = action.charAt(0).toUpperCase() + action.slice(1);
+  const truncatedSelection = selection.length > 100
+    ? selection.slice(0, 100) + "..."
+    : selection;
+  return `[${actionDisplay}] "${truncatedSelection}"`;
+}
+
+/**
+ * Formats an Advisory Action as a user-visible message.
+ * This appears in the Discussion conversation.
+ */
+function formatAdvisoryActionUserMessage(
+  action: string,
+  selection: string
+): string {
+  const actionDisplay = action.charAt(0).toUpperCase() + action.slice(1);
+  const truncatedSelection = selection.length > 100
+    ? selection.slice(0, 100) + "..."
+    : selection;
+  return `[${actionDisplay}] "${truncatedSelection}"`;
+}
+
+/**
+ * Handles a Quick Action request (Tighten, Embellish, Correct, Polish).
+ *
+ * Flow:
+ * 1. Validates file path is within vault
+ * 2. Builds the prompt using action-specific template
+ * 3. If existing session: resumes it; otherwise creates task-scoped session
+ * 4. Streams all events to frontend (tool_start, tool_end, response_chunk, response_end)
+ * 5. Appends user message and response to session history
+ *
+ * When an existing discussion session is available, Quick Actions use it to maintain
+ * full context. The Edit tool usage appears in the conversation history.
+ *
+ * @param ctx - Handler context with connection state and send functions
+ * @param request - Quick action request message
+ * @param deps - Optional dependencies for testing
+ */
+export async function handleQuickAction(
+  ctx: HandlerContext,
+  request: QuickActionRequestMessage,
+  deps: PairWritingDependencies = {}
+): Promise<void> {
+  // Require vault to be selected
+  if (!requireVault(ctx)) {
+    return;
+  }
+
+  const vault = ctx.state.currentVault;
+  let sessionId = ctx.state.currentSessionId;
+  const resumeSession = deps.resumeSession ?? defaultResumeSession;
+  const appendMessage = deps.appendMessage ?? defaultAppendMessage;
+
+  log.info(`Quick action "${request.action}" on ${request.filePath}`);
+  if (sessionId) {
+    log.info(`Using existing session: ${sessionId.slice(0, 8)}...`);
+  } else {
+    log.info("No existing session, will create persistent session");
+  }
+
+  // Validate action type (fast, no I/O)
+  if (!isQuickActionType(request.action)) {
+    ctx.sendError("VALIDATION_ERROR", `Invalid action type: ${String(request.action)}`);
+    return;
+  }
+
+  // Validate selection (fast, no I/O)
+  if (!request.selection || request.selection.length === 0) {
+    ctx.sendError("VALIDATION_ERROR", "Selection is required");
+    return;
+  }
+
+  // Validate file path is within vault content root (requires filesystem)
+  try {
+    const absolutePath = join(vault.contentRoot, request.filePath);
+    await validatePath(vault.contentRoot, request.filePath);
+    log.debug(`Validated path: ${absolutePath}`);
+  } catch (error) {
+    log.warn(`Path validation failed: ${request.filePath}`, error);
+    ctx.sendError(
+      "PATH_TRAVERSAL",
+      `File path "${request.filePath}" is not within vault`
+    );
+    return;
+  }
+
+  // Build the prompt context
+  const promptContext: QuickActionContext = {
+    filePath: request.filePath,
+    selectedText: request.selection,
+    contextBefore: request.contextBefore,
+    contextAfter: request.contextAfter,
+    startLine: request.selectionStartLine,
+    endLine: request.selectionEndLine,
+    totalLines: request.totalLines,
+  };
+
+  // Build the action-specific prompt
+  const prompt = buildQuickActionPrompt(request.action, promptContext);
+  log.debug(`Built prompt (${prompt.length} chars)`);
+
+  // Generate message ID for streaming
+  const messageId = generateMessageId();
+  const startTime = Date.now();
+  const userMessage = formatQuickActionUserMessage(request.action, request.selection);
+
+  // Send response_start
+  ctx.send({ type: "response_start", messageId });
+
+  try {
+    let queryResult: AsyncGenerator<SDKMessage, void>;
+
+    if (sessionId) {
+      // Resume existing discussion session with Edit tool enabled
+      log.info("Resuming existing session for Quick Action...");
+      const sessionResult = await resumeSession(
+        vault.path,
+        sessionId,
+        prompt,
+        {
+          ...QUICK_ACTION_OPTIONS,
+          cwd: vault.contentRoot,
+          settingSources: ["local", "project", "user"],
+        }
+      );
+      queryResult = sessionResult.events;
+    } else {
+      // Create persistent session (will show in Recent Sessions)
+      log.info("Creating persistent Quick Action session...");
+      const sessionResult = await ctx.deps.createSession(vault, prompt);
+      sessionId = sessionResult.sessionId;
+      ctx.state.currentSessionId = sessionId;
+      queryResult = sessionResult.events;
+
+      // Notify frontend of new session
+      ctx.send({
+        type: "session_ready",
+        sessionId,
+        vaultId: vault.id,
+        createdAt: new Date().toISOString(),
+      });
+      log.info(`Created new session: ${sessionId.slice(0, 8)}...`);
+    }
+
+    // Add user message to session history (so it appears in Discussion)
+    try {
+      await appendMessage(vault.path, sessionId, {
+        id: generateMessageId(),
+        role: "user",
+        content: userMessage,
+        timestamp: new Date().toISOString(),
+      });
+    } catch (error) {
+      log.warn("Failed to append user message to session", error);
+    }
+
+    // Stream events to frontend
+    const streamResult = await streamQuickActionEvents(ctx, messageId, queryResult);
+
+    const durationMs = Date.now() - startTime;
+    log.info(`Quick action completed in ${durationMs}ms`);
+
+    // Append assistant message to session history
+    if (streamResult.content.length > 0) {
+      try {
+        await appendMessage(vault.path, sessionId, {
+          id: messageId,
+          role: "assistant",
+          content: streamResult.content,
+          timestamp: new Date().toISOString(),
+          toolInvocations: streamResult.toolInvocations.length > 0 ? streamResult.toolInvocations : undefined,
+          contextUsage: streamResult.contextUsage,
+          durationMs,
+        });
+      } catch (error) {
+        log.warn("Failed to append assistant message to session", error);
+      }
+    }
+
+    // Send response_end
+    ctx.send({
+      type: "response_end",
+      messageId,
+      durationMs,
+      contextUsage: streamResult.contextUsage,
+    });
+  } catch (error) {
+    log.error("Quick action failed", error);
+    const message = error instanceof Error ? error.message : "Quick action failed";
+    ctx.sendError("SDK_ERROR", message);
+  }
+}
+
+/**
+ * Result from streaming Quick Action events.
+ */
+interface StreamingResult {
+  content: string;
+  toolInvocations: Array<{
+    toolUseId: string;
+    toolName: string;
+    status: "running" | "complete";
+    input?: unknown;
+    output?: unknown;
+  }>;
+  contextUsage?: number;
+}
+
+/**
+ * Streams SDK events for a Quick Action to the frontend.
+ *
+ * Maps SDK events to WebSocket protocol messages:
+ * - content_block_start (tool_use) -> tool_start
+ * - content_block_stop (tool_use) -> tool_end
+ * - text_delta -> response_chunk
+ *
+ * @param ctx - Handler context
+ * @param messageId - Unique message ID for this response
+ * @param queryResult - The SDK query generator
+ * @returns Accumulated content, tool invocations, and context usage
+ */
+async function streamQuickActionEvents(
+  ctx: HandlerContext,
+  messageId: string,
+  queryResult: AsyncGenerator<SDKMessage, void>
+): Promise<StreamingResult> {
+  const responseChunks: string[] = [];
+  const toolsMap = new Map<string, { name: string; inputChunks: string[]; input?: unknown; output?: unknown }>();
+  const contentBlocks = new Map<number, { type: string; toolUseId?: string; toolName?: string; inputChunks?: string[] }>();
+  let contextUsage: number | undefined;
+
+  for await (const event of queryResult) {
+    log.debug(`SDK event: ${event.type}`);
+
+    switch (event.type) {
+      case "stream_event": {
+        const streamEvent = event.event;
+
+        // Handle content block start (text or tool_use)
+        if (streamEvent.type === "content_block_start") {
+          const { index, content_block: contentBlock } = streamEvent;
+
+          if (contentBlock.type === "tool_use") {
+            const { id: toolUseId, name: toolName } = contentBlock;
+            log.info(`Tool started: ${toolName} (${toolUseId})`);
+
+            contentBlocks.set(index, {
+              type: "tool_use",
+              toolUseId,
+              toolName,
+              inputChunks: [],
+            });
+
+            toolsMap.set(toolUseId, { name: toolName, inputChunks: [] });
+
+            ctx.send({
+              type: "tool_start",
+              toolName,
+              toolUseId,
+            });
+          } else if (contentBlock.type === "text") {
+            contentBlocks.set(index, { type: "text" });
+          }
+        }
+
+        // Handle content block delta (text or tool input)
+        if (streamEvent.type === "content_block_delta") {
+          const { index, delta } = streamEvent;
+
+          if (delta.type === "text_delta") {
+            const { text } = delta;
+            ctx.send({
+              type: "response_chunk",
+              messageId,
+              content: text,
+            });
+            responseChunks.push(text);
+          }
+
+          if (delta.type === "input_json_delta") {
+            const { partial_json: partialJson } = delta;
+            const block = contentBlocks.get(index);
+            if (partialJson && block?.type === "tool_use" && block.inputChunks) {
+              block.inputChunks.push(partialJson);
+            }
+          }
+        }
+
+        // Handle content block stop
+        if (streamEvent.type === "content_block_stop") {
+          const { index } = streamEvent;
+          const block = contentBlocks.get(index);
+
+          if (block?.type === "tool_use" && block.toolUseId && block.inputChunks) {
+            const jsonStr = block.inputChunks.join("");
+            try {
+              const input: unknown = jsonStr ? JSON.parse(jsonStr) : {};
+              ctx.send({
+                type: "tool_input",
+                toolUseId: block.toolUseId,
+                input,
+              });
+              // Store input for session history
+              const tool = toolsMap.get(block.toolUseId);
+              if (tool) {
+                tool.input = input;
+              }
+            } catch {
+              log.warn(`Failed to parse tool input JSON for ${block.toolUseId}`);
+            }
+          }
+
+          contentBlocks.delete(index);
+        }
+        break;
+      }
+
+      case "result": {
+        // Extract tool results and context usage
+        const { usage, modelUsage } = event;
+
+        if (usage && modelUsage) {
+          const inputTokens = usage.input_tokens ?? 0;
+          const outputTokens = usage.output_tokens ?? 0;
+          const totalTokens = inputTokens + outputTokens;
+
+          const modelNames = Object.keys(modelUsage);
+          const modelName = modelNames[0];
+          if (modelName && modelUsage[modelName]) {
+            const contextWindow = modelUsage[modelName].contextWindow;
+            if (contextWindow && contextWindow > 0) {
+              contextUsage = Math.round((100 * totalTokens) / contextWindow);
+              contextUsage = Math.max(0, Math.min(100, contextUsage));
+            }
+          }
+        }
+
+        // Extract tool results from result content
+        const rawEvent = event as unknown as { result?: { content?: unknown[] } };
+        const result = rawEvent.result;
+        if (result && Array.isArray(result.content)) {
+          for (const block of result.content) {
+            if (typeof block !== "object" || block === null || !("type" in block)) continue;
+            const typedBlock = block as { type: string; tool_use_id?: string; content?: unknown };
+
+            if (typedBlock.type === "tool_result" && typedBlock.tool_use_id) {
+              log.info(`Tool completed: ${typedBlock.tool_use_id}`);
+              ctx.send({
+                type: "tool_end",
+                toolUseId: typedBlock.tool_use_id,
+                output: typedBlock.content ?? null,
+              });
+              // Store output for session history
+              const tool = toolsMap.get(typedBlock.tool_use_id);
+              if (tool) {
+                tool.output = typedBlock.content ?? null;
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case "user": {
+        // Handle tool results from user events
+        const { message } = event;
+        const content = message.content;
+        if (!Array.isArray(content)) break;
+
+        for (const block of content) {
+          if (typeof block !== "object" || block === null || !("type" in block)) continue;
+
+          if (block.type === "tool_result" && "tool_use_id" in block) {
+            const toolUseId = block.tool_use_id;
+            const output = "content" in block ? block.content : null;
+
+            log.info(`Tool completed (from user event): ${toolUseId}`);
+            ctx.send({
+              type: "tool_end",
+              toolUseId,
+              output: output ?? null,
+            });
+            // Store output for session history
+            const tool = toolsMap.get(toolUseId);
+            if (tool) {
+              tool.output = output ?? null;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  // Convert toolsMap to array for storage
+  const toolInvocations = Array.from(toolsMap.entries()).map(([toolUseId, tool]) => ({
+    toolUseId,
+    toolName: tool.name,
+    status: "complete" as const,
+    input: tool.input,
+    output: tool.output,
+  }));
+
+  return {
+    content: responseChunks.join(""),
+    toolInvocations,
+    contextUsage,
+  };
+}
+
+// =============================================================================
+// Advisory Action Handler (Validate, Critique, Compare)
+// =============================================================================
+
+/**
+ * SDK options for Advisory Action sessions (when no existing session).
+ *
+ * Advisory Actions are read-only: Claude analyzes text and provides feedback.
+ * - No tools needed (pure text analysis)
+ * - maxTurns: 1 (single response expected)
+ * - Budget capped at $0.25 for advisory feedback
+ */
+const ADVISORY_ACTION_OPTIONS: Partial<Options> = {
+  allowedTools: [],
+  maxTurns: 1,
+  maxBudgetUsd: 0.25,
+  includePartialMessages: true,
+};
+
+/**
+ * Handles an Advisory Action request (Validate, Critique, Compare).
+ *
+ * Advisory actions stream text responses to the Discussion conversation.
+ * When an existing session is available, uses resumeSession to maintain context.
+ * The user reads the feedback and manually applies changes.
+ *
+ * @param ctx - Handler context with connection state and send functions
+ * @param request - Advisory action request message
+ * @param deps - Optional dependencies for testing
+ */
+export async function handleAdvisoryAction(
+  ctx: HandlerContext,
+  request: AdvisoryActionRequestMessage,
+  deps: PairWritingDependencies = {}
+): Promise<void> {
+  // Require vault to be selected
+  if (!requireVault(ctx)) {
+    return;
+  }
+
+  const vault = ctx.state.currentVault;
+  let sessionId = ctx.state.currentSessionId;
+  const resumeSession = deps.resumeSession ?? defaultResumeSession;
+  const appendMessage = deps.appendMessage ?? defaultAppendMessage;
+
+  log.info(`Advisory action "${request.action}" on ${request.filePath}`);
+  if (sessionId) {
+    log.info(`Using existing session: ${sessionId.slice(0, 8)}...`);
+  } else {
+    log.info("No existing session, will create persistent session");
+  }
+
+  // Validate action type
+  if (!isAdvisoryActionType(request.action)) {
+    ctx.sendError("VALIDATION_ERROR", `Invalid advisory action type: ${String(request.action)}`);
+    return;
+  }
+
+  // Validate selection
+  if (!request.selection || request.selection.length === 0) {
+    ctx.sendError("VALIDATION_ERROR", "Selection is required");
+    return;
+  }
+
+  // Validate file path is within vault
+  try {
+    await validatePath(vault.contentRoot, request.filePath);
+  } catch (error) {
+    log.warn(`Path validation failed: ${request.filePath}`, error);
+    ctx.sendError("PATH_TRAVERSAL", `File path "${request.filePath}" is not within vault`);
+    return;
+  }
+
+  // Build the prompt context
+  const promptContext: AdvisoryActionContext = {
+    filePath: request.filePath,
+    selectedText: request.selection,
+    contextBefore: request.contextBefore,
+    contextAfter: request.contextAfter,
+    startLine: request.selectionStartLine,
+    endLine: request.selectionEndLine,
+    totalLines: request.totalLines,
+    snapshotSelection: request.snapshotSelection,
+  };
+
+  // Build the action-specific prompt
+  const prompt = buildAdvisoryActionPrompt(request.action, promptContext);
+  log.debug(`Built advisory prompt (${prompt.length} chars)`);
+
+  // Generate message ID and stream response
+  const messageId = generateMessageId();
+  const startTime = Date.now();
+  const userMessage = formatAdvisoryActionUserMessage(request.action, request.selection);
+
+  ctx.send({ type: "response_start", messageId });
+
+  try {
+    let queryResult: AsyncGenerator<SDKMessage, void>;
+
+    if (sessionId) {
+      // Resume existing discussion session
+      log.info("Resuming existing session for Advisory Action...");
+      const sessionResult = await resumeSession(
+        vault.path,
+        sessionId,
+        prompt,
+        {
+          ...ADVISORY_ACTION_OPTIONS,
+          cwd: vault.contentRoot,
+          settingSources: ["local", "project", "user"],
+        }
+      );
+      queryResult = sessionResult.events;
+    } else {
+      // Create persistent session (will show in Recent Sessions)
+      log.info("Creating persistent Advisory Action session...");
+      const sessionResult = await ctx.deps.createSession(vault, prompt);
+      sessionId = sessionResult.sessionId;
+      ctx.state.currentSessionId = sessionId;
+      queryResult = sessionResult.events;
+
+      // Notify frontend of new session
+      ctx.send({
+        type: "session_ready",
+        sessionId,
+        vaultId: vault.id,
+        createdAt: new Date().toISOString(),
+      });
+      log.info(`Created new session: ${sessionId.slice(0, 8)}...`);
+    }
+
+    // Add user message to session history (so it appears in Discussion)
+    try {
+      await appendMessage(vault.path, sessionId, {
+        id: generateMessageId(),
+        role: "user",
+        content: userMessage,
+        timestamp: new Date().toISOString(),
+      });
+    } catch (error) {
+      log.warn("Failed to append user message to session", error);
+    }
+
+    // Stream events (advisory actions are text-only, no tools)
+    const streamResult = await streamAdvisoryActionEvents(ctx, messageId, queryResult);
+
+    const durationMs = Date.now() - startTime;
+    log.info(`Advisory action completed in ${durationMs}ms`);
+
+    // Append assistant message to session history
+    if (streamResult.content.length > 0) {
+      try {
+        await appendMessage(vault.path, sessionId, {
+          id: messageId,
+          role: "assistant",
+          content: streamResult.content,
+          timestamp: new Date().toISOString(),
+          contextUsage: streamResult.contextUsage,
+          durationMs,
+        });
+      } catch (error) {
+        log.warn("Failed to append assistant message to session", error);
+      }
+    }
+
+    ctx.send({
+      type: "response_end",
+      messageId,
+      durationMs,
+      contextUsage: streamResult.contextUsage,
+    });
+  } catch (error) {
+    log.error("Advisory action failed", error);
+    const message = error instanceof Error ? error.message : "Advisory action failed";
+    ctx.sendError("SDK_ERROR", message);
+  }
+}
+
+/**
+ * Result from streaming Advisory Action events.
+ */
+interface AdvisoryStreamingResult {
+  content: string;
+  contextUsage?: number;
+}
+
+/**
+ * Streams SDK events for an Advisory Action to the frontend.
+ *
+ * Advisory actions are text-only (no tools), so this is simpler than Quick Actions.
+ *
+ * @param ctx - Handler context
+ * @param messageId - Unique message ID for this response
+ * @param queryResult - The SDK query generator
+ * @returns Accumulated content and context usage
+ */
+async function streamAdvisoryActionEvents(
+  ctx: HandlerContext,
+  messageId: string,
+  queryResult: AsyncGenerator<SDKMessage, void>
+): Promise<AdvisoryStreamingResult> {
+  const responseChunks: string[] = [];
+  let contextUsage: number | undefined;
+
+  for await (const event of queryResult) {
+    log.debug(`SDK event: ${event.type}`);
+
+    switch (event.type) {
+      case "stream_event": {
+        const streamEvent = event.event;
+
+        // Handle text deltas
+        if (streamEvent.type === "content_block_delta") {
+          const { delta } = streamEvent;
+
+          if (delta.type === "text_delta") {
+            const { text } = delta;
+            ctx.send({
+              type: "response_chunk",
+              messageId,
+              content: text,
+            });
+            responseChunks.push(text);
+          }
+        }
+        break;
+      }
+
+      case "result": {
+        // Extract context usage
+        const { usage, modelUsage } = event;
+
+        if (usage && modelUsage) {
+          const inputTokens = usage.input_tokens ?? 0;
+          const outputTokens = usage.output_tokens ?? 0;
+          const totalTokens = inputTokens + outputTokens;
+
+          const modelNames = Object.keys(modelUsage);
+          const modelName = modelNames[0];
+          if (modelName && modelUsage[modelName]) {
+            const contextWindow = modelUsage[modelName].contextWindow;
+            if (contextWindow && contextWindow > 0) {
+              contextUsage = Math.round((100 * totalTokens) / contextWindow);
+              contextUsage = Math.max(0, Math.min(100, contextUsage));
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  return {
+    content: responseChunks.join(""),
+    contextUsage,
+  };
+}
diff --git a/backend/src/handlers/types.ts b/backend/src/handlers/types.ts
index 6fc13fe7..42c2b978 100644
--- a/backend/src/handlers/types.ts
+++ b/backend/src/handlers/types.ts
@@ -12,6 +12,7 @@ import type {
   RecentNoteEntry,
   RecentDiscussionEntry,
   TaskEntry,
+  ConversationMessage,
 } from "@memory-loop/shared";
 import type { SessionQueryResult } from "../session-manager.js";
 import type { SearchIndexManager } from "../search/search-index.js";
@@ -129,6 +130,20 @@ export interface HandlerDependencies {
     vaultPath: string,
     limit?: number
   ) => Promise<RecentDiscussionEntry[]>;
+  createSession?: (
+    vault: VaultInfo,
+    prompt: string
+  ) => Promise<SessionQueryResult>;
+  resumeSession?: (
+    vaultPath: string,
+    sessionId: string,
+    prompt: string
+  ) => Promise<SessionQueryResult>;
+  appendMessage?: (
+    vaultPath: string,
+    sessionId: string,
+    message: ConversationMessage
+  ) => Promise<void>;
 
   // Vault config
   loadVaultConfig?: (vaultPath: string) => Promise<VaultConfig>;
@@ -238,6 +253,20 @@ export interface RequiredHandlerDependencies {
     vaultPath: string,
     limit?: number
   ) => Promise<RecentDiscussionEntry[]>;
+  createSession: (
+    vault: VaultInfo,
+    prompt: string
+  ) => Promise<SessionQueryResult>;
+  resumeSession: (
+    vaultPath: string,
+    sessionId: string,
+    prompt: string
+  ) => Promise<SessionQueryResult>;
+  appendMessage: (
+    vaultPath: string,
+    sessionId: string,
+    message: ConversationMessage
+  ) => Promise<void>;
   loadVaultConfig: (vaultPath: string) => Promise<VaultConfig>;
 }
 
diff --git a/backend/src/pair-writing-prompts.ts b/backend/src/pair-writing-prompts.ts
new file mode 100644
index 00000000..ae8163a5
--- /dev/null
+++ b/backend/src/pair-writing-prompts.ts
@@ -0,0 +1,474 @@
+/**
+ * Pair Writing Prompt Templates
+ *
+ * Action-specific system prompts for:
+ * - Quick Actions (Tighten, Embellish, Correct, Polish): Use Claude's Read/Edit tools
+ * - Advisory Actions (Validate, Critique, Compare): Stream text feedback only
+ * - Pair Chat: Freeform chat with optional selection context
+ *
+ * See: .sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md (TD-3)
+ */
+
+/**
+ * Quick action types supported by the system.
+ */
+export type QuickActionType = "tighten" | "embellish" | "correct" | "polish";
+
+/**
+ * Advisory action types supported by the system.
+ */
+export type AdvisoryActionType = "validate" | "critique" | "compare";
+
+/**
+ * Context required to build a Quick Action prompt.
+ */
+export interface QuickActionContext {
+  /** Absolute or relative file path being edited */
+  filePath: string;
+  /** The selected text to revise */
+  selectedText: string;
+  /** One paragraph before the selection (for tone matching) */
+  contextBefore: string;
+  /** One paragraph after the selection (for tone matching) */
+  contextAfter: string;
+  /** 1-indexed line number where selection starts */
+  startLine: number;
+  /** 1-indexed line number where selection ends */
+  endLine: number;
+  /** Total lines in the document */
+  totalLines: number;
+}
+
+/**
+ * Position hint indicating where the selection is located in the document.
+ */
+export type PositionHint = "beginning" | "middle" | "end";
+
+/**
+ * Configuration for a single Quick Action type.
+ */
+interface ActionConfig {
+  /** Human-readable action name */
+  name: string;
+  /** Task description for the prompt */
+  taskDescription: string;
+  /** Rules specific to this action */
+  rules: string[];
+}
+
+/**
+ * Action configurations for all Quick Action types.
+ */
+const ACTION_CONFIGS: Record<QuickActionType, ActionConfig> = {
+  tighten: {
+    name: "Tighten",
+    taskDescription: "Tighten the selected text",
+    rules: [
+      "Preserve the core meaning",
+      "Remove filler words, redundant phrases, unnecessary qualifiers",
+      "Maintain the author's voice and the document's tone",
+    ],
+  },
+  embellish: {
+    name: "Embellish",
+    taskDescription: "Embellish the selected text",
+    rules: [
+      "Add vivid details, examples, or explanatory content",
+      "Enhance clarity and engagement without changing the core meaning",
+      "Match the existing style and tone of the document",
+      "Avoid purple prose or excessive ornamentation",
+    ],
+  },
+  correct: {
+    name: "Correct",
+    taskDescription: "Correct errors in the selected text",
+    rules: [
+      "Fix spelling, grammar, and punctuation errors",
+      "Correct word usage and syntax issues",
+      "Do not change the meaning, style, or voice",
+      "Only fix clear errors; do not edit for style preferences",
+    ],
+  },
+  polish: {
+    name: "Polish",
+    taskDescription: "Polish the selected text",
+    rules: [
+      "Improve sentence flow and readability",
+      "Smooth awkward phrasing while preserving meaning",
+      "Enhance word choices where clarity improves",
+      "Maintain the author's voice and the document's tone",
+    ],
+  },
+};
+
+/**
+ * Calculates a position hint based on where the selection is in the document.
+ *
+ * Position thresholds:
+ * - Beginning: lines 1-20% of document
+ * - Middle: lines 20-80% of document
+ * - End: lines 80-100% of document
+ *
+ * @param startLine - 1-indexed line number where selection starts
+ * @param endLine - 1-indexed line number where selection ends
+ * @param totalLines - Total lines in the document
+ * @returns Position hint string
+ */
+export function calculatePositionHint(
+  startLine: number,
+  endLine: number,
+  totalLines: number
+): PositionHint {
+  // Use the midpoint of the selection for position calculation
+  const midpoint = (startLine + endLine) / 2;
+
+  // Handle edge cases
+  if (totalLines <= 0) {
+    return "middle";
+  }
+
+  // Calculate position as percentage of document
+  const positionPercent = (midpoint / totalLines) * 100;
+
+  if (positionPercent <= 20) {
+    return "beginning";
+  } else if (positionPercent >= 80) {
+    return "end";
+  } else {
+    return "middle";
+  }
+}
+
+/**
+ * Formats the position hint as a human-readable phrase.
+ *
+ * @param hint - Position hint
+ * @returns Human-readable position phrase
+ */
+export function formatPositionHint(hint: PositionHint): string {
+  switch (hint) {
+    case "beginning":
+      return "near the beginning of";
+    case "middle":
+      return "in the middle of";
+    case "end":
+      return "near the end of";
+  }
+}
+
+/**
+ * Builds the system prompt for a Quick Action.
+ *
+ * The prompt structure follows TD-3 from the plan:
+ * - Efficiency guidance ("be efficient", "keep responses brief")
+ * - Task description with file path and line numbers
+ * - Action-specific rules
+ * - Selected text and surrounding context
+ * - Workflow instructions (Read -> Edit -> Confirm)
+ *
+ * @param action - The Quick Action type
+ * @param context - The context for the action (file, selection, etc.)
+ * @returns Complete system prompt for Claude
+ */
+export function buildQuickActionPrompt(
+  action: QuickActionType,
+  context: QuickActionContext
+): string {
+  const config = ACTION_CONFIGS[action];
+  const positionHint = calculatePositionHint(
+    context.startLine,
+    context.endLine,
+    context.totalLines
+  );
+  const positionPhrase = formatPositionHint(positionHint);
+
+  // Format rules as bullet points
+  const formattedRules = config.rules.map((rule) => `- ${rule}`).join("\n");
+
+  return `You are a writing assistant performing a Quick Action. Be efficient: read the file, make the edit, confirm briefly.
+
+Task: ${config.taskDescription} ${positionPhrase} "${context.filePath}" (lines ${context.startLine}-${context.endLine}).
+
+Rules for "${config.name}":
+${formattedRules}
+
+Selected text to revise:
+${context.selectedText}
+
+Surrounding context (for tone matching - do not modify this):
+${context.contextBefore}
+[SELECTION TO EDIT]
+${context.contextAfter}
+
+Workflow:
+1. Read the file to see current state
+2. Use Edit tool to replace the selection with ${action === "tighten" ? "tightened" : action === "embellish" ? "embellished" : action === "correct" ? "corrected" : "polished"} version
+3. Confirm with one sentence (e.g., "Removed 3 filler phrases." or "Fixed 2 grammar errors.")
+
+Keep responses brief. No lengthy explanations.`;
+}
+
+/**
+ * Validates that a Quick Action context has required fields.
+ *
+ * @param context - The context to validate
+ * @returns True if valid, throws error if invalid
+ */
+export function validateQuickActionContext(
+  context: QuickActionContext
+): boolean {
+  if (!context.filePath) {
+    throw new Error("filePath is required");
+  }
+  if (!context.selectedText) {
+    throw new Error("selectedText is required");
+  }
+  if (context.startLine < 1) {
+    throw new Error("startLine must be >= 1");
+  }
+  if (context.endLine < context.startLine) {
+    throw new Error("endLine must be >= startLine");
+  }
+  if (context.totalLines < 1) {
+    throw new Error("totalLines must be >= 1");
+  }
+  return true;
+}
+
+/**
+ * Returns the action configuration for a given action type.
+ * Useful for getting action metadata without building a full prompt.
+ *
+ * @param action - The Quick Action type
+ * @returns Action configuration
+ */
+export function getActionConfig(action: QuickActionType): ActionConfig {
+  return ACTION_CONFIGS[action];
+}
+
+/**
+ * Checks if a string is a valid Quick Action type.
+ *
+ * @param action - String to check
+ * @returns True if valid action type
+ */
+export function isQuickActionType(action: string): action is QuickActionType {
+  return ["tighten", "embellish", "correct", "polish"].includes(action);
+}
+
+/**
+ * Checks if a string is a valid Advisory Action type.
+ *
+ * @param action - String to check
+ * @returns True if valid advisory action type
+ */
+export function isAdvisoryActionType(action: string): action is AdvisoryActionType {
+  return ["validate", "critique", "compare"].includes(action);
+}
+
+// =============================================================================
+// Advisory Action Prompts (Pair Writing Mode)
+// =============================================================================
+
+/**
+ * Context required to build an Advisory Action prompt.
+ */
+export interface AdvisoryActionContext {
+  /** Absolute or relative file path being edited */
+  filePath: string;
+  /** The selected text to analyze */
+  selectedText: string;
+  /** One paragraph before the selection (for context) */
+  contextBefore: string;
+  /** One paragraph after the selection (for context) */
+  contextAfter: string;
+  /** 1-indexed line number where selection starts */
+  startLine: number;
+  /** 1-indexed line number where selection ends */
+  endLine: number;
+  /** Total lines in the document */
+  totalLines: number;
+  /** For compare action: the corresponding text from the snapshot */
+  snapshotSelection?: string;
+}
+
+/**
+ * Configuration for Advisory Action types.
+ */
+interface AdvisoryActionConfig {
+  /** Human-readable action name */
+  name: string;
+  /** Task description for the prompt */
+  taskDescription: string;
+  /** Detailed instructions for this action */
+  instructions: string[];
+}
+
+/**
+ * Advisory action configurations.
+ */
+const ADVISORY_ACTION_CONFIGS: Record<AdvisoryActionType, AdvisoryActionConfig> = {
+  validate: {
+    name: "Validate",
+    taskDescription: "Fact-check the selected text",
+    instructions: [
+      "Identify any factual claims in the selection",
+      "Assess the accuracy of each claim based on your knowledge",
+      "Note claims you cannot verify (requires specialized knowledge, recent events, etc.)",
+      "Be specific about what is correct, questionable, or incorrect",
+      "Suggest corrections for any inaccuracies found",
+    ],
+  },
+  critique: {
+    name: "Critique",
+    taskDescription: "Analyze the clarity, voice, and structure of the selected text",
+    instructions: [
+      "Evaluate clarity: Is the meaning immediately apparent?",
+      "Assess voice: Is the tone consistent with the surrounding context?",
+      "Check structure: Does the text flow logically?",
+      "Identify specific weaknesses with concrete examples",
+      "Suggest improvements without rewriting the text entirely",
+      "Be constructive, not just critical",
+    ],
+  },
+  compare: {
+    name: "Compare",
+    taskDescription: "Analyze how the text has changed from the snapshot",
+    instructions: [
+      "Describe what changed objectively (additions, deletions, rewording)",
+      "Explain how the meaning or emphasis shifted (if at all)",
+      "Note whether the changes improved, degraded, or maintained quality",
+      "Be descriptive rather than judgmental",
+    ],
+  },
+};
+
+/**
+ * Builds the prompt for a Validate action.
+ *
+ * @param context - The context for the action
+ * @returns Complete prompt for Claude
+ */
+export function buildValidatePrompt(context: AdvisoryActionContext): string {
+  const config = ADVISORY_ACTION_CONFIGS.validate;
+  const positionHint = calculatePositionHint(
+    context.startLine,
+    context.endLine,
+    context.totalLines
+  );
+  const positionPhrase = formatPositionHint(positionHint);
+  const formattedInstructions = config.instructions.map((i) => `- ${i}`).join("\n");
+
+  return `You are a writing assistant helping fact-check content.
+
+Task: ${config.taskDescription} ${positionPhrase} "${context.filePath}".
+
+Instructions:
+${formattedInstructions}
+
+Selected text to validate:
+${context.selectedText}
+
+Surrounding context (for reference):
+${context.contextBefore}
+[SELECTED TEXT]
+${context.contextAfter}
+
+Provide your analysis in a clear, organized format. Be specific and actionable.`;
+}
+
+/**
+ * Builds the prompt for a Critique action.
+ *
+ * @param context - The context for the action
+ * @returns Complete prompt for Claude
+ */
+export function buildCritiquePrompt(context: AdvisoryActionContext): string {
+  const config = ADVISORY_ACTION_CONFIGS.critique;
+  const positionHint = calculatePositionHint(
+    context.startLine,
+    context.endLine,
+    context.totalLines
+  );
+  const positionPhrase = formatPositionHint(positionHint);
+  const formattedInstructions = config.instructions.map((i) => `- ${i}`).join("\n");
+
+  return `You are a writing assistant providing editorial feedback.
+
+Task: ${config.taskDescription} ${positionPhrase} "${context.filePath}".
+
+Instructions:
+${formattedInstructions}
+
+Selected text to critique:
+${context.selectedText}
+
+Surrounding context (for tone/style reference):
+${context.contextBefore}
+[SELECTED TEXT]
+${context.contextAfter}
+
+Provide your analysis in a clear, organized format. Focus on specific, actionable feedback.`;
+}
+
+/**
+ * Builds the prompt for a Compare action.
+ *
+ * @param context - The context for the action (must include snapshotSelection)
+ * @returns Complete prompt for Claude
+ */
+export function buildComparePrompt(context: AdvisoryActionContext): string {
+  const config = ADVISORY_ACTION_CONFIGS.compare;
+  const formattedInstructions = config.instructions.map((i) => `- ${i}`).join("\n");
+
+  // Handle case where no snapshot selection was provided
+  if (!context.snapshotSelection) {
+    return `You are a writing assistant helping track document changes.
+
+The user selected text to compare to a snapshot, but no corresponding text was found in the snapshot. This usually means the selection is new content that was added after the snapshot was taken.
+
+Current selection (new content):
+${context.selectedText}
+
+Respond briefly noting that this appears to be new content not present in the snapshot.`;
+  }
+
+  return `You are a writing assistant helping track document changes.
+
+Task: ${config.taskDescription}
+
+Instructions:
+${formattedInstructions}
+
+BEFORE (from snapshot):
+${context.snapshotSelection}
+
+AFTER (current):
+${context.selectedText}
+
+Provide a clear analysis of:
+1. What changed (specific additions, deletions, rewording)
+2. How the meaning or emphasis shifted
+3. Overall assessment of the changes`;
+}
+
+/**
+ * Builds the appropriate advisory action prompt based on action type.
+ *
+ * @param action - The advisory action type
+ * @param context - The context for the action
+ * @returns Complete prompt for Claude
+ */
+export function buildAdvisoryActionPrompt(
+  action: AdvisoryActionType,
+  context: AdvisoryActionContext
+): string {
+  switch (action) {
+    case "validate":
+      return buildValidatePrompt(context);
+    case "critique":
+      return buildCritiquePrompt(context);
+    case "compare":
+      return buildComparePrompt(context);
+  }
+}
diff --git a/backend/src/websocket-handler.ts b/backend/src/websocket-handler.ts
index e321dcb8..2d5030e9 100644
--- a/backend/src/websocket-handler.ts
+++ b/backend/src/websocket-handler.ts
@@ -198,6 +198,11 @@ import {
   handleTriggerExtraction,
 } from "./handlers/memory-handlers.js";
 
+import {
+  handleQuickAction,
+  handleAdvisoryAction,
+} from "./handlers/pair-writing-handlers.js";
+
 // Re-export types for external consumers
 export type { WebSocketLike, ConnectionState };
 export { createConnectionState, generateMessageId };
@@ -302,6 +307,9 @@ export class WebSocketHandler {
       getAllTasks: hd.getAllTasks ?? defaultGetAllTasks,
       toggleTask: hd.toggleTask ?? defaultToggleTask,
       getRecentSessions: hd.getRecentSessions ?? defaultGetRecentSessions,
+      createSession: hd.createSession ?? defaultCreateSession,
+      resumeSession: hd.resumeSession ?? defaultResumeSession,
+      appendMessage: hd.appendMessage ?? defaultAppendMessage,
       loadVaultConfig: hd.loadVaultConfig ?? defaultLoadVaultConfig,
     };
   }
@@ -754,6 +762,15 @@ export class WebSocketHandler {
       case "trigger_extraction":
         await handleTriggerExtraction(ctx);
         break;
+
+      // Pair Writing handlers
+      case "quick_action_request":
+        await handleQuickAction(ctx, message);
+        break;
+
+      case "advisory_action_request":
+        await handleAdvisoryAction(ctx, message);
+        break;
     }
   }
 
diff --git a/frontend/src/App.css b/frontend/src/App.css
index 8f3f7f2a..9c98d18c 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -127,7 +127,7 @@
   height: 32px;
 }
 
-/* Title button for collapsing (mobile only) */
+/* Title button for collapsing */
 .app-title-btn {
   background: transparent;
   border: none;
@@ -137,33 +137,31 @@
   display: contents;
 }
 
-/* Mobile collapsed state */
-@media (max-width: 767px) {
-  .app-header--collapsed {
-    flex-wrap: nowrap;
-    justify-content: flex-start;
-  }
+/* Collapsed header state (all screen sizes) */
+.app-header--collapsed {
+  flex-wrap: nowrap;
+  justify-content: flex-start;
+}
 
-  .app-header--collapsed .app-header__collapse-btn {
-    display: flex;
-  }
+.app-header--collapsed .app-header__collapse-btn {
+  display: flex;
+}
 
-  .app-header--collapsed .app-header__left,
-  .app-header--collapsed .app-header__right {
-    display: none;
-  }
+.app-header--collapsed .app-header__left,
+.app-header--collapsed .app-header__right {
+  display: none;
+}
 
-  .app-header--collapsed .app-header__center {
-    order: 0;
-    width: auto;
-    flex: 1;
-    justify-content: flex-start;
-  }
+.app-header--collapsed .app-header__center {
+  order: 0;
+  width: max-content;
+  flex: 1;
+  justify-content: center;
+}
 
-  /* Expanded state on mobile */
-  .app-header--expanded .app-header__collapse-btn {
-    display: none;
-  }
+/* Expanded state - hide collapse button */
+.app-header--expanded .app-header__collapse-btn {
+  display: none;
 }
 
 .app-header__left {
@@ -347,7 +345,13 @@
   display: flex;
   flex-direction: column;
   width: 100%;
-  max-width: 1000px;
+  max-width: 800px;
   margin: 0 auto;
   overflow: hidden;
+  transition: max-width 0.3s ease;
+}
+
+/* Full-width layout for Pair Writing mode */
+[data-pair-writing] .app-main {
+  max-width: 100vw;
 }
diff --git a/frontend/src/components/BrowseMode.css b/frontend/src/components/BrowseMode.css
index a5608b3f..8b00fc6e 100644
--- a/frontend/src/components/BrowseMode.css
+++ b/frontend/src/components/BrowseMode.css
@@ -10,6 +10,7 @@
   height: 100%;
   overflow: hidden;
   background: var(--glass-bg);
+  transition: grid-template-columns 0.3s ease;
 }
 
 .browse-mode--tree-collapsed {
diff --git a/frontend/src/components/BrowseMode.tsx b/frontend/src/components/BrowseMode.tsx
index e09df487..8e85ffd9 100644
--- a/frontend/src/components/BrowseMode.tsx
+++ b/frontend/src/components/BrowseMode.tsx
@@ -22,6 +22,7 @@ import { CsvViewer } from "./CsvViewer";
 import { DownloadViewer } from "./DownloadViewer";
 import { SearchHeader } from "./SearchHeader";
 import { SearchResults } from "./SearchResults";
+import { PairWritingMode } from "./PairWritingMode";
 import { isImageFile, isVideoFile, isPdfFile, isMarkdownFile, isJsonFile, isTxtFile, isCsvFile, hasSupportedViewer } from "../utils/file-types";
 import type { FileSearchResult, ContentSearchResult } from "@memory-loop/shared";
 import "./BrowseMode.css";
@@ -45,6 +46,7 @@ export function BrowseMode(): React.ReactNode {
   const [isTreeCollapsed, setIsTreeCollapsed] = useState(false);
   const [isMobileTreeOpen, setIsMobileTreeOpen] = useState(false);
   const [pendingDirectoryContents, setPendingDirectoryContents] = useState<DirectoryContents | null>(null);
+  const [isPairWritingActive, setIsPairWritingActive] = useState(false);
 
   const hasSentVaultSelectionRef = useRef(false);
   const [hasSessionReady, setHasSessionReady] = useState(false);
@@ -63,6 +65,22 @@ export function BrowseMode(): React.ReactNode {
   // Track pending task toggles for rollback on error
   const pendingTaskTogglesRef = useRef<Map<string, string>>(new Map());
 
+  // Track isPairWritingActive in a ref for use in callbacks without stale closures
+  const isPairWritingActiveRef = useRef(isPairWritingActive);
+  isPairWritingActiveRef.current = isPairWritingActive;
+
+  // Set data attribute on document for CSS styling (full-width layout in pair writing mode)
+  useEffect(() => {
+    if (isPairWritingActive) {
+      document.documentElement.dataset.pairWriting = "true";
+    } else {
+      delete document.documentElement.dataset.pairWriting;
+    }
+    return () => {
+      delete document.documentElement.dataset.pairWriting;
+    };
+  }, [isPairWritingActive]);
+
   // Hook to handle session-level messages (widgets, etc.)
   const handleServerMessage = useServerMessageHandler();
 
@@ -72,9 +90,25 @@ export function BrowseMode(): React.ReactNode {
     setHasSessionReady(false);
   }, []);
 
+  // Streaming message types that Discussion handles when PairWritingMode is active
+  const STREAMING_MESSAGE_TYPES = new Set([
+    "response_start",
+    "response_chunk",
+    "response_end",
+    "tool_start",
+    "tool_input",
+    "tool_end",
+  ]);
+
   // Handle incoming messages - route to server message handler for session-level processing
+  // Skip streaming messages when PairWritingMode is active (Discussion handles those)
   const handleMessage = useCallback(
     (message: import("@memory-loop/shared").ServerMessage) => {
+      // When PairWritingMode is active, Discussion handles streaming messages
+      // via its shared connection. Skip them here to avoid double processing.
+      if (isPairWritingActiveRef.current && STREAMING_MESSAGE_TYPES.has(message.type)) {
+        return;
+      }
       handleServerMessage(message);
     },
     [handleServerMessage]
@@ -672,9 +706,22 @@ export function BrowseMode(): React.ReactNode {
     [search.query, sendGetSnippets]
   );
 
+  // Enter Pair Writing Mode (REQ-F-9)
+  const handleEnterPairWriting = useCallback(() => {
+    setIsPairWritingActive(true);
+  }, []);
+
+  // Exit Pair Writing Mode and return to standard Browse view (REQ-F-14)
+  const handleExitPairWriting = useCallback(() => {
+    setIsPairWritingActive(false);
+  }, []);
+
   // Get the view mode title text
   const viewModeTitle = viewMode === "files" ? "Files" : "Tasks";
 
+  // Check if current file is a markdown file (for Pair Writing button visibility)
+  const isCurrentFileMarkdown = isMarkdownFile(browser.currentPath);
+
   return (
     <div className={`browse-mode ${isTreeCollapsed ? "browse-mode--tree-collapsed" : ""}`}>
       {/* Desktop tree pane */}
@@ -774,7 +821,20 @@ export function BrowseMode(): React.ReactNode {
           </div>
         )}
         <article className="browse-mode__viewer-content">
-          {isImageFile(browser.currentPath) ? (
+          {/* Pair Writing Mode takes over the viewer when active (REQ-F-11) */}
+          {isPairWritingActive && isCurrentFileMarkdown && browser.currentFileContent !== null ? (
+            <PairWritingMode
+              filePath={browser.currentPath}
+              content={browser.currentFileContent}
+              assetBaseUrl={assetBaseUrl}
+              onExit={handleExitPairWriting}
+              onSave={handleSave}
+              sendMessage={sendMessage}
+              lastMessage={lastMessage}
+              connectionStatus={connectionStatus}
+              onQuickActionComplete={handleNavigate}
+            />
+          ) : isImageFile(browser.currentPath) ? (
             <ImageViewer path={browser.currentPath} assetBaseUrl={assetBaseUrl} onMobileMenuClick={toggleMobileTree} />
           ) : isVideoFile(browser.currentPath) ? (
             <VideoViewer path={browser.currentPath} assetBaseUrl={assetBaseUrl} onMobileMenuClick={toggleMobileTree} />
@@ -787,7 +847,13 @@ export function BrowseMode(): React.ReactNode {
           ) : isCsvFile(browser.currentPath) ? (
             <CsvViewer onNavigate={handleNavigate} onMobileMenuClick={toggleMobileTree} />
           ) : isMarkdownFile(browser.currentPath) || !browser.currentPath ? (
-            <MarkdownViewer onNavigate={handleNavigate} assetBaseUrl={assetBaseUrl} onSave={handleSave} onMobileMenuClick={toggleMobileTree} />
+            <MarkdownViewer
+              onNavigate={handleNavigate}
+              assetBaseUrl={assetBaseUrl}
+              onSave={handleSave}
+              onMobileMenuClick={toggleMobileTree}
+              onEnterPairWriting={handleEnterPairWriting}
+            />
           ) : (
             <DownloadViewer path={browser.currentPath} assetBaseUrl={assetBaseUrl} onMobileMenuClick={toggleMobileTree} />
           )}
diff --git a/frontend/src/components/ConversationPane.css b/frontend/src/components/ConversationPane.css
new file mode 100644
index 00000000..73b6eb2a
--- /dev/null
+++ b/frontend/src/components/ConversationPane.css
@@ -0,0 +1,101 @@
+/**
+ * ConversationPane Component Styles
+ *
+ * Shared conversation display styles for Discussion mode and Pair Writing Mode.
+ * Extracted from Discussion.css to ensure consistent styling (REQ-NF-4).
+ */
+
+/* Messages container */
+.conversation-pane {
+  flex: 1;
+  overflow-y: auto;
+  padding: var(--spacing-md);
+  scroll-behavior: smooth;
+}
+
+/* Empty state */
+.conversation-pane__empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: end;
+  height: 100%;
+  text-align: center;
+  color: var(--color-text-secondary);
+  padding: var(--spacing-lg);
+}
+
+.conversation-pane__empty p::before {
+  content: '';
+  position: absolute;
+  inset: 0;
+  background-image: url('/images/bg-quartary.webp');
+  background-size: cover;
+  background-position: center center;
+  border-radius: inherit;
+  opacity: 0.15;
+  z-index: -1;
+}
+
+.conversation-pane__empty p,
+.conversation-pane__empty .conversation-pane__hint {
+  background: var(--glass-bg);
+  backdrop-filter: blur(var(--glass-blur-light));
+  padding: var(--spacing-sm) var(--spacing-md);
+  border-radius: var(--radius-md);
+}
+
+.conversation-pane__empty::before {
+  content: "";
+  width: 60px;
+  height: 60px;
+  background-image: url('/images/empty-state.webp');
+  filter: hue-rotate(var(--holiday-hue-rotate, 0deg));
+  background-size: contain;
+  background-repeat: no-repeat;
+  background-position: center;
+  animation: conversation-pane-disintegrate 20s ease-in-out infinite;
+  margin-bottom: var(--space-6);
+}
+
+@keyframes conversation-pane-disintegrate {
+  0% {
+    transform: translateY(50px);
+    filter: blur(0px) opacity(100%);
+  }
+  50% {
+    transform: translateY(50px) scale(1.5);
+    filter: blur(4px) opacity(25%);
+  }
+  100% {
+    transform: translateY(50px);
+    filter: blur(0px) opacity(100%);
+  }
+}
+
+/* Larger orb on desktop */
+@media (min-width: 768px) {
+  .conversation-pane__empty::before {
+    width: 60px;
+    height: 60px;
+  }
+}
+
+.conversation-pane__empty p {
+  margin: 0;
+  font-size: var(--font-size-lg);
+}
+
+.conversation-pane__hint {
+  font-size: var(--font-size-sm);
+  margin-top: var(--spacing-sm) !important;
+  color: var(--color-text-accent-secondary);
+  font-style: italic;
+}
+
+/* Tablet and up */
+@media (min-width: 768px) {
+  .conversation-pane {
+    padding: var(--spacing-lg);
+  }
+}
diff --git a/frontend/src/components/ConversationPane.tsx b/frontend/src/components/ConversationPane.tsx
new file mode 100644
index 00000000..24e6c187
--- /dev/null
+++ b/frontend/src/components/ConversationPane.tsx
@@ -0,0 +1,84 @@
+/**
+ * ConversationPane Component
+ *
+ * Shared conversation display for Discussion mode and Pair Writing Mode.
+ * Renders message list with auto-scroll and streaming indicator.
+ *
+ * Extracted from Discussion.tsx per TD-7 to ensure REQ-NF-4 (consistent styling).
+ */
+
+import React, { useEffect, useRef } from "react";
+import type { ConversationMessage } from "../contexts/SessionContext";
+import { MessageBubble } from "./MessageBubble";
+import "./ConversationPane.css";
+
+/**
+ * Props for ConversationPane component.
+ */
+export interface ConversationPaneProps {
+  /** Messages to display */
+  messages: ConversationMessage[];
+  /** Vault ID for constructing image URLs in messages */
+  vaultId?: string;
+  /** Empty state content (displayed when no messages) */
+  emptyState?: React.ReactNode;
+  /** Additional CSS class for the container */
+  className?: string;
+  /** ARIA label for the conversation (defaults to "Conversation") */
+  ariaLabel?: string;
+}
+
+/**
+ * Default empty state for Discussion mode.
+ */
+export function DiscussionEmptyState(): React.ReactNode {
+  return (
+    <div className="conversation-pane__empty">
+      <p>Start a conversation about your vault.</p>
+      <p className="conversation-pane__hint">
+        Try asking questions about your notes or use slash commands.
+      </p>
+    </div>
+  );
+}
+
+/**
+ * Renders a scrollable conversation with messages and auto-scroll behavior.
+ *
+ * Features:
+ * - Scrollable message list with user/assistant messages
+ * - Auto-scrolls to bottom when messages change
+ * - Configurable empty state for different contexts
+ * - Matches Discussion mode styling (REQ-NF-4)
+ */
+export function ConversationPane({
+  messages,
+  vaultId,
+  emptyState,
+  className,
+  ariaLabel = "Conversation",
+}: ConversationPaneProps): React.ReactNode {
+  const messagesEndRef = useRef<HTMLDivElement>(null);
+
+  // Auto-scroll to bottom when messages change
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+
+  const containerClassName = className
+    ? `conversation-pane ${className}`
+    : "conversation-pane";
+
+  return (
+    <div className={containerClassName} role="list" aria-label={ariaLabel}>
+      {messages.length === 0 ? (
+        emptyState ?? <DiscussionEmptyState />
+      ) : (
+        messages.map((message) => (
+          <MessageBubble key={message.id} message={message} vaultId={vaultId} />
+        ))
+      )}
+      <div ref={messagesEndRef} aria-hidden="true" />
+    </div>
+  );
+}
diff --git a/frontend/src/components/Discussion.css b/frontend/src/components/Discussion.css
index 409c63f6..35fc932c 100644
--- a/frontend/src/components/Discussion.css
+++ b/frontend/src/components/Discussion.css
@@ -12,93 +12,8 @@
   position: relative;
 }
 
-/* Messages container */
-.discussion__messages {
-  flex: 1;
-  overflow-y: auto;
-  padding: var(--spacing-md);
-  scroll-behavior: smooth;
-}
-
-/* Empty state */
-.discussion__empty {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: end;
-  height: 100%;
-  text-align: center;
-  color: var(--color-text-secondary);
-  padding: var(--spacing-lg);
-}
-.discussion__empty p::before {
-  content: '';
-  position: absolute;
-  inset: 0;
-  background-image: url('/images/bg-quartary.webp');
-  background-size: cover;
-  background-position: center center;
-  border-radius: inherit;
-  opacity: 0.15;
-  z-index: -1;
-}
-
-
-.discussion__empty p,
-.discussion__empty .discussion__hint {
-  background: var(--glass-bg);
-  backdrop-filter: blur(var(--glass-blur-light));
-  padding: var(--spacing-sm) var(--spacing-md);
-  border-radius: var(--radius-md);
-}
-
-.discussion__empty::before {
-  content: "";
-  width: 60px;
-  height: 60px;
-  background-image: url('/images/empty-state.webp');
-  filter: hue-rotate(var(--holiday-hue-rotate, 0deg));
-  background-size: contain;
-  background-repeat: no-repeat;
-  background-position: center;
-  animation: disintegrate 20s ease-in-out infinite;
-  margin-bottom: var(--space-6);
-}
-
-@keyframes disintegrate {
-  0% { 
-    transform: translateY(50px);
-    filter: blur(0px) opacity(100%);
-  }
-  50% { 
-    transform: translateY(50px) scale(1.5);
-    filter: blur(4px) opacity(25%);
-  }
-  100% { 
-    transform: translateY(50px);
-    filter: blur(0px) opacity(100%);
-  }
-}
-
-/* Larger orb on desktop */
-@media (min-width: 768px) {
-  .discussion__empty::before {
-    width: 60px;
-    height: 60px;
-  }
-}
-
-.discussion__empty p {
-  margin: 0;
-  font-size: var(--font-size-lg);
-}
-
-.discussion__hint {
-  font-size: var(--font-size-sm);
-  margin-top: var(--spacing-sm) !important;
-  color: var(--color-text-accent-secondary);
-  font-style: italic;
-}
+/* Messages container - now uses ConversationPane with discussion__messages class.
+ * Empty state styling is handled by ConversationPane.css. */
 
 /* Input area */
 .discussion__input-area {
@@ -239,10 +154,6 @@
 
 /* Tablet and up */
 @media (min-width: 768px) {
-  .discussion__messages {
-    padding: var(--spacing-lg);
-  }
-
   .discussion__input-area {
     padding: var(--spacing-md) var(--spacing-lg);
   }
diff --git a/frontend/src/components/Discussion.tsx b/frontend/src/components/Discussion.tsx
index 8fdffad2..2dcc42f2 100644
--- a/frontend/src/components/Discussion.tsx
+++ b/frontend/src/components/Discussion.tsx
@@ -6,10 +6,10 @@
  */
 
 import React, { useState, useEffect, useRef, useCallback, useMemo } from "react";
-import type { ServerMessage, SlashCommand } from "@memory-loop/shared";
-import { useWebSocket } from "../hooks/useWebSocket";
+import type { ServerMessage, SlashCommand, ClientMessage } from "@memory-loop/shared";
+import { useWebSocket, type ConnectionStatus } from "../hooks/useWebSocket";
 import { useSession, useServerMessageHandler } from "../contexts/SessionContext";
-import { MessageBubble } from "./MessageBubble";
+import { ConversationPane, DiscussionEmptyState } from "./ConversationPane";
 import { ConfirmDialog } from "./ConfirmDialog";
 import { ToolPermissionDialog, type ToolPermissionRequest } from "./ToolPermissionDialog";
 import { AskUserQuestionDialog, type AskUserQuestionRequest } from "./AskUserQuestionDialog";
@@ -19,6 +19,22 @@ import "./Discussion.css";
 
 const STORAGE_KEY = "memory-loop-discussion-draft";
 
+/**
+ * Props for the Discussion component.
+ * All props are optional to maintain backward compatibility.
+ * When provided, Discussion uses the shared WebSocket connection instead of creating its own.
+ */
+export interface DiscussionProps {
+  /** Function to send WebSocket messages (shared connection) */
+  sendMessage?: (message: ClientMessage) => void;
+  /** Current connection status (shared connection) */
+  connectionStatus?: ConnectionStatus;
+  /** Last received server message (shared connection) */
+  lastMessage?: ServerMessage | null;
+  /** Callback fired when reconnecting (shared connection) */
+  onReconnect?: () => void;
+}
+
 /**
  * Chat interface for vault-contextualized AI discussions.
  *
@@ -28,8 +44,11 @@ const STORAGE_KEY = "memory-loop-discussion-draft";
  * - Slash command autocomplete with keyboard navigation
  * - Auto-scroll to bottom on new messages
  * - Draft preservation in localStorage
+ *
+ * When props are provided, Discussion uses a shared WebSocket connection.
+ * This enables embedding Discussion in Pair Writing Mode with a shared session.
  */
-export function Discussion(): React.ReactNode {
+export function Discussion(props: DiscussionProps = {}): React.ReactNode {
   const [input, setInput] = useState("");
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [isFocused, setIsFocused] = useState(false);
@@ -39,7 +58,7 @@ export function Discussion(): React.ReactNode {
   const [autocompleteSelectedIndex, setAutocompleteSelectedIndex] = useState(0);
   const [argumentHintPlaceholder, setArgumentHintPlaceholder] = useState<string | null>(null);
 
-  const messagesEndRef = useRef<HTMLDivElement>(null);
+  // messagesEndRef removed - auto-scroll now handled by ConversationPane
   const inputRef = useRef<HTMLTextAreaElement>(null);
   const hasSentVaultSelectionRef = useRef(false);
   const prevSessionIdRef = useRef<string | null>(null);
@@ -76,6 +95,11 @@ export function Discussion(): React.ReactNode {
     return () => query.removeEventListener("change", handler);
   }, []);
 
+  // Check if we're using a shared connection (all three props provided)
+  const isSharedConnection = props.sendMessage !== undefined &&
+    props.connectionStatus !== undefined &&
+    props.lastMessage !== undefined;
+
   // Callback to re-send vault selection on WebSocket reconnect
   const handleReconnect = useCallback(() => {
     hasSentVaultSelectionRef.current = false;
@@ -83,7 +107,9 @@ export function Discussion(): React.ReactNode {
     setIsSubmitting(false);
     // Clear any pending permission dialog - backend lost the request on disconnect
     setPendingPermission(null);
-  }, []);
+    // Call external onReconnect if provided
+    props.onReconnect?.();
+  }, [props.onReconnect]);
 
   const handleServerMessage = useServerMessageHandler();
 
@@ -144,10 +170,30 @@ export function Discussion(): React.ReactNode {
     [handleServerMessage, addToolToLastMessage, updateToolInput, completeToolInvocation]
   );
 
-  const { sendMessage, lastMessage, connectionStatus } = useWebSocket({
-    onReconnect: handleReconnect,
-    onMessage: handleMessage,
-  });
+  // Use internal WebSocket only when not using shared connection
+  const internalWs = useWebSocket(
+    isSharedConnection
+      ? {} // Minimal config when not using (connection still created but not used)
+      : {
+          onReconnect: handleReconnect,
+          onMessage: handleMessage,
+        }
+  );
+
+  // Select between shared and internal connection
+  const sendMessage = isSharedConnection ? props.sendMessage! : internalWs.sendMessage;
+  const connectionStatus = isSharedConnection ? props.connectionStatus! : internalWs.connectionStatus;
+  const lastMessage = isSharedConnection ? props.lastMessage! : internalWs.lastMessage;
+
+  // Process messages from shared connection via useEffect on lastMessage
+  // (internal connection uses onMessage callback instead)
+  const lastProcessedMessageRef = useRef<ServerMessage | null>(null);
+  useEffect(() => {
+    if (isSharedConnection && lastMessage && lastMessage !== lastProcessedMessageRef.current) {
+      lastProcessedMessageRef.current = lastMessage;
+      handleMessage(lastMessage);
+    }
+  }, [isSharedConnection, lastMessage, handleMessage]);
 
   // Send vault selection when WebSocket connects (initial or reconnect)
   // Sessions are stored per-vault, so we must select vault before resuming any session.
@@ -285,10 +331,7 @@ export function Discussion(): React.ReactNode {
     }
   }, [input]);
 
-  // Auto-scroll to bottom when messages change
-  useEffect(() => {
-    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
-  }, [messages]);
+  // Auto-scroll removed - now handled by ConversationPane
 
   // Slash command autocomplete logic
   // Check if input starts with "/" and we have commands available
@@ -497,21 +540,13 @@ export function Discussion(): React.ReactNode {
         +
       </button>
 
-      <div className="discussion__messages" role="list" aria-label="Conversation">
-        {messages.length === 0 ? (
-          <div className="discussion__empty">
-            <p>Start a conversation about your vault.</p>
-            <p className="discussion__hint">
-              Try asking questions about your notes or use slash commands.
-            </p>
-          </div>
-        ) : (
-          messages.map((message) => (
-            <MessageBubble key={message.id} message={message} vaultId={vault?.id} />
-          ))
-        )}
-        <div ref={messagesEndRef} aria-hidden="true" />
-      </div>
+      <ConversationPane
+        messages={messages}
+        vaultId={vault?.id}
+        emptyState={<DiscussionEmptyState />}
+        className="discussion__messages"
+        ariaLabel="Conversation"
+      />
 
       <form className="discussion__input-area" onSubmit={handleSubmit}>
         <SlashCommandAutocomplete
diff --git a/frontend/src/components/EditorContextMenu.css b/frontend/src/components/EditorContextMenu.css
new file mode 100644
index 00000000..a3c81afe
--- /dev/null
+++ b/frontend/src/components/EditorContextMenu.css
@@ -0,0 +1,117 @@
+/**
+ * EditorContextMenu Component Styles
+ *
+ * Context menu for Quick Actions on text selections.
+ * Uses glass morphism styling consistent with FileTree context menu.
+ */
+
+.editor-context-menu {
+  position: fixed;
+  z-index: 1000;
+  min-width: 180px;
+  max-width: 240px;
+  padding: var(--spacing-xs);
+  background: var(--glass-bg);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border: 1px solid var(--glass-border);
+  border-radius: var(--radius-md);
+  box-shadow: 0 8px 32px var(--color-black-a40);
+  animation: editor-context-menu-appear 0.1s ease-out;
+}
+
+@keyframes editor-context-menu-appear {
+  from {
+    opacity: 0;
+    transform: scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+/* Menu item */
+.editor-context-menu__item {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--spacing-sm);
+  width: 100%;
+  padding: var(--spacing-sm) var(--spacing-md);
+  background: transparent;
+  border: none;
+  border-radius: var(--radius-sm);
+  color: var(--color-text);
+  font-size: var(--text-sm);
+  text-align: left;
+  cursor: pointer;
+  transition: background-color 0.15s ease;
+}
+
+.editor-context-menu__item:hover,
+.editor-context-menu__item--focused {
+  background: var(--color-accent-primary-a15);
+}
+
+.editor-context-menu__item:focus {
+  outline: none;
+}
+
+.editor-context-menu__item:focus-visible {
+  outline: 2px solid var(--color-accent);
+  outline-offset: -2px;
+}
+
+/* Icon container */
+.editor-context-menu__icon {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  flex-shrink: 0;
+  margin-top: 2px;
+}
+
+.editor-context-menu__icon-svg {
+  width: 16px;
+  height: 16px;
+  color: var(--color-text-accent-secondary);
+}
+
+/* Content area (label + description) */
+.editor-context-menu__content {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+}
+
+.editor-context-menu__label {
+  font-weight: 500;
+  color: var(--color-text);
+}
+
+.editor-context-menu__description {
+  font-size: var(--text-xs);
+  color: var(--color-text-secondary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* Touch device adjustments */
+@media (hover: none) {
+  .editor-context-menu__item {
+    min-height: 48px;
+    padding: var(--spacing-md);
+  }
+
+  .editor-context-menu__item:hover {
+    background: transparent;
+  }
+
+  .editor-context-menu__item:active {
+    background: var(--color-accent-primary-a15);
+  }
+}
diff --git a/frontend/src/components/EditorContextMenu.tsx b/frontend/src/components/EditorContextMenu.tsx
new file mode 100644
index 00000000..81705839
--- /dev/null
+++ b/frontend/src/components/EditorContextMenu.tsx
@@ -0,0 +1,624 @@
+/**
+ * EditorContextMenu Component
+ *
+ * Context menu for Quick Actions on text selections in the markdown editor.
+ * Supports right-click (desktop) and long-press (mobile) triggers.
+ * Renders via portal at the selection position.
+ *
+ * In Pair Writing Mode, also shows Advisory Actions (Validate, Critique)
+ * and Compare to snapshot action.
+ *
+ * Implements: TD-1, TD-12 from the Pair Writing Mode plan.
+ * Addresses: REQ-F-2, REQ-F-3, REQ-F-15, REQ-F-18, REQ-F-25, REQ-NF-3, REQ-NF-5 from spec.
+ */
+
+import { useEffect, useRef, useCallback, useState } from "react";
+import { createPortal } from "react-dom";
+import "./EditorContextMenu.css";
+
+/**
+ * Editor modes that affect context menu contents.
+ */
+export type EditorMode = "browse" | "pair-writing";
+
+/**
+ * Quick Action types available in the context menu.
+ * These are transformative actions that directly modify the selected text.
+ */
+export type QuickActionType = "tighten" | "embellish" | "correct" | "polish";
+
+/**
+ * Advisory Action types available in Pair Writing Mode.
+ * These actions send selection to conversation pane (not inline replacement).
+ */
+export type AdvisoryActionType = "validate" | "critique" | "compare";
+
+/**
+ * Position for rendering the context menu.
+ */
+export interface MenuPosition {
+  x: number;
+  y: number;
+}
+
+/**
+ * Props for EditorContextMenu component.
+ */
+export interface EditorContextMenuProps {
+  /** Whether the menu is currently open */
+  isOpen: boolean;
+  /** Position to render the menu at (viewport coordinates) */
+  position: MenuPosition | null;
+  /** Callback when a Quick Action is selected */
+  onAction: (action: QuickActionType) => void;
+  /** Callback when the menu should be dismissed */
+  onDismiss: () => void;
+  /**
+   * Editor mode determines which actions are shown.
+   * - "browse": Only Quick Actions (Tighten, Embellish, Correct, Polish)
+   * - "pair-writing": Quick Actions + Advisory Actions (Validate, Critique) + Compare
+   * Defaults to "browse" for backward compatibility.
+   */
+  mode?: EditorMode;
+  /**
+   * Whether a snapshot exists. When true and mode is "pair-writing",
+   * the "Compare to snapshot" action is shown.
+   */
+  hasSnapshot?: boolean;
+  /**
+   * Callback when an Advisory Action is selected (Validate, Critique, Compare).
+   * Advisory actions dispatch to conversation pane, not inline replacement.
+   * Only relevant in "pair-writing" mode.
+   */
+  onAdvisoryAction?: (action: AdvisoryActionType) => void;
+}
+
+/**
+ * Menu item configuration for Quick Actions.
+ */
+interface QuickMenuItem {
+  action: QuickActionType;
+  label: string;
+  description: string;
+}
+
+/**
+ * Menu item configuration for Advisory Actions.
+ */
+interface AdvisoryMenuItem {
+  action: AdvisoryActionType;
+  label: string;
+  description: string;
+}
+
+/**
+ * Quick Actions menu items configuration.
+ * These are transformative actions (REQ-F-1).
+ */
+const QUICK_ACTIONS: QuickMenuItem[] = [
+  {
+    action: "tighten",
+    label: "Tighten",
+    description: "Make more concise",
+  },
+  {
+    action: "embellish",
+    label: "Embellish",
+    description: "Add detail and nuance",
+  },
+  {
+    action: "correct",
+    label: "Correct",
+    description: "Fix typos and grammar",
+  },
+  {
+    action: "polish",
+    label: "Polish",
+    description: "Correct and improve prose",
+  },
+];
+
+/**
+ * Advisory Actions menu items configuration.
+ * These are non-transformative actions shown only in Pair Writing Mode (REQ-F-15).
+ */
+const ADVISORY_ACTIONS: AdvisoryMenuItem[] = [
+  {
+    action: "validate",
+    label: "Validate",
+    description: "Fact-check the claim",
+  },
+  {
+    action: "critique",
+    label: "Critique",
+    description: "Analyze clarity, voice, structure",
+  },
+];
+
+/**
+ * Compare action shown when snapshot exists (REQ-F-25).
+ */
+const COMPARE_ACTION: AdvisoryMenuItem = {
+  action: "compare",
+  label: "Compare to snapshot",
+  description: "Show what changed",
+};
+
+/**
+ * EditorContextMenu displays Quick Actions for text selections.
+ *
+ * Features:
+ * - Renders via React portal at specified position
+ * - Keyboard navigation (Arrow keys, Enter, Escape)
+ * - Click outside dismissal
+ * - Accessible via role="menu" and role="menuitem"
+ * - In Pair Writing Mode: shows Advisory Actions (Validate, Critique)
+ * - Shows Compare action when snapshot exists
+ *
+ * Usage:
+ * ```tsx
+ * // Browse mode (default)
+ * <EditorContextMenu
+ *   isOpen={menuOpen}
+ *   position={{ x: 100, y: 200 }}
+ *   onAction={(action) => handleQuickAction(action)}
+ *   onDismiss={() => setMenuOpen(false)}
+ * />
+ *
+ * // Pair Writing Mode with snapshot
+ * <EditorContextMenu
+ *   isOpen={menuOpen}
+ *   position={{ x: 100, y: 200 }}
+ *   onAction={(action) => handleQuickAction(action)}
+ *   onAdvisoryAction={(action) => handleAdvisoryAction(action)}
+ *   onDismiss={() => setMenuOpen(false)}
+ *   mode="pair-writing"
+ *   hasSnapshot={true}
+ * />
+ * ```
+ */
+export function EditorContextMenu({
+  isOpen,
+  position,
+  onAction,
+  onDismiss,
+  mode = "browse",
+  hasSnapshot = false,
+  onAdvisoryAction,
+}: EditorContextMenuProps): React.ReactNode {
+  const menuRef = useRef<HTMLDivElement>(null);
+  const [focusedIndex, setFocusedIndex] = useState(0);
+
+  // Build the list of all menu items based on mode
+  const allItems = buildMenuItems(mode, hasSnapshot);
+  const itemCount = allItems.length;
+
+  // Reset focus index when menu opens
+  useEffect(() => {
+    if (isOpen) {
+      setFocusedIndex(0);
+    }
+  }, [isOpen]);
+
+  // Focus the menu when it opens
+  useEffect(() => {
+    if (isOpen && menuRef.current) {
+      // Focus the first menu item
+      const firstItem = menuRef.current.querySelector<HTMLButtonElement>(
+        '[role="menuitem"]'
+      );
+      firstItem?.focus();
+    }
+  }, [isOpen]);
+
+  // Click outside handler
+  useEffect(() => {
+    if (!isOpen) return;
+
+    function handleClickOutside(event: MouseEvent) {
+      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+        onDismiss();
+      }
+    }
+
+    // Use mousedown to catch click before it propagates
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [isOpen, onDismiss]);
+
+  // Escape key handler
+  useEffect(() => {
+    if (!isOpen) return;
+
+    function handleKeyDown(event: KeyboardEvent) {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onDismiss();
+      }
+    }
+
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [isOpen, onDismiss]);
+
+  // Handle action based on item type
+  const handleItemAction = useCallback(
+    (item: MenuItem) => {
+      if (item.type === "quick") {
+        onAction(item.action as QuickActionType);
+      } else if (onAdvisoryAction) {
+        onAdvisoryAction(item.action as AdvisoryActionType);
+      }
+    },
+    [onAction, onAdvisoryAction]
+  );
+
+  // Keyboard navigation within the menu
+  const handleKeyDown = useCallback(
+    (event: React.KeyboardEvent) => {
+      switch (event.key) {
+        case "ArrowDown":
+          event.preventDefault();
+          setFocusedIndex((prev) => (prev + 1) % itemCount);
+          break;
+        case "ArrowUp":
+          event.preventDefault();
+          setFocusedIndex((prev) => (prev - 1 + itemCount) % itemCount);
+          break;
+        case "Enter":
+        case " ":
+          event.preventDefault();
+          handleItemAction(allItems[focusedIndex]);
+          break;
+        case "Home":
+          event.preventDefault();
+          setFocusedIndex(0);
+          break;
+        case "End":
+          event.preventDefault();
+          setFocusedIndex(itemCount - 1);
+          break;
+      }
+    },
+    [focusedIndex, itemCount, allItems, handleItemAction]
+  );
+
+  // Focus the correct item when focusedIndex changes
+  useEffect(() => {
+    if (!isOpen || !menuRef.current) return;
+
+    const items = menuRef.current.querySelectorAll<HTMLButtonElement>(
+      '[role="menuitem"]'
+    );
+    items[focusedIndex]?.focus();
+  }, [focusedIndex, isOpen]);
+
+  if (!isOpen || !position) {
+    return null;
+  }
+
+  // Calculate menu position to keep it in viewport (consider more items in pair-writing mode)
+  const estimatedHeight = itemCount * 56 + 16; // 56px per item + padding
+  const menuStyle = calculateMenuPosition(position, estimatedHeight);
+
+  // Determine aria-label based on mode
+  const ariaLabel = mode === "pair-writing" ? "Writing Actions" : "Quick Actions";
+
+  const menuContent = (
+    <div
+      ref={menuRef}
+      className="editor-context-menu"
+      style={menuStyle}
+      role="menu"
+      aria-label={ariaLabel}
+      onKeyDown={handleKeyDown}
+    >
+      {allItems.map((item, index) => (
+        <button
+          key={item.action}
+          type="button"
+          className={`editor-context-menu__item ${
+            index === focusedIndex ? "editor-context-menu__item--focused" : ""
+          }${item.type === "advisory" ? " editor-context-menu__item--advisory" : ""}`}
+          role="menuitem"
+          tabIndex={index === focusedIndex ? 0 : -1}
+          onClick={() => handleItemAction(item)}
+          aria-describedby={`action-desc-${item.action}`}
+        >
+          <span className="editor-context-menu__icon">
+            <MenuItemIcon action={item.action} />
+          </span>
+          <span className="editor-context-menu__content">
+            <span className="editor-context-menu__label">{item.label}</span>
+            <span
+              id={`action-desc-${item.action}`}
+              className="editor-context-menu__description"
+            >
+              {item.description}
+            </span>
+          </span>
+        </button>
+      ))}
+    </div>
+  );
+
+  // Render via portal to document.body
+  return createPortal(menuContent, document.body);
+}
+
+// ----------------------------------------------------------------------------
+// Helper Types and Functions
+// ----------------------------------------------------------------------------
+
+/**
+ * Unified menu item type that can represent both quick and advisory actions.
+ */
+interface MenuItem {
+  action: QuickActionType | AdvisoryActionType;
+  label: string;
+  description: string;
+  type: "quick" | "advisory";
+}
+
+/**
+ * Build the list of menu items based on mode and snapshot state.
+ */
+function buildMenuItems(mode: EditorMode, hasSnapshot: boolean): MenuItem[] {
+  // Always include Quick Actions
+  const items: MenuItem[] = QUICK_ACTIONS.map((item) => ({
+    ...item,
+    type: "quick" as const,
+  }));
+
+  // In Pair Writing Mode, add Advisory Actions (REQ-F-15)
+  if (mode === "pair-writing") {
+    items.push(
+      ...ADVISORY_ACTIONS.map((item) => ({
+        ...item,
+        type: "advisory" as const,
+      }))
+    );
+
+    // Add Compare action if snapshot exists (REQ-F-25)
+    if (hasSnapshot) {
+      items.push({
+        ...COMPARE_ACTION,
+        type: "advisory" as const,
+      });
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Calculate menu position to keep it within viewport bounds.
+ */
+function calculateMenuPosition(
+  position: MenuPosition,
+  estimatedHeight = 200
+): React.CSSProperties {
+  // Menu dimensions (approximate, CSS will handle actual sizing)
+  const menuWidth = 200;
+  const menuHeight = estimatedHeight;
+  const padding = 8;
+
+  const viewportWidth = window.innerWidth;
+  const viewportHeight = window.innerHeight;
+
+  let x = position.x;
+  let y = position.y;
+
+  // Keep menu within horizontal bounds
+  if (x + menuWidth > viewportWidth - padding) {
+    x = viewportWidth - menuWidth - padding;
+  }
+  if (x < padding) {
+    x = padding;
+  }
+
+  // Keep menu within vertical bounds
+  if (y + menuHeight > viewportHeight - padding) {
+    // Position above if not enough space below
+    y = position.y - menuHeight;
+    if (y < padding) {
+      y = padding;
+    }
+  }
+
+  return {
+    left: x,
+    top: y,
+  };
+}
+
+/**
+ * Icon component for all menu item types (quick and advisory actions).
+ */
+function MenuItemIcon({ action }: { action: QuickActionType | AdvisoryActionType }): React.ReactNode {
+  switch (action) {
+    case "tighten":
+      return <TightenIcon />;
+    case "embellish":
+      return <EmbellishIcon />;
+    case "correct":
+      return <CorrectIcon />;
+    case "polish":
+      return <PolishIcon />;
+    case "validate":
+      return <ValidateIcon />;
+    case "critique":
+      return <CritiqueIcon />;
+    case "compare":
+      return <CompareIcon />;
+  }
+}
+
+/**
+ * Tighten icon (compress/minimize).
+ */
+function TightenIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      {/* Arrows pointing inward */}
+      <polyline points="4 14 10 14 10 20" />
+      <polyline points="20 10 14 10 14 4" />
+      <line x1="14" y1="10" x2="21" y2="3" />
+      <line x1="3" y1="21" x2="10" y2="14" />
+    </svg>
+  );
+}
+
+/**
+ * Embellish icon (expand/add).
+ */
+function EmbellishIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      {/* Arrows pointing outward */}
+      <polyline points="15 3 21 3 21 9" />
+      <polyline points="9 21 3 21 3 15" />
+      <line x1="21" y1="3" x2="14" y2="10" />
+      <line x1="3" y1="21" x2="10" y2="14" />
+    </svg>
+  );
+}
+
+/**
+ * Correct icon (checkmark).
+ */
+function CorrectIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <polyline points="20 6 9 17 4 12" />
+    </svg>
+  );
+}
+
+/**
+ * Polish icon (sparkles).
+ */
+function PolishIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <path d="M12 3l1.5 4.5L18 9l-4.5 1.5L12 15l-1.5-4.5L6 9l4.5-1.5L12 3z" />
+      <path d="M19 14l.9 2.7 2.7.9-2.7.9-.9 2.7-.9-2.7-2.7-.9 2.7-.9.9-2.7z" />
+      <path d="M5 17l.6 1.8 1.8.6-1.8.6-.6 1.8-.6-1.8-1.8-.6 1.8-.6.6-1.8z" />
+    </svg>
+  );
+}
+
+/**
+ * Validate icon (shield with checkmark).
+ */
+function ValidateIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" />
+      <polyline points="9 12 11 14 15 10" />
+    </svg>
+  );
+}
+
+/**
+ * Critique icon (magnifying glass with lines).
+ */
+function CritiqueIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <circle cx="11" cy="11" r="8" />
+      <line x1="21" y1="21" x2="16.65" y2="16.65" />
+      <line x1="8" y1="9" x2="14" y2="9" />
+      <line x1="8" y1="13" x2="12" y2="13" />
+    </svg>
+  );
+}
+
+/**
+ * Compare icon (two documents with diff).
+ */
+function CompareIcon(): React.ReactNode {
+  return (
+    <svg
+      className="editor-context-menu__icon-svg"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <rect x="3" y="3" width="7" height="13" rx="1" />
+      <rect x="14" y="8" width="7" height="13" rx="1" />
+      <line x1="10" y1="12" x2="14" y2="12" />
+    </svg>
+  );
+}
+
+/**
+ * Exported for use by parent components that need to extract position
+ * from contextmenu or long-press events.
+ */
+export function getMenuPositionFromEvent(
+  event: React.MouseEvent | React.TouchEvent
+): MenuPosition {
+  if ("touches" in event) {
+    const touch = event.touches[0] || event.changedTouches[0];
+    return {
+      x: touch?.clientX ?? 0,
+      y: touch?.clientY ?? 0,
+    };
+  }
+  return {
+    x: event.clientX,
+    y: event.clientY,
+  };
+}
diff --git a/frontend/src/components/MarkdownViewer.css b/frontend/src/components/MarkdownViewer.css
index 0717855a..764a1095 100644
--- a/frontend/src/components/MarkdownViewer.css
+++ b/frontend/src/components/MarkdownViewer.css
@@ -509,6 +509,57 @@
   }
 }
 
+/* Toolbar actions container - groups action buttons */
+.markdown-viewer__toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+}
+
+/* Pair Writing button - desktop only (REQ-F-9, REQ-F-10) */
+.markdown-viewer__pair-writing-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: var(--spacing-xs) var(--spacing-md);
+  min-height: 32px;
+  background: transparent;
+  border: 1px solid var(--glass-border);
+  border-radius: var(--radius-md);
+  color: var(--color-text-accent);
+  cursor: pointer;
+  font-size: var(--text-sm);
+  font-weight: var(--font-medium);
+  transition: background-color 0.2s ease, color 0.2s ease, border-color 0.2s ease, box-shadow 0.3s ease;
+}
+
+.markdown-viewer__pair-writing-btn:hover {
+  background: var(--color-accent-primary-a10);
+  border-color: var(--color-accent);
+  color: var(--color-text);
+  box-shadow: 0 0 12px var(--color-accent-primary-a15);
+}
+
+.markdown-viewer__pair-writing-btn:focus-visible {
+  outline: 2px solid var(--color-accent);
+  outline-offset: 2px;
+}
+
+/* Hide Pair Writing button on touch/mobile devices (REQ-F-10) */
+@media (hover: none), (pointer: coarse) {
+  .markdown-viewer__pair-writing-btn {
+    display: none;
+  }
+}
+
+@media (hover: none) {
+  .markdown-viewer__pair-writing-btn:hover {
+    background: transparent;
+    border-color: var(--glass-border);
+    box-shadow: none;
+  }
+}
+
 /* Error message display (REQ-F-14) */
 .markdown-viewer__adjust-error {
   padding: var(--spacing-sm) var(--spacing-md);
diff --git a/frontend/src/components/MarkdownViewer.tsx b/frontend/src/components/MarkdownViewer.tsx
index dbc8aa85..8b14c4c2 100644
--- a/frontend/src/components/MarkdownViewer.tsx
+++ b/frontend/src/components/MarkdownViewer.tsx
@@ -34,6 +34,8 @@ export interface MarkdownViewerProps {
   onSave?: (content: string) => void;
   /** Callback to open mobile file browser (only shown on mobile) */
   onMobileMenuClick?: () => void;
+  /** Callback to enter Pair Writing Mode (desktop only, REQ-F-9) */
+  onEnterPairWriting?: () => void;
 }
 
 /**
@@ -354,6 +356,7 @@ export function MarkdownViewer({
   assetBaseUrl = "/vault/assets",
   onSave,
   onMobileMenuClick,
+  onEnterPairWriting,
 }: MarkdownViewerProps): ReactNode {
   const {
     browser,
@@ -609,14 +612,27 @@ export function MarkdownViewer({
           </button>
         )}
         <Breadcrumb path={currentPath} onNavigate={handleBreadcrumbNavigate} />
-        <button
-          type="button"
-          className="markdown-viewer__adjust-btn"
-          onClick={startAdjust}
-          aria-label="Adjust file"
-        >
-          Adjust
-        </button>
+        <div className="markdown-viewer__toolbar-actions">
+          <button
+            type="button"
+            className="markdown-viewer__adjust-btn"
+            onClick={startAdjust}
+            aria-label="Adjust file"
+          >
+            Adjust
+          </button>
+          {/* Pair Writing button - desktop only (REQ-F-9, REQ-F-10) */}
+          {onEnterPairWriting && (
+            <button
+              type="button"
+              className="markdown-viewer__pair-writing-btn"
+              onClick={onEnterPairWriting}
+              aria-label="Enter Pair Writing mode"
+            >
+              Pair Writing
+            </button>
+          )}
+        </div>
       </div>
 
       {currentFileTruncated && (
diff --git a/frontend/src/components/PairWritingEditor.css b/frontend/src/components/PairWritingEditor.css
new file mode 100644
index 00000000..9869b4ee
--- /dev/null
+++ b/frontend/src/components/PairWritingEditor.css
@@ -0,0 +1,80 @@
+/**
+ * PairWritingEditor styles
+ *
+ * Editor component for Pair Writing Mode with Quick Actions support.
+ */
+
+.pair-writing-editor {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  position: relative;
+}
+
+.pair-writing-editor__textarea {
+  flex: 1;
+  width: 100%;
+  padding: 1rem;
+  font-family: var(--font-mono, ui-monospace, monospace);
+  font-size: 0.875rem;
+  line-height: 1.6;
+  color: var(--color-text);
+  background-color: var(--color-surface);
+  border: none;
+  resize: none;
+  outline: none;
+}
+
+.pair-writing-editor__textarea:focus {
+  outline: none;
+}
+
+.pair-writing-editor__textarea::placeholder {
+  color: var(--color-text-muted);
+}
+
+/* Processing state */
+.pair-writing-editor--processing {
+  pointer-events: none;
+}
+
+.pair-writing-editor__textarea--processing {
+  opacity: 0.6;
+}
+
+/* Processing overlay */
+.pair-writing-editor__processing-overlay {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 1.5rem 2rem;
+  background-color: var(--color-surface-elevated, var(--color-surface));
+  border-radius: 0.5rem;
+  box-shadow: var(--shadow-lg, 0 4px 12px rgba(0, 0, 0, 0.15));
+  z-index: 10;
+}
+
+.pair-writing-editor__processing-spinner {
+  width: 24px;
+  height: 24px;
+  border: 2px solid var(--color-border);
+  border-top-color: var(--color-primary);
+  border-radius: 50%;
+  animation: pair-writing-editor-spin 0.8s linear infinite;
+}
+
+@keyframes pair-writing-editor-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.pair-writing-editor__processing-text {
+  font-size: 0.875rem;
+  color: var(--color-text-muted);
+}
diff --git a/frontend/src/components/PairWritingEditor.tsx b/frontend/src/components/PairWritingEditor.tsx
new file mode 100644
index 00000000..90f2baec
--- /dev/null
+++ b/frontend/src/components/PairWritingEditor.tsx
@@ -0,0 +1,328 @@
+/**
+ * PairWritingEditor Component
+ *
+ * Editor for Pair Writing Mode that handles arbitrary markdown files.
+ * Supports Quick Actions via context menu with text selection.
+ *
+ * Key difference from MemoryEditor: This component receives content via props
+ * rather than fetching a specific file. It's designed for editing any vault file.
+ *
+ * Features:
+ * - Textarea for editing content
+ * - Context menu with Quick Actions (Tighten, Embellish, Correct, Polish)
+ * - Advisory Actions in pair-writing mode (Validate, Critique, Compare)
+ * - WebSocket integration for streaming Quick Action responses
+ * - Toast notifications for Claude's commentary
+ *
+ * Spec Requirements:
+ * - REQ-F-4: Selection + context sent to Claude for Quick Actions
+ * - REQ-F-6: Toast for Claude commentary
+ * - REQ-F-7: Loading indicator on selection during processing
+ * - REQ-F-8: Quick Actions persist immediately via Claude Edit tool
+ * - REQ-F-12: Editor pane in split view
+ * - REQ-F-15: Advisory Actions (Validate, Critique)
+ */
+
+import { useState, useCallback, useEffect, useRef } from "react";
+import type {
+  ClientMessage,
+  ServerMessage,
+  QuickActionType as QuickActionTypeProtocol,
+} from "@memory-loop/shared";
+import {
+  EditorContextMenu,
+  getMenuPositionFromEvent,
+  type MenuPosition,
+  type QuickActionType,
+  type AdvisoryActionType,
+} from "./EditorContextMenu";
+import { useLongPress } from "../hooks/useLongPress";
+import {
+  useTextSelection,
+  type SelectionContext,
+} from "../hooks/useTextSelection";
+import { Toast, type ToastVariant } from "./Toast";
+import "./PairWritingEditor.css";
+
+/**
+ * Props for the PairWritingEditor component.
+ */
+export interface PairWritingEditorProps {
+  /** Initial file content to display */
+  initialContent: string;
+  /** File path (relative to vault content root) for Quick Actions */
+  filePath: string;
+  /** Function to send WebSocket messages */
+  sendMessage: (message: ClientMessage) => void;
+  /** Last received server message (for handling responses) */
+  lastMessage: ServerMessage | null;
+  /** Called when content changes (for tracking unsaved changes) */
+  onContentChange?: (content: string) => void;
+  /** Called when Quick Action completes and file should be reloaded */
+  onQuickActionComplete?: (path: string) => void;
+  /** Called when an Advisory Action is triggered (for conversation pane) */
+  onAdvisoryAction?: (
+    action: AdvisoryActionType,
+    selection: SelectionContext
+  ) => void;
+  /** Whether a snapshot exists (shows Compare action) */
+  hasSnapshot?: boolean;
+  /** Current snapshot content (for Compare action) */
+  snapshotContent?: string;
+  // Dependency injection for testing (avoids mock.module pollution)
+  /** Context menu component (defaults to EditorContextMenu) */
+  ContextMenuComponent?: typeof EditorContextMenu;
+  /** Toast component (defaults to Toast) */
+  ToastComponent?: typeof Toast;
+}
+
+/**
+ * PairWritingEditor Component
+ *
+ * A textarea-based editor for Pair Writing Mode that supports:
+ * - Quick Actions via context menu (right-click/long-press)
+ * - Advisory Actions for pair-writing mode
+ * - Real-time streaming of Claude's responses
+ * - Toast notifications for commentary
+ */
+export function PairWritingEditor({
+  initialContent,
+  filePath,
+  sendMessage,
+  lastMessage,
+  onContentChange,
+  onQuickActionComplete,
+  onAdvisoryAction,
+  hasSnapshot = false,
+  ContextMenuComponent = EditorContextMenu,
+  ToastComponent = Toast,
+}: PairWritingEditorProps): React.ReactNode {
+  // Content state - initialized from props, updated on edit
+  const [content, setContent] = useState(initialContent);
+
+  // Context menu state
+  const [menuOpen, setMenuOpen] = useState(false);
+  const [menuPosition, setMenuPosition] = useState<MenuPosition | null>(null);
+
+  // Quick Action state (REQ-F-7: loading indicator during processing)
+  const [isProcessingQuickAction, setIsProcessingQuickAction] = useState(false);
+  const [quickActionMessageId, setQuickActionMessageId] = useState<
+    string | null
+  >(null);
+  // Use ref for confirmation to avoid infinite loop in useEffect
+  // (state in deps would re-trigger effect on every chunk append)
+  const quickActionConfirmationRef = useRef("");
+
+  // Toast state (REQ-F-6: commentary displayed as toast)
+  const [toastVisible, setToastVisible] = useState(false);
+  const [toastMessage, setToastMessage] = useState("");
+  const [toastVariant, setToastVariant] = useState<ToastVariant>("success");
+
+  // Ref to the textarea for selection tracking
+  const textareaRef = useRef<HTMLTextAreaElement | null>(null);
+
+  // Track text selection
+  const { selection } = useTextSelection(textareaRef, content);
+
+  // Store selection context for use in action handlers
+  const selectionRef = useRef<SelectionContext | null>(null);
+  selectionRef.current = selection;
+
+  // Track filePath in ref for use in callbacks
+  const filePathRef = useRef(filePath);
+  filePathRef.current = filePath;
+
+  // Update content when initialContent changes (e.g., after Quick Action reload)
+  useEffect(() => {
+    setContent(initialContent);
+  }, [initialContent]);
+
+  // Handle server messages for Quick Actions
+  useEffect(() => {
+    if (!lastMessage || !isProcessingQuickAction) return;
+
+    if (lastMessage.type === "response_start") {
+      // Store message ID for tracking
+      setQuickActionMessageId(lastMessage.messageId);
+    } else if (lastMessage.type === "response_chunk") {
+      // Accumulate confirmation message text from Claude
+      if (lastMessage.messageId === quickActionMessageId) {
+        quickActionConfirmationRef.current += lastMessage.content;
+      }
+    } else if (lastMessage.type === "response_end") {
+      // Quick Action complete - clear processing state
+      setIsProcessingQuickAction(false);
+      setQuickActionMessageId(null);
+
+      // Show toast with confirmation message (REQ-F-6)
+      const confirmation = quickActionConfirmationRef.current.trim();
+      if (confirmation) {
+        setToastMessage(confirmation);
+        setToastVariant("success");
+        setToastVisible(true);
+      }
+      quickActionConfirmationRef.current = "";
+
+      // Trigger file reload (REQ-F-8: file is already updated by Claude's Edit tool)
+      onQuickActionComplete?.(filePathRef.current);
+    } else if (lastMessage.type === "error") {
+      // Clear Quick Action processing state on error
+      setIsProcessingQuickAction(false);
+      setQuickActionMessageId(null);
+      quickActionConfirmationRef.current = "";
+      // Show error toast
+      setToastMessage(lastMessage.message);
+      setToastVariant("error");
+      setToastVisible(true);
+    }
+  }, [lastMessage, isProcessingQuickAction, quickActionMessageId, onQuickActionComplete]);
+
+  // Handle content change
+  const handleChange = useCallback(
+    (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+      const newContent = e.target.value;
+      setContent(newContent);
+      onContentChange?.(newContent);
+    },
+    [onContentChange]
+  );
+
+  // Open context menu at position (only if there's a selection)
+  const openContextMenu = useCallback((position: MenuPosition) => {
+    // Only show menu if there's selected text
+    if (!selectionRef.current) return;
+    setMenuPosition(position);
+    setMenuOpen(true);
+  }, []);
+
+  // Close context menu
+  const closeContextMenu = useCallback(() => {
+    setMenuOpen(false);
+    setMenuPosition(null);
+  }, []);
+
+  // Handle right-click (desktop context menu)
+  const handleContextMenu = useCallback(
+    (e: React.MouseEvent<HTMLTextAreaElement>) => {
+      // Only intercept if there's a selection
+      if (!selectionRef.current) return;
+
+      e.preventDefault();
+      openContextMenu(getMenuPositionFromEvent(e));
+    },
+    [openContextMenu]
+  );
+
+  // Handle long-press (mobile context menu)
+  const handleLongPress = useCallback(
+    (e: React.TouchEvent) => {
+      // Only show menu if there's a selection
+      if (!selectionRef.current) return;
+
+      openContextMenu(getMenuPositionFromEvent(e));
+    },
+    [openContextMenu]
+  );
+
+  // Long press handlers for mobile
+  const longPressHandlers = useLongPress(handleLongPress, { duration: 500 });
+
+  // Handle Quick Action selection
+  const handleQuickAction = useCallback(
+    (action: QuickActionType) => {
+      const currentSelection = selectionRef.current;
+      if (!currentSelection) {
+        closeContextMenu();
+        return;
+      }
+
+      // Close menu immediately
+      closeContextMenu();
+
+      // Set processing state for loading indicator (REQ-F-7)
+      setIsProcessingQuickAction(true);
+      quickActionConfirmationRef.current = "";
+      setQuickActionMessageId(null);
+
+      // Send quick_action_request message (REQ-F-4)
+      sendMessage({
+        type: "quick_action_request",
+        action: action as QuickActionTypeProtocol,
+        selection: currentSelection.text,
+        contextBefore: currentSelection.contextBefore,
+        contextAfter: currentSelection.contextAfter,
+        filePath: filePathRef.current,
+        selectionStartLine: currentSelection.startLine,
+        selectionEndLine: currentSelection.endLine,
+        totalLines: currentSelection.totalLines,
+      });
+    },
+    [closeContextMenu, sendMessage]
+  );
+
+  // Handle Advisory Action selection (REQ-F-15)
+  const handleAdvisoryAction = useCallback(
+    (action: AdvisoryActionType) => {
+      const currentSelection = selectionRef.current;
+      if (!currentSelection) {
+        closeContextMenu();
+        return;
+      }
+
+      // Close menu immediately
+      closeContextMenu();
+
+      // Delegate to parent for conversation pane handling
+      onAdvisoryAction?.(action, currentSelection);
+    },
+    [closeContextMenu, onAdvisoryAction]
+  );
+
+  return (
+    <div
+      className={`pair-writing-editor${isProcessingQuickAction ? " pair-writing-editor--processing" : ""}`}
+    >
+      {/* Textarea for editing */}
+      <textarea
+        ref={textareaRef}
+        className={`pair-writing-editor__textarea${isProcessingQuickAction ? " pair-writing-editor__textarea--processing" : ""}`}
+        value={content}
+        onChange={handleChange}
+        onContextMenu={handleContextMenu}
+        {...longPressHandlers}
+        spellCheck={false}
+        disabled={isProcessingQuickAction}
+        aria-label="Document editor"
+      />
+
+      {/* Loading indicator for Quick Actions (REQ-F-7) */}
+      {isProcessingQuickAction && (
+        <div className="pair-writing-editor__processing-overlay">
+          <div className="pair-writing-editor__processing-spinner" />
+          <span className="pair-writing-editor__processing-text">
+            Applying changes...
+          </span>
+        </div>
+      )}
+
+      {/* Context Menu for Quick Actions and Advisory Actions */}
+      <ContextMenuComponent
+        isOpen={menuOpen}
+        position={menuPosition}
+        onAction={handleQuickAction}
+        onAdvisoryAction={handleAdvisoryAction}
+        onDismiss={closeContextMenu}
+        mode="pair-writing"
+        hasSnapshot={hasSnapshot}
+      />
+
+      {/* Toast for Quick Action confirmation (REQ-F-6) */}
+      <ToastComponent
+        isVisible={toastVisible}
+        variant={toastVariant}
+        message={toastMessage}
+        onDismiss={() => setToastVisible(false)}
+      />
+    </div>
+  );
+}
diff --git a/frontend/src/components/PairWritingMode.css b/frontend/src/components/PairWritingMode.css
new file mode 100644
index 00000000..ef66183a
--- /dev/null
+++ b/frontend/src/components/PairWritingMode.css
@@ -0,0 +1,277 @@
+/**
+ * PairWritingMode Component Styles
+ *
+ * Split-screen layout with editor and conversation panes.
+ * Desktop-only component (hidden via CSS media query on touch devices).
+ *
+ * @see .sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md TD-6, TD-9
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-10, REQ-F-11
+ */
+
+/* ============================================
+   Main Container
+   ============================================ */
+
+.pair-writing-mode {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  background: var(--glass-bg);
+}
+
+/* ============================================
+   Toolbar Styles (PairWritingToolbar)
+   ============================================ */
+
+.pair-writing-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: var(--spacing-sm) var(--spacing-md);
+  border-bottom: 1px solid var(--glass-border);
+  background: var(--glass-bg-secondary);
+  backdrop-filter: blur(var(--glass-blur));
+  min-height: 48px;
+  gap: var(--spacing-md);
+}
+
+@supports not (backdrop-filter: blur(10px)) {
+  .pair-writing-toolbar {
+    background-color: var(--color-surface);
+  }
+}
+
+.pair-writing-toolbar__left {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-xs);
+  flex: 1;
+  min-width: 0; /* Allow text truncation */
+}
+
+.pair-writing-toolbar__file-path {
+  font-size: var(--text-sm);
+  color: var(--color-text-secondary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.pair-writing-toolbar__unsaved-indicator {
+  font-size: var(--text-lg);
+  font-weight: var(--font-bold);
+  color: var(--color-warning);
+  line-height: 1;
+}
+
+.pair-writing-toolbar__actions {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+  flex-shrink: 0;
+}
+
+/* Toolbar buttons */
+.pair-writing-toolbar__btn {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-xs);
+  padding: var(--spacing-xs) var(--spacing-sm);
+  background: transparent;
+  border: 1px solid var(--glass-border);
+  border-radius: var(--radius-md);
+  color: var(--color-text);
+  font-size: var(--text-sm);
+  cursor: pointer;
+  transition:
+    background-color 0.2s ease,
+    border-color 0.2s ease,
+    box-shadow 0.3s ease,
+    color 0.2s ease;
+}
+
+.pair-writing-toolbar__btn:hover:not(:disabled) {
+  background: var(--color-accent-primary-a10);
+  border-color: var(--color-accent);
+  box-shadow: 0 0 12px var(--color-accent-primary-a15);
+}
+
+.pair-writing-toolbar__btn:focus-visible {
+  outline: 2px solid var(--color-accent);
+  outline-offset: 2px;
+}
+
+.pair-writing-toolbar__btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Snapshot button states */
+.pair-writing-toolbar__btn--snapshot {
+  color: var(--color-text-secondary);
+}
+
+.pair-writing-toolbar__btn--snapshot:hover:not(:disabled) {
+  color: var(--color-text);
+}
+
+.pair-writing-toolbar__btn--has-snapshot {
+  color: var(--color-accent);
+  border-color: var(--color-accent-a30);
+}
+
+.pair-writing-toolbar__btn--has-snapshot:hover:not(:disabled) {
+  background: var(--color-accent-primary-a15);
+}
+
+/* Save button */
+.pair-writing-toolbar__btn--save {
+  background: var(--gradient-primary);
+  color: white;
+  border-color: transparent;
+}
+
+.pair-writing-toolbar__btn--save:hover:not(:disabled) {
+  box-shadow: var(--glow-primary);
+  background: var(--gradient-primary);
+  border-color: transparent;
+}
+
+.pair-writing-toolbar__btn--save:disabled {
+  background: var(--color-bg-tertiary);
+  color: var(--color-text-secondary);
+  opacity: 0.7;
+}
+
+/* Exit button */
+.pair-writing-toolbar__btn--exit {
+  color: var(--color-text-secondary);
+  border-color: transparent;
+}
+
+.pair-writing-toolbar__btn--exit:hover:not(:disabled) {
+  color: var(--color-error);
+  background: var(--color-error-a10);
+  border-color: var(--color-error-a30);
+  box-shadow: none;
+}
+
+/* Icons and labels */
+.pair-writing-toolbar__icon {
+  width: 16px;
+  height: 16px;
+  flex-shrink: 0;
+}
+
+.pair-writing-toolbar__label {
+  display: none;
+}
+
+/* Show labels on larger screens */
+@media (min-width: 900px) {
+  .pair-writing-toolbar__label {
+    display: inline;
+  }
+}
+
+/* Spinner for saving state */
+.pair-writing-toolbar__spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid var(--color-white-a30);
+  border-top-color: white;
+  border-radius: 50%;
+  animation: pair-writing-toolbar-spin 1s linear infinite;
+}
+
+@keyframes pair-writing-toolbar-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* ============================================
+   Split-Screen Content (TD-6)
+   ============================================ */
+
+.pair-writing-mode__content {
+  display: grid;
+  grid-template-columns: 1fr 1fr; /* 50/50 split per REQ-F-11 */
+  gap: 1px;
+  flex: 1;
+  overflow: hidden;
+  background: var(--glass-border); /* Gap color */
+}
+
+.pair-writing-mode__editor-pane,
+.pair-writing-mode__conversation-pane {
+  display: flex;
+  flex-direction: column;
+  background: var(--glass-bg);
+  overflow: hidden;
+}
+
+/* Editor pane needs to contain the MemoryEditor */
+.pair-writing-mode__editor-pane {
+  position: relative;
+}
+
+/* ============================================
+   Conversation Pane (Pair Writing specific)
+   ============================================ */
+
+.pair-writing-conversation {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+}
+
+.pair-writing-conversation__empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  text-align: center;
+  color: var(--color-text-secondary);
+  padding: var(--spacing-lg);
+}
+
+.pair-writing-conversation__empty p {
+  margin: 0;
+  font-size: var(--font-size-base);
+}
+
+.pair-writing-conversation__hint {
+  font-size: var(--font-size-sm);
+  margin-top: var(--spacing-sm) !important;
+  color: var(--color-text-accent-secondary);
+  font-style: italic;
+}
+
+/* ============================================
+   Desktop-Only Visibility (TD-9, REQ-F-10)
+   ============================================ */
+
+/* Hide on touch devices */
+@media (hover: none), (pointer: coarse) {
+  .pair-writing-mode {
+    display: none;
+  }
+}
+
+/* ============================================
+   Responsive Adjustments
+   ============================================ */
+
+/* On narrower screens, adjust toolbar padding */
+@media (max-width: 768px) {
+  .pair-writing-toolbar {
+    padding: var(--spacing-xs) var(--spacing-sm);
+    gap: var(--spacing-sm);
+  }
+
+  .pair-writing-toolbar__btn {
+    padding: var(--spacing-xs);
+  }
+}
diff --git a/frontend/src/components/PairWritingMode.tsx b/frontend/src/components/PairWritingMode.tsx
new file mode 100644
index 00000000..c0796baa
--- /dev/null
+++ b/frontend/src/components/PairWritingMode.tsx
@@ -0,0 +1,241 @@
+/**
+ * PairWritingMode Component
+ *
+ * Split-screen container for desktop pair writing with AI assistance.
+ * Left pane: PairWritingEditor for document editing with Quick Actions
+ * Right pane: Discussion component (same session as Think tab)
+ *
+ * Desktop-only: hidden via CSS media query on touch devices (REQ-F-10).
+ *
+ * The right pane IS the Discussion tab: same conversation history, same session,
+ * same WebSocket connection. Quick Actions and Advisory Actions appear in the
+ * Discussion conversation, and responses stream through the same channel.
+ *
+ * @see .sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md TD-5, TD-6, TD-9
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-10, REQ-F-11, REQ-F-14, REQ-F-30
+ */
+
+import { useState, useCallback, useEffect } from "react";
+import type { ClientMessage, ServerMessage } from "@memory-loop/shared";
+import { useSession } from "../contexts/SessionContext";
+import { usePairWritingState } from "../hooks/usePairWritingState";
+import { PairWritingToolbar } from "./PairWritingToolbar";
+import { PairWritingEditor } from "./PairWritingEditor";
+import { Discussion } from "./Discussion";
+import { ConfirmDialog } from "./ConfirmDialog";
+import type { AdvisoryActionType } from "./EditorContextMenu";
+import type { SelectionContext } from "../hooks/useTextSelection";
+import type { ConnectionStatus } from "../hooks/useWebSocket";
+import "./PairWritingMode.css";
+
+/**
+ * Props for PairWritingMode component.
+ */
+export interface PairWritingModeProps {
+  /** File path being edited (relative to vault content root) */
+  filePath: string;
+  /** Initial file content */
+  content: string;
+  /** Base URL for vault assets (images) */
+  assetBaseUrl: string;
+  /** Called when exiting Pair Writing mode */
+  onExit: () => void;
+  /** Called to save content to disk */
+  onSave: (content: string) => void;
+  /** Function to send WebSocket messages (shared with Discussion) */
+  sendMessage: (message: ClientMessage) => void;
+  /** Last received server message (shared with Discussion) */
+  lastMessage: ServerMessage | null;
+  /** Current WebSocket connection status (shared with Discussion) */
+  connectionStatus: ConnectionStatus;
+  /** Called when Quick Action completes and file should be reloaded */
+  onQuickActionComplete?: (path: string) => void;
+  // Dependency injection for testing (avoids mock.module pollution)
+  /** Editor component to render (defaults to PairWritingEditor) */
+  EditorComponent?: typeof PairWritingEditor;
+  /** Discussion component to render (defaults to Discussion) */
+  DiscussionComponent?: typeof Discussion;
+}
+
+/**
+ * Split-screen Pair Writing Mode for desktop.
+ *
+ * Features:
+ * - 50/50 split layout with editor and Discussion (REQ-F-11)
+ * - Toolbar with Snapshot, Save, Exit buttons (REQ-F-14, REQ-F-23, REQ-F-29)
+ * - Exit confirmation when unsaved manual edits exist (REQ-F-30)
+ * - Hidden on touch devices via CSS media query (REQ-F-10)
+ * - Discussion in right pane is the same session as Think tab
+ *
+ * State management for editor (content, snapshot, unsaved changes) is handled
+ * by usePairWritingState hook. Conversation state is managed by SessionContext
+ * and displayed by the embedded Discussion component.
+ */
+export function PairWritingMode({
+  filePath,
+  content: initialContent,
+  assetBaseUrl: _assetBaseUrl,
+  onExit,
+  onSave,
+  sendMessage,
+  lastMessage,
+  connectionStatus,
+  onQuickActionComplete,
+  EditorComponent = PairWritingEditor,
+  DiscussionComponent = Discussion,
+}: PairWritingModeProps): React.ReactNode {
+  void _assetBaseUrl; // Preserved for interface stability; Discussion handles its own asset resolution
+  const { state, actions } = usePairWritingState();
+  const { addMessage } = useSession();
+  const [showExitConfirm, setShowExitConfirm] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+
+  // Activate pair writing mode on mount (if not already active)
+  useEffect(() => {
+    if (!state.isActive) {
+      actions.activate(initialContent);
+    }
+  }, [state.isActive, actions, initialContent]);
+
+  // Update content when initialContent changes (e.g., after Quick Action reload)
+  useEffect(() => {
+    if (state.isActive && initialContent !== state.content) {
+      // Content was reloaded from disk (e.g., after Quick Action)
+      actions.reloadContent(initialContent);
+    }
+  }, [initialContent, state.isActive, state.content, actions]);
+
+  // Handle snapshot button (REQ-F-23)
+  const handleSnapshot = useCallback(() => {
+    actions.takeSnapshot();
+  }, [actions]);
+
+  // Handle save button (REQ-F-29)
+  const handleSave = useCallback(() => {
+    setIsSaving(true);
+    // Use the onSave prop to save content
+    onSave(state.content);
+    // Save completion is tracked via the parent component
+    // For now, assume save is synchronous from our perspective
+    setIsSaving(false);
+    actions.markSaved();
+  }, [onSave, state.content, actions]);
+
+  // Handle exit button (REQ-F-14, REQ-F-30)
+  const handleExitClick = useCallback(() => {
+    if (state.hasUnsavedChanges) {
+      setShowExitConfirm(true);
+    } else {
+      actions.clearAll();
+      onExit();
+    }
+  }, [state.hasUnsavedChanges, actions, onExit]);
+
+  // Confirm exit with unsaved changes
+  const handleConfirmExit = useCallback(() => {
+    setShowExitConfirm(false);
+    actions.clearAll();
+    onExit();
+  }, [actions, onExit]);
+
+  // Cancel exit
+  const handleCancelExit = useCallback(() => {
+    setShowExitConfirm(false);
+  }, []);
+
+  // Handle content change from editor
+  const handleContentChange = useCallback(
+    (newContent: string) => {
+      actions.setContent(newContent);
+    },
+    [actions]
+  );
+
+  // Handle Quick Action completion (reload content from disk)
+  const handleQuickActionComplete = useCallback(
+    (path: string) => {
+      // The file was updated by Claude's Edit tool
+      // Parent component should reload the file
+      onQuickActionComplete?.(path);
+    },
+    [onQuickActionComplete]
+  );
+
+  // Handle Advisory Action from editor (REQ-F-15)
+  // Adds user message to SessionContext so it appears in the Discussion
+  const handleAdvisoryAction = useCallback(
+    (action: AdvisoryActionType, selection: SelectionContext) => {
+      // Add user message showing what they selected to the shared conversation
+      const userMessage = `[${action.charAt(0).toUpperCase() + action.slice(1)}] "${selection.text}"`;
+      addMessage({ role: "user", content: userMessage });
+
+      // Send advisory action request to backend
+      // Backend routes through existing session, response appears in Discussion
+      sendMessage({
+        type: "advisory_action_request",
+        action,
+        selection: selection.text,
+        contextBefore: selection.contextBefore,
+        contextAfter: selection.contextAfter,
+        filePath,
+        selectionStartLine: selection.startLine,
+        selectionEndLine: selection.endLine,
+        totalLines: selection.totalLines,
+        snapshotSelection: action === "compare" ? state.snapshot ?? undefined : undefined,
+      });
+    },
+    [addMessage, sendMessage, filePath, state.snapshot]
+  );
+
+  return (
+    <div className="pair-writing-mode">
+      {/* Toolbar (REQ-F-14) */}
+      <PairWritingToolbar
+        hasUnsavedChanges={state.hasUnsavedChanges}
+        hasSnapshot={state.snapshot !== null}
+        isSaving={isSaving}
+        onSnapshot={handleSnapshot}
+        onSave={handleSave}
+        onExit={handleExitClick}
+        filePath={filePath}
+      />
+
+      {/* Split-screen content (REQ-F-11, TD-6) */}
+      <div className="pair-writing-mode__content">
+        {/* Left pane: Editor (REQ-F-12) */}
+        <div className="pair-writing-mode__editor-pane">
+          <EditorComponent
+            initialContent={initialContent}
+            filePath={filePath}
+            sendMessage={sendMessage}
+            lastMessage={lastMessage}
+            onContentChange={handleContentChange}
+            onQuickActionComplete={handleQuickActionComplete}
+            onAdvisoryAction={handleAdvisoryAction}
+            hasSnapshot={state.snapshot !== null}
+            snapshotContent={state.snapshot ?? undefined}
+          />
+        </div>
+
+        {/* Right pane: Discussion (same session as Think tab) */}
+        <div className="pair-writing-mode__conversation-pane">
+          <DiscussionComponent
+            sendMessage={sendMessage}
+            connectionStatus={connectionStatus}
+            lastMessage={lastMessage}
+          />
+        </div>
+      </div>
+
+      {/* Exit confirmation dialog (REQ-F-30) */}
+      <ConfirmDialog
+        isOpen={showExitConfirm}
+        title="Unsaved Changes"
+        message="You have unsaved manual edits. Are you sure you want to exit Pair Writing mode? Your changes will be lost."
+        confirmLabel="Exit Without Saving"
+        onConfirm={handleConfirmExit}
+        onCancel={handleCancelExit}
+      />
+    </div>
+  );
+}
diff --git a/frontend/src/components/PairWritingToolbar.tsx b/frontend/src/components/PairWritingToolbar.tsx
new file mode 100644
index 00000000..81710b11
--- /dev/null
+++ b/frontend/src/components/PairWritingToolbar.tsx
@@ -0,0 +1,145 @@
+/**
+ * PairWritingToolbar Component
+ *
+ * Toolbar for Pair Writing Mode with Snapshot, Save, and Exit buttons.
+ *
+ * @see .sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md TD-5, TD-8, TD-11
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-14, REQ-F-23, REQ-F-29, REQ-F-30
+ */
+
+import React from "react";
+import "./PairWritingMode.css";
+
+export interface PairWritingToolbarProps {
+  /** Whether there are unsaved manual edits (triggers exit warning per REQ-F-30) */
+  hasUnsavedChanges: boolean;
+  /** Whether a snapshot currently exists (REQ-F-24) */
+  hasSnapshot: boolean;
+  /** Whether save is in progress */
+  isSaving?: boolean;
+  /** Called when user clicks Snapshot button (REQ-F-23) */
+  onSnapshot: () => void;
+  /** Called when user clicks Save button (REQ-F-29) */
+  onSave: () => void;
+  /** Called when user clicks Exit button (REQ-F-14) */
+  onExit: () => void;
+  /** Current file path being edited (displayed in toolbar) */
+  filePath?: string;
+}
+
+/**
+ * Toolbar for Pair Writing Mode.
+ *
+ * Features:
+ * - Snapshot button to capture current document state (REQ-F-23)
+ * - Save button to persist manual edits (REQ-F-29)
+ * - Exit button with warning for unsaved changes (REQ-F-14, REQ-F-30)
+ *
+ * Note: Exit confirmation dialog is handled by the parent PairWritingMode component.
+ */
+export function PairWritingToolbar({
+  hasUnsavedChanges,
+  hasSnapshot,
+  isSaving = false,
+  onSnapshot,
+  onSave,
+  onExit,
+  filePath,
+}: PairWritingToolbarProps): React.ReactNode {
+  return (
+    <div className="pair-writing-toolbar" role="toolbar" aria-label="Pair Writing toolbar">
+      {/* Left section: file info */}
+      <div className="pair-writing-toolbar__left">
+        {filePath && (
+          <span className="pair-writing-toolbar__file-path" title={filePath}>
+            {filePath}
+          </span>
+        )}
+        {hasUnsavedChanges && (
+          <span className="pair-writing-toolbar__unsaved-indicator" aria-label="Unsaved changes">
+            *
+          </span>
+        )}
+      </div>
+
+      {/* Right section: action buttons */}
+      <div className="pair-writing-toolbar__actions">
+        {/* Snapshot button (REQ-F-23) */}
+        <button
+          type="button"
+          className={`pair-writing-toolbar__btn pair-writing-toolbar__btn--snapshot${hasSnapshot ? " pair-writing-toolbar__btn--has-snapshot" : ""}`}
+          onClick={onSnapshot}
+          aria-pressed={hasSnapshot}
+          title={hasSnapshot ? "Update snapshot (replaces previous)" : "Take snapshot for comparison"}
+        >
+          <svg
+            className="pair-writing-toolbar__icon"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+            aria-hidden="true"
+          >
+            <path d="M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z" />
+            <circle cx="12" cy="13" r="4" />
+          </svg>
+          <span className="pair-writing-toolbar__label">Snapshot</span>
+        </button>
+
+        {/* Save button (REQ-F-29) */}
+        <button
+          type="button"
+          className="pair-writing-toolbar__btn pair-writing-toolbar__btn--save"
+          onClick={onSave}
+          disabled={!hasUnsavedChanges || isSaving}
+          title={hasUnsavedChanges ? "Save changes to vault" : "No unsaved changes"}
+        >
+          {isSaving ? (
+            <div className="pair-writing-toolbar__spinner" aria-hidden="true" />
+          ) : (
+            <svg
+              className="pair-writing-toolbar__icon"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              strokeWidth="2"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+              aria-hidden="true"
+            >
+              <path d="M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z" />
+              <polyline points="17 21 17 13 7 13 7 21" />
+              <polyline points="7 3 7 8 15 8" />
+            </svg>
+          )}
+          <span className="pair-writing-toolbar__label">{isSaving ? "Saving..." : "Save"}</span>
+        </button>
+
+        {/* Exit button (REQ-F-14) */}
+        <button
+          type="button"
+          className="pair-writing-toolbar__btn pair-writing-toolbar__btn--exit"
+          onClick={onExit}
+          title="Exit Pair Writing mode"
+        >
+          <svg
+            className="pair-writing-toolbar__icon"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+            aria-hidden="true"
+          >
+            <path d="M18 6L6 18" />
+            <path d="M6 6l12 12" />
+          </svg>
+          <span className="pair-writing-toolbar__label">Exit</span>
+        </button>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/components/__tests__/BrowseMode.pairWriting.test.tsx b/frontend/src/components/__tests__/BrowseMode.pairWriting.test.tsx
new file mode 100644
index 00000000..7f573285
--- /dev/null
+++ b/frontend/src/components/__tests__/BrowseMode.pairWriting.test.tsx
@@ -0,0 +1,129 @@
+/**
+ * Tests for BrowseMode Pair Writing integration (TASK-012)
+ *
+ * Tests the "Pair Writing" button visibility and mode switching.
+ *
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-9, REQ-F-10
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { render, screen, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { BrowseMode } from "../BrowseMode";
+import { SessionProvider } from "../../contexts/SessionContext";
+import type { ClientMessage } from "@memory-loop/shared";
+
+// Track WebSocket instances and messages
+let wsInstances: MockWebSocket[] = [];
+let sentMessages: ClientMessage[] = [];
+
+// Mock WebSocket
+class MockWebSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSED = 3;
+
+  readyState = MockWebSocket.OPEN;
+  onopen: ((e: Event) => void) | null = null;
+  onclose: ((e: Event) => void) | null = null;
+  onmessage: ((e: MessageEvent) => void) | null = null;
+  onerror: ((e: Event) => void) | null = null;
+
+  constructor(public url: string) {
+    wsInstances.push(this);
+    setTimeout(() => {
+      if (this.onopen) this.onopen(new Event("open"));
+    }, 0);
+  }
+
+  send(data: string): void {
+    sentMessages.push(JSON.parse(data) as ClientMessage);
+  }
+
+  close(): void {
+    this.readyState = MockWebSocket.CLOSED;
+  }
+}
+
+const originalWebSocket = globalThis.WebSocket;
+
+function TestWrapper({ children }: { children: ReactNode }) {
+  return <SessionProvider>{children}</SessionProvider>;
+}
+
+beforeEach(() => {
+  wsInstances = [];
+  sentMessages = [];
+  localStorage.clear();
+  // @ts-expect-error - mocking WebSocket
+  globalThis.WebSocket = MockWebSocket;
+});
+
+afterEach(() => {
+  cleanup();
+  globalThis.WebSocket = originalWebSocket;
+});
+
+describe("BrowseMode Pair Writing integration", () => {
+  describe("component structure", () => {
+    it("renders BrowseMode with viewer pane", () => {
+      const { container } = render(<BrowseMode />, { wrapper: TestWrapper });
+
+      // The viewer pane should exist
+      const viewerPane = container.querySelector(".browse-mode__viewer-pane");
+      expect(viewerPane).not.toBeNull();
+    });
+
+    it("renders MarkdownViewer in viewer pane when no file selected", () => {
+      render(<BrowseMode />, { wrapper: TestWrapper });
+
+      // MarkdownViewer shows empty state when no file is selected
+      expect(screen.getByText("Select a file to view its content")).toBeDefined();
+    });
+  });
+
+  describe("Pair Writing button visibility (REQ-F-9)", () => {
+    it("does not show Pair Writing button when no file is selected", () => {
+      render(<BrowseMode />, { wrapper: TestWrapper });
+
+      // When no file is selected, Pair Writing button should not be visible
+      // (it only appears when viewing a markdown file)
+      const pairWritingBtn = screen.queryByRole("button", { name: /pair writing/i });
+      expect(pairWritingBtn).toBeNull();
+    });
+  });
+
+  describe("integration with MarkdownViewer", () => {
+    it("MarkdownViewer receives onEnterPairWriting prop", () => {
+      // This test verifies the integration exists at the component level
+      // The actual callback behavior is tested via the MarkdownViewer tests
+      render(<BrowseMode />, { wrapper: TestWrapper });
+
+      // MarkdownViewer should render its empty state
+      expect(screen.getByText("Select a file to view its content")).toBeDefined();
+    });
+  });
+});
+
+describe("PairWritingMode component", () => {
+  // Note: These tests use the PairWritingMode component directly
+  // rather than through BrowseMode to avoid complex WebSocket mocking
+
+  describe("rendering", () => {
+    it("PairWritingMode is importable and has correct interface", async () => {
+      // Dynamic import to verify module structure
+      const module = await import("../PairWritingMode");
+      expect(typeof module.PairWritingMode).toBe("function");
+    });
+  });
+});
+
+describe("PairWritingToolbar component", () => {
+  describe("rendering", () => {
+    it("PairWritingToolbar is importable and has correct interface", async () => {
+      // Dynamic import to verify module structure
+      const module = await import("../PairWritingToolbar");
+      expect(typeof module.PairWritingToolbar).toBe("function");
+    });
+  });
+});
diff --git a/frontend/src/components/__tests__/ConversationPane.test.tsx b/frontend/src/components/__tests__/ConversationPane.test.tsx
new file mode 100644
index 00000000..b1c334fa
--- /dev/null
+++ b/frontend/src/components/__tests__/ConversationPane.test.tsx
@@ -0,0 +1,281 @@
+/**
+ * Tests for ConversationPane component
+ *
+ * Tests message display, auto-scroll behavior, and empty state rendering.
+ * ConversationPane is extracted from Discussion.tsx per TD-7 for reuse in PairWritingMode.
+ */
+
+import { describe, it, expect, afterEach } from "bun:test";
+import { render, cleanup } from "@testing-library/react";
+import React from "react";
+import { ConversationPane, DiscussionEmptyState } from "../ConversationPane";
+import type { ConversationMessage } from "../../contexts/SessionContext";
+
+afterEach(() => {
+  cleanup();
+});
+
+function createMessage(
+  overrides: Partial<ConversationMessage> = {}
+): ConversationMessage {
+  return {
+    id: `msg-${Math.random().toString(36).slice(2)}`,
+    role: "assistant",
+    content: "Test content",
+    timestamp: new Date(),
+    isStreaming: false,
+    ...overrides,
+  };
+}
+
+describe("ConversationPane", () => {
+  describe("rendering", () => {
+    it("renders message list with proper role attribute", () => {
+      const messages = [
+        createMessage({ id: "1", content: "Hello" }),
+        createMessage({ id: "2", content: "World" }),
+      ];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      const messageList = container.querySelector('[role="list"]');
+      expect(messageList).not.toBeNull();
+    });
+
+    it("renders messages using MessageBubble component", () => {
+      const messages = [
+        createMessage({ id: "1", role: "user", content: "User message" }),
+        createMessage({ id: "2", role: "assistant", content: "Assistant message" }),
+      ];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      // MessageBubble renders with message-bubble class
+      const bubbles = container.querySelectorAll(".message-bubble");
+      expect(bubbles.length).toBe(2);
+
+      // Check user and assistant classes
+      expect(
+        container.querySelector(".message-bubble--user")
+      ).not.toBeNull();
+      expect(
+        container.querySelector(".message-bubble--assistant")
+      ).not.toBeNull();
+    });
+
+    it("passes vaultId to MessageBubble for image display", () => {
+      const messages = [
+        createMessage({
+          id: "1",
+          role: "assistant",
+          content: "Check this: ![[05_Attachments/image.png]]",
+        }),
+      ];
+
+      const { container } = render(
+        <ConversationPane messages={messages} vaultId="test-vault" />
+      );
+
+      // MessageBubble with vaultId transforms image paths to img elements
+      const img = container.querySelector("img:not(.message-bubble__hr)");
+      expect(img).not.toBeNull();
+      expect(img?.getAttribute("src")).toBe(
+        "/vault/test-vault/assets/05_Attachments/image.png"
+      );
+    });
+
+    it("applies custom className when provided", () => {
+      const { container } = render(
+        <ConversationPane messages={[]} className="custom-class" />
+      );
+
+      const pane = container.querySelector(".conversation-pane");
+      expect(pane?.classList.contains("custom-class")).toBe(true);
+    });
+
+    it("uses custom ariaLabel when provided", () => {
+      const { container } = render(
+        <ConversationPane messages={[]} ariaLabel="Custom conversation" />
+      );
+
+      const pane = container.querySelector('[aria-label="Custom conversation"]');
+      expect(pane).not.toBeNull();
+    });
+
+    it("uses default ariaLabel when not provided", () => {
+      const { container } = render(<ConversationPane messages={[]} />);
+
+      const pane = container.querySelector('[aria-label="Conversation"]');
+      expect(pane).not.toBeNull();
+    });
+  });
+
+  describe("empty state", () => {
+    it("renders default DiscussionEmptyState when no messages and no custom emptyState", () => {
+      const { container } = render(<ConversationPane messages={[]} />);
+
+      // Default empty state shows "Start a conversation" text
+      expect(container.textContent).toContain("Start a conversation");
+    });
+
+    it("renders custom emptyState when provided and no messages", () => {
+      const customEmpty = <div data-testid="custom-empty">Custom empty state</div>;
+
+      const { container } = render(
+        <ConversationPane messages={[]} emptyState={customEmpty} />
+      );
+
+      expect(
+        container.querySelector('[data-testid="custom-empty"]')
+      ).not.toBeNull();
+      expect(container.textContent).toContain("Custom empty state");
+    });
+
+    it("does not render empty state when messages exist", () => {
+      const messages = [createMessage({ id: "1", content: "Hello" })];
+
+      const { container } = render(
+        <ConversationPane messages={messages} emptyState={<div data-testid="custom-empty" />} />
+      );
+
+      expect(container.querySelector('[data-testid="custom-empty"]')).toBeNull();
+    });
+  });
+
+  describe("DiscussionEmptyState", () => {
+    it("renders with expected text content", () => {
+      const { container } = render(<DiscussionEmptyState />);
+
+      expect(container.textContent).toContain("Start a conversation about your vault");
+      expect(container.textContent).toContain("slash commands");
+    });
+
+    it("has proper CSS class for styling", () => {
+      const { container } = render(<DiscussionEmptyState />);
+
+      expect(
+        container.querySelector(".conversation-pane__empty")
+      ).not.toBeNull();
+    });
+  });
+
+  describe("streaming indicator", () => {
+    it("renders streaming indicator when message is streaming", () => {
+      const messages = [
+        createMessage({
+          id: "1",
+          role: "assistant",
+          content: "Streaming...",
+          isStreaming: true,
+        }),
+      ];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      // Streaming indicator is an img with alt="Typing"
+      const cursor = container.querySelector('img[alt="Typing"]');
+      expect(cursor).not.toBeNull();
+    });
+
+    it("does not render streaming indicator for completed messages", () => {
+      const messages = [
+        createMessage({
+          id: "1",
+          role: "assistant",
+          content: "Complete message",
+          isStreaming: false,
+        }),
+      ];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      const cursor = container.querySelector('img[alt="Typing"]');
+      expect(cursor).toBeNull();
+    });
+  });
+
+  describe("scroll behavior", () => {
+    it("includes scroll anchor element at end", () => {
+      const messages = [createMessage({ id: "1", content: "Message" })];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      // The scroll anchor is a div with aria-hidden="true" at the end
+      const anchor = container.querySelector('[aria-hidden="true"]');
+      expect(anchor).not.toBeNull();
+    });
+  });
+
+  describe("multiple messages", () => {
+    it("renders messages in order", () => {
+      const messages = [
+        createMessage({ id: "1", role: "user", content: "First message" }),
+        createMessage({ id: "2", role: "assistant", content: "Second message" }),
+        createMessage({ id: "3", role: "user", content: "Third message" }),
+      ];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      const textContent = container.textContent ?? "";
+      const firstIndex = textContent.indexOf("First message");
+      const secondIndex = textContent.indexOf("Second message");
+      const thirdIndex = textContent.indexOf("Third message");
+
+      expect(firstIndex).toBeLessThan(secondIndex);
+      expect(secondIndex).toBeLessThan(thirdIndex);
+    });
+
+    it("uses message id as key for stable rendering", () => {
+      const messages = [
+        createMessage({ id: "stable-id-1", content: "Message 1" }),
+        createMessage({ id: "stable-id-2", content: "Message 2" }),
+      ];
+
+      const { rerender, container } = render(
+        <ConversationPane messages={messages} />
+      );
+
+      // Get initial render count
+      const initialBubbles = container.querySelectorAll(".message-bubble");
+      expect(initialBubbles.length).toBe(2);
+
+      // Add a new message
+      const updatedMessages = [
+        ...messages,
+        createMessage({ id: "stable-id-3", content: "Message 3" }),
+      ];
+
+      rerender(<ConversationPane messages={updatedMessages} />);
+
+      const updatedBubbles = container.querySelectorAll(".message-bubble");
+      expect(updatedBubbles.length).toBe(3);
+    });
+  });
+
+  describe("tool invocations", () => {
+    it("renders tool invocations in assistant messages", () => {
+      const messages = [
+        createMessage({
+          id: "1",
+          role: "assistant",
+          content: "Using a tool...",
+          toolInvocations: [
+            {
+              toolUseId: "tool-1",
+              toolName: "Read",
+              input: { path: "/test.txt" },
+              output: "file content",
+              status: "complete" as const,
+            },
+          ],
+        }),
+      ];
+
+      const { container } = render(<ConversationPane messages={messages} />);
+
+      // Tool display component should render
+      const toolDisplay = container.querySelector(".message-bubble__tools");
+      expect(toolDisplay).not.toBeNull();
+    });
+  });
+});
diff --git a/frontend/src/components/__tests__/EditorContextMenu.test.tsx b/frontend/src/components/__tests__/EditorContextMenu.test.tsx
new file mode 100644
index 00000000..79787f2e
--- /dev/null
+++ b/frontend/src/components/__tests__/EditorContextMenu.test.tsx
@@ -0,0 +1,382 @@
+/**
+ * EditorContextMenu Component Tests
+ *
+ * Tests rendering, keyboard navigation, accessibility, and user interactions.
+ */
+
+import { describe, it, expect, afterEach, mock } from "bun:test";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import {
+  EditorContextMenu,
+  getMenuPositionFromEvent,
+  type QuickActionType,
+} from "../EditorContextMenu";
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("EditorContextMenu", () => {
+  const defaultProps = {
+    isOpen: true,
+    position: { x: 100, y: 100 },
+    onAction: mock(() => {}),
+    onDismiss: mock(() => {}),
+  };
+
+  describe("rendering", () => {
+    it("renders nothing when isOpen is false", () => {
+      render(<EditorContextMenu {...defaultProps} isOpen={false} />);
+
+      expect(screen.queryByRole("menu")).toBeNull();
+    });
+
+    it("renders nothing when position is null", () => {
+      render(<EditorContextMenu {...defaultProps} position={null} />);
+
+      expect(screen.queryByRole("menu")).toBeNull();
+    });
+
+    it("renders menu when isOpen is true and position is provided", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      expect(screen.getByRole("menu")).toBeDefined();
+    });
+
+    it("renders all four Quick Actions", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      expect(screen.getByText("Tighten")).toBeDefined();
+      expect(screen.getByText("Embellish")).toBeDefined();
+      expect(screen.getByText("Correct")).toBeDefined();
+      expect(screen.getByText("Polish")).toBeDefined();
+    });
+
+    it("renders descriptions for each action", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      expect(screen.getByText("Make more concise")).toBeDefined();
+      expect(screen.getByText("Add detail and nuance")).toBeDefined();
+      expect(screen.getByText("Fix typos and grammar")).toBeDefined();
+      expect(screen.getByText("Correct and improve prose")).toBeDefined();
+    });
+
+    it("positions menu at specified coordinates", () => {
+      render(
+        <EditorContextMenu {...defaultProps} position={{ x: 200, y: 300 }} />
+      );
+
+      const menu = screen.getByRole("menu");
+      const style = menu.style;
+
+      // Menu should be positioned at or near the specified coordinates
+      // (may be adjusted for viewport bounds)
+      expect(parseInt(style.left)).toBeGreaterThanOrEqual(0);
+      expect(parseInt(style.top)).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("accessibility", () => {
+    it("has proper menu role", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      expect(menu).toBeDefined();
+      expect(menu.getAttribute("aria-label")).toBe("Quick Actions");
+    });
+
+    it("has menuitem role on all items", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menuItems = screen.getAllByRole("menuitem");
+      expect(menuItems.length).toBe(4);
+    });
+
+    it("menu items have aria-describedby linking to descriptions", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menuItems = screen.getAllByRole("menuitem");
+      menuItems.forEach((item) => {
+        const describedBy = item.getAttribute("aria-describedby");
+        expect(describedBy).toBeDefined();
+        expect(describedBy?.startsWith("action-desc-")).toBe(true);
+      });
+    });
+
+    it("only one menu item has tabIndex 0", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menuItems = screen.getAllByRole("menuitem");
+      const focusableItems = menuItems.filter(
+        (item) => item.getAttribute("tabindex") === "0"
+      );
+      expect(focusableItems.length).toBe(1);
+    });
+  });
+
+  describe("keyboard navigation", () => {
+    it("ArrowDown moves focus to next item", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      const menuItems = screen.getAllByRole("menuitem");
+
+      // First item should be focused initially
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+
+      // Press ArrowDown
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+
+      // Second item should now have tabIndex 0
+      expect(menuItems[1].getAttribute("tabindex")).toBe("0");
+    });
+
+    it("ArrowUp moves focus to previous item", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      const menuItems = screen.getAllByRole("menuitem");
+
+      // Move to second item first
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      expect(menuItems[1].getAttribute("tabindex")).toBe("0");
+
+      // Press ArrowUp
+      fireEvent.keyDown(menu, { key: "ArrowUp" });
+
+      // First item should be focused again
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+    });
+
+    it("ArrowDown wraps from last to first item", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      const menuItems = screen.getAllByRole("menuitem");
+
+      // Navigate to last item (4 presses from first)
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+
+      expect(menuItems[3].getAttribute("tabindex")).toBe("0");
+
+      // Press ArrowDown again - should wrap to first
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+    });
+
+    it("ArrowUp wraps from first to last item", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      const menuItems = screen.getAllByRole("menuitem");
+
+      // First item is focused
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+
+      // Press ArrowUp - should wrap to last
+      fireEvent.keyDown(menu, { key: "ArrowUp" });
+      expect(menuItems[3].getAttribute("tabindex")).toBe("0");
+    });
+
+    it("Enter activates focused item", () => {
+      const onAction = mock(() => {});
+      render(<EditorContextMenu {...defaultProps} onAction={onAction} />);
+
+      const menu = screen.getByRole("menu");
+
+      // First item (Tighten) is focused, press Enter
+      fireEvent.keyDown(menu, { key: "Enter" });
+
+      expect(onAction).toHaveBeenCalledTimes(1);
+      expect(onAction).toHaveBeenCalledWith("tighten");
+    });
+
+    it("Space activates focused item", () => {
+      const onAction = mock(() => {});
+      render(<EditorContextMenu {...defaultProps} onAction={onAction} />);
+
+      const menu = screen.getByRole("menu");
+
+      // Navigate to second item and press Space
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      fireEvent.keyDown(menu, { key: " " });
+
+      expect(onAction).toHaveBeenCalledTimes(1);
+      expect(onAction).toHaveBeenCalledWith("embellish");
+    });
+
+    it("Home moves focus to first item", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      const menuItems = screen.getAllByRole("menuitem");
+
+      // Navigate to third item
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      expect(menuItems[2].getAttribute("tabindex")).toBe("0");
+
+      // Press Home
+      fireEvent.keyDown(menu, { key: "Home" });
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+    });
+
+    it("End moves focus to last item", () => {
+      render(<EditorContextMenu {...defaultProps} />);
+
+      const menu = screen.getByRole("menu");
+      const menuItems = screen.getAllByRole("menuitem");
+
+      // First item is focused
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+
+      // Press End
+      fireEvent.keyDown(menu, { key: "End" });
+      expect(menuItems[3].getAttribute("tabindex")).toBe("0");
+    });
+
+    it("Escape calls onDismiss", () => {
+      const onDismiss = mock(() => {});
+      render(<EditorContextMenu {...defaultProps} onDismiss={onDismiss} />);
+
+      // Escape handler is on document
+      fireEvent.keyDown(document, { key: "Escape" });
+
+      expect(onDismiss).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("user interactions", () => {
+    it("clicking a menu item calls onAction with correct action type", () => {
+      const onAction = mock(() => {});
+      render(<EditorContextMenu {...defaultProps} onAction={onAction} />);
+
+      fireEvent.click(screen.getByText("Correct"));
+
+      expect(onAction).toHaveBeenCalledTimes(1);
+      expect(onAction).toHaveBeenCalledWith("correct");
+    });
+
+    it("clicking outside the menu calls onDismiss", () => {
+      const onDismiss = mock(() => {});
+      render(<EditorContextMenu {...defaultProps} onDismiss={onDismiss} />);
+
+      // Click outside (on document body)
+      fireEvent.mouseDown(document.body);
+
+      expect(onDismiss).toHaveBeenCalledTimes(1);
+    });
+
+    it("clicking inside the menu does not call onDismiss", () => {
+      const onDismiss = mock(() => {});
+      render(<EditorContextMenu {...defaultProps} onDismiss={onDismiss} />);
+
+      const menu = screen.getByRole("menu");
+      fireEvent.mouseDown(menu);
+
+      expect(onDismiss).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("focus management", () => {
+    it("resets focus to first item when menu reopens", () => {
+      const { rerender } = render(
+        <EditorContextMenu {...defaultProps} isOpen={true} />
+      );
+
+      const menu = screen.getByRole("menu");
+
+      // Navigate to third item
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+      fireEvent.keyDown(menu, { key: "ArrowDown" });
+
+      // Close and reopen
+      rerender(<EditorContextMenu {...defaultProps} isOpen={false} />);
+      rerender(<EditorContextMenu {...defaultProps} isOpen={true} />);
+
+      // First item should be focused again
+      const menuItems = screen.getAllByRole("menuitem");
+      expect(menuItems[0].getAttribute("tabindex")).toBe("0");
+    });
+  });
+});
+
+describe("getMenuPositionFromEvent", () => {
+  it("extracts position from mouse event", () => {
+    const event = {
+      clientX: 150,
+      clientY: 250,
+    } as React.MouseEvent;
+
+    const position = getMenuPositionFromEvent(event);
+
+    expect(position.x).toBe(150);
+    expect(position.y).toBe(250);
+  });
+
+  it("extracts position from touch event with touches", () => {
+    const event = {
+      touches: [{ clientX: 100, clientY: 200 }],
+      changedTouches: [],
+    } as unknown as React.TouchEvent;
+
+    const position = getMenuPositionFromEvent(event);
+
+    expect(position.x).toBe(100);
+    expect(position.y).toBe(200);
+  });
+
+  it("extracts position from touch event with changedTouches", () => {
+    const event = {
+      touches: [],
+      changedTouches: [{ clientX: 120, clientY: 220 }],
+    } as unknown as React.TouchEvent;
+
+    const position = getMenuPositionFromEvent(event);
+
+    expect(position.x).toBe(120);
+    expect(position.y).toBe(220);
+  });
+
+  it("returns 0,0 for touch event with no touches", () => {
+    const event = {
+      touches: [],
+      changedTouches: [],
+    } as unknown as React.TouchEvent;
+
+    const position = getMenuPositionFromEvent(event);
+
+    expect(position.x).toBe(0);
+    expect(position.y).toBe(0);
+  });
+});
+
+describe("Quick Action types", () => {
+  it("onAction receives correct action type for each item", () => {
+    const actionMap: Record<string, QuickActionType> = {
+      Tighten: "tighten",
+      Embellish: "embellish",
+      Correct: "correct",
+      Polish: "polish",
+    };
+
+    const baseProps = {
+      isOpen: true,
+      position: { x: 100, y: 100 },
+      onDismiss: mock(() => {}),
+    };
+
+    for (const [label, expectedAction] of Object.entries(actionMap)) {
+      const onAction = mock(() => {});
+      render(<EditorContextMenu {...baseProps} onAction={onAction} />);
+
+      fireEvent.click(screen.getByText(label));
+
+      expect(onAction).toHaveBeenCalledWith(expectedAction);
+
+      cleanup();
+    }
+  });
+});
diff --git a/frontend/src/components/__tests__/PairWritingEditor.test.tsx b/frontend/src/components/__tests__/PairWritingEditor.test.tsx
new file mode 100644
index 00000000..d9863e64
--- /dev/null
+++ b/frontend/src/components/__tests__/PairWritingEditor.test.tsx
@@ -0,0 +1,798 @@
+/**
+ * Tests for PairWritingEditor component
+ *
+ * Tests cover:
+ * - Initial rendering with props
+ * - Content state management
+ * - Context menu interactions (right-click, long-press)
+ * - Quick Action flow (send message, processing state, response handling)
+ * - Advisory Action delegation
+ * - Toast notifications
+ * - Error handling
+ *
+ * Uses dependency injection for ContextMenuComponent and ToastComponent to avoid
+ * mock.module pollution between test files.
+ *
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-4, REQ-F-6, REQ-F-7, REQ-F-8, REQ-F-15
+ */
+
+import { describe, it, expect, beforeEach, afterEach, mock, spyOn } from "bun:test";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import type { ServerMessage, ClientMessage } from "@memory-loop/shared";
+import { PairWritingEditor } from "../PairWritingEditor";
+import type {
+  EditorContextMenuProps,
+  QuickActionType,
+  AdvisoryActionType,
+} from "../EditorContextMenu";
+import type { ToastProps } from "../Toast";
+
+// =============================================================================
+// Mock Components - Injected via props (no mock.module)
+// =============================================================================
+
+// Track captured callbacks from MockContextMenu
+let capturedOnAction: ((action: QuickActionType) => void) | null = null;
+let capturedOnAdvisoryAction: ((action: AdvisoryActionType) => void) | null = null;
+
+/**
+ * Mock context menu component injected via props.
+ * Matches EditorContextMenuProps signature for type compatibility.
+ */
+function MockContextMenu({
+  isOpen,
+  onAction,
+  onAdvisoryAction,
+  onDismiss,
+  hasSnapshot,
+}: EditorContextMenuProps) {
+  capturedOnAction = onAction;
+  capturedOnAdvisoryAction = onAdvisoryAction ?? null;
+  return isOpen ? (
+    <div data-testid="context-menu" data-has-snapshot={hasSnapshot}>
+      <button data-testid="action-tighten" onClick={() => onAction("tighten")}>Tighten</button>
+      <button data-testid="action-embellish" onClick={() => onAction("embellish")}>Embellish</button>
+      <button data-testid="advisory-validate" onClick={() => onAdvisoryAction?.("validate")}>Validate</button>
+      <button data-testid="menu-dismiss" onClick={onDismiss}>Dismiss</button>
+    </div>
+  ) : null;
+}
+
+/**
+ * Mock toast component injected via props.
+ * Matches ToastProps signature for type compatibility.
+ */
+function MockToast({ isVisible, message, variant }: ToastProps) {
+  return isVisible ? (
+    <div data-testid="toast" data-variant={variant}>
+      {message}
+    </div>
+  ) : null;
+}
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+function createDefaultProps() {
+  return {
+    initialContent: "# Test Document\n\nThis is test content.\n\nMore content here.",
+    filePath: "notes/test-file.md",
+    sendMessage: mock<(message: ClientMessage) => void>(() => {}),
+    lastMessage: null as ServerMessage | null,
+    onContentChange: mock<(content: string) => void>(() => {}),
+    onQuickActionComplete: mock<(path: string) => void>(() => {}),
+    onAdvisoryAction: mock(() => {}),
+    hasSnapshot: false,
+    // Inject mock components to avoid mock.module pollution
+    ContextMenuComponent: MockContextMenu,
+    ToastComponent: MockToast,
+  };
+}
+
+/**
+ * Gets the textarea element and casts to correct type.
+ * getByRole returns HTMLElement but we know it's a textarea.
+ */
+function getTextarea(): HTMLTextAreaElement {
+  return screen.getByRole("textbox");
+}
+
+/**
+ * Helper to simulate text selection in the textarea.
+ * Sets selectionStart/End and dispatches a select event.
+ */
+function simulateTextSelection(
+  textarea: HTMLTextAreaElement,
+  start: number,
+  end: number
+) {
+  textarea.selectionStart = start;
+  textarea.selectionEnd = end;
+  fireEvent.select(textarea);
+}
+
+beforeEach(() => {
+  capturedOnAction = null;
+  capturedOnAdvisoryAction = null;
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+// =============================================================================
+// Initial Rendering Tests
+// =============================================================================
+
+describe("PairWritingEditor - rendering", () => {
+  it("renders with initial content", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = getTextarea();
+    expect(textarea).toBeDefined();
+    expect(textarea.value).toBe(props.initialContent);
+  });
+
+  it("renders textarea with correct aria-label", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = screen.getByLabelText("Document editor");
+    expect(textarea).toBeDefined();
+  });
+
+  it("does not render Toast initially", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    expect(screen.queryByTestId("toast")).toBeNull();
+  });
+
+  it("does not render context menu initially", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    expect(screen.queryByTestId("context-menu")).toBeNull();
+  });
+
+  it("passes hasSnapshot to EditorContextMenu", () => {
+    const props = createDefaultProps();
+    props.hasSnapshot = true;
+
+    render(<PairWritingEditor {...props} />);
+
+    // Select text to enable context menu
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 0, 15); // Select "# Test Document"
+
+    // Trigger context menu
+    fireEvent.contextMenu(textarea);
+
+    const menu = screen.getByTestId("context-menu");
+    expect(menu.getAttribute("data-has-snapshot")).toBe("true");
+  });
+});
+
+// =============================================================================
+// Content Management Tests
+// =============================================================================
+
+describe("PairWritingEditor - content management", () => {
+  it("updates content on textarea change", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = getTextarea();
+    fireEvent.change(textarea, { target: { value: "New content" } });
+
+    expect(textarea.value).toBe("New content");
+  });
+
+  it("calls onContentChange when content changes", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = getTextarea();
+    fireEvent.change(textarea, { target: { value: "Updated content" } });
+
+    expect(props.onContentChange).toHaveBeenCalledWith("Updated content");
+  });
+
+  it("updates content when initialContent prop changes", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Verify initial content
+    let textarea = getTextarea();
+    expect(textarea.value).toBe(props.initialContent);
+
+    // Rerender with new initialContent
+    rerender(<PairWritingEditor {...props} initialContent="Reloaded content" />);
+
+    textarea = getTextarea();
+    expect(textarea.value).toBe("Reloaded content");
+  });
+});
+
+// =============================================================================
+// Context Menu Tests
+// =============================================================================
+
+describe("PairWritingEditor - context menu", () => {
+  it("opens context menu on right-click when text is selected", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = getTextarea();
+
+    // Select some text first
+    simulateTextSelection(textarea, 0, 15); // Select "# Test Document"
+
+    // Then right-click
+    fireEvent.contextMenu(textarea);
+
+    expect(screen.getByTestId("context-menu")).toBeDefined();
+  });
+
+  it("does not open context menu when no selection", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = getTextarea();
+
+    // No selection (cursor only)
+    simulateTextSelection(textarea, 5, 5);
+
+    fireEvent.contextMenu(textarea);
+
+    expect(screen.queryByTestId("context-menu")).toBeNull();
+  });
+
+  it("closes context menu when dismissed", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 0, 15);
+    fireEvent.contextMenu(textarea);
+    expect(screen.getByTestId("context-menu")).toBeDefined();
+
+    // Dismiss menu
+    fireEvent.click(screen.getByTestId("menu-dismiss"));
+    expect(screen.queryByTestId("context-menu")).toBeNull();
+  });
+
+  it("prevents default context menu behavior when selection exists", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 0, 15);
+
+    const event = new MouseEvent("contextmenu", { bubbles: true, cancelable: true });
+    const preventDefaultSpy = spyOn(event, "preventDefault");
+
+    textarea.dispatchEvent(event);
+
+    expect(preventDefaultSpy).toHaveBeenCalled();
+  });
+});
+
+// =============================================================================
+// Quick Action Flow Tests (REQ-F-4, REQ-F-7, REQ-F-8)
+// =============================================================================
+
+describe("PairWritingEditor - Quick Action flow", () => {
+  it("sends quick_action_request when Quick Action selected (REQ-F-4)", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu and trigger action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 17, 37); // Select "This is test content"
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    expect(props.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "quick_action_request",
+        action: "tighten",
+        selection: "This is test content",
+        filePath: "notes/test-file.md",
+      })
+    );
+  });
+
+  it("shows processing state during Quick Action (REQ-F-7)", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Check processing state
+    expect(screen.getByText("Applying changes...")).toBeDefined();
+    expect(document.querySelector(".pair-writing-editor--processing")).not.toBeNull();
+  });
+
+  it("disables textarea during processing", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    expect(textarea.disabled).toBe(true);
+  });
+
+  it("closes context menu after Quick Action selection", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    expect(screen.getByTestId("context-menu")).toBeDefined();
+
+    // Select action
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Menu should be closed
+    expect(screen.queryByTestId("context-menu")).toBeNull();
+  });
+
+  it("does not send message if no selection when action triggered", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu with selection
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+
+    // Clear selection before action
+    simulateTextSelection(textarea, 5, 5); // No selection
+
+    // Trigger action via captured callback
+    if (capturedOnAction) {
+      capturedOnAction("tighten");
+    }
+
+    expect(props.sendMessage).not.toHaveBeenCalled();
+  });
+});
+
+// =============================================================================
+// Quick Action Response Handling Tests (REQ-F-6, REQ-F-8)
+// =============================================================================
+
+describe("PairWritingEditor - Quick Action response handling", () => {
+  it("tracks message ID from response_start", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Simulate response_start
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "response_start",
+          messageId: "msg_123",
+        }}
+      />
+    );
+
+    // Processing should still be active
+    expect(screen.getByText("Applying changes...")).toBeDefined();
+  });
+
+  it("accumulates response chunks", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Simulate response_start
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "response_start",
+          messageId: "msg_123",
+        }}
+      />
+    );
+
+    // Simulate response chunks
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "response_chunk",
+          messageId: "msg_123",
+          content: "Tightened ",
+        }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "response_chunk",
+          messageId: "msg_123",
+          content: "the text.",
+        }}
+      />
+    );
+
+    // Simulate response_end
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "response_end",
+          messageId: "msg_123",
+        }}
+      />
+    );
+
+    // Toast should show accumulated text
+    const toast = screen.getByTestId("toast");
+    expect(toast).toBeDefined();
+    expect(toast.textContent).toBe("Tightened the text.");
+  });
+
+  it("shows success toast on response_end with confirmation (REQ-F-6)", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Simulate response flow
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_start", messageId: "msg_123" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_chunk", messageId: "msg_123", content: "Done!" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_end", messageId: "msg_123" }}
+      />
+    );
+
+    const toast = screen.getByTestId("toast");
+    expect(toast.getAttribute("data-variant")).toBe("success");
+  });
+
+  it("calls onQuickActionComplete on response_end (REQ-F-8)", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Simulate response flow
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_start", messageId: "msg_123" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_chunk", messageId: "msg_123", content: "OK" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_end", messageId: "msg_123" }}
+      />
+    );
+
+    expect(props.onQuickActionComplete).toHaveBeenCalledWith("notes/test-file.md");
+  });
+
+  it("clears processing state on response_end", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    expect(textarea.disabled).toBe(true);
+
+    // Simulate response flow
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_start", messageId: "msg_123" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_chunk", messageId: "msg_123", content: "OK" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_end", messageId: "msg_123" }}
+      />
+    );
+
+    // Get fresh reference after rerender
+    const textareaAfter = getTextarea();
+    expect(textareaAfter.disabled).toBe(false);
+    expect(document.querySelector(".pair-writing-editor--processing")).toBeNull();
+  });
+
+  it("does not show toast if confirmation is empty", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Simulate response with no chunks
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_start", messageId: "msg_123" }}
+      />
+    );
+
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{ type: "response_end", messageId: "msg_123" }}
+      />
+    );
+
+    expect(screen.queryByTestId("toast")).toBeNull();
+  });
+});
+
+// =============================================================================
+// Error Handling Tests
+// =============================================================================
+
+describe("PairWritingEditor - error handling", () => {
+  it("clears processing state on error message", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    expect(textarea.disabled).toBe(true);
+
+    // Simulate error
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "error",
+          code: "SDK_ERROR",
+          message: "Something went wrong",
+        }}
+      />
+    );
+
+    const textareaAfter = getTextarea();
+    expect(textareaAfter.disabled).toBe(false);
+  });
+
+  it("shows error toast on error message", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Trigger Quick Action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("action-tighten"));
+
+    // Simulate error
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "error",
+          code: "SDK_ERROR",
+          message: "Connection lost",
+        }}
+      />
+    );
+
+    const toast = screen.getByTestId("toast");
+    expect(toast).toBeDefined();
+    expect(toast.textContent).toBe("Connection lost");
+    expect(toast.getAttribute("data-variant")).toBe("error");
+  });
+
+  it("ignores messages when not processing Quick Action", () => {
+    const props = createDefaultProps();
+    const { rerender } = render(<PairWritingEditor {...props} />);
+
+    // Simulate response without having triggered a Quick Action
+    rerender(
+      <PairWritingEditor
+        {...props}
+        lastMessage={{
+          type: "response_chunk",
+          messageId: "msg_123",
+          content: "Random chunk",
+        }}
+      />
+    );
+
+    // Should not show toast or enter processing state
+    expect(screen.queryByTestId("toast")).toBeNull();
+    expect(document.querySelector(".pair-writing-editor--processing")).toBeNull();
+  });
+});
+
+// =============================================================================
+// Advisory Action Tests (REQ-F-15)
+// =============================================================================
+
+describe("PairWritingEditor - Advisory Actions (REQ-F-15)", () => {
+  it("calls onAdvisoryAction with action and selection", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu and trigger advisory action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 17, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("advisory-validate"));
+
+    expect(props.onAdvisoryAction).toHaveBeenCalledWith(
+      "validate",
+      expect.objectContaining({
+        text: "This is test content",
+      })
+    );
+  });
+
+  it("closes menu after Advisory Action selection", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    expect(screen.getByTestId("context-menu")).toBeDefined();
+
+    // Select advisory action
+    fireEvent.click(screen.getByTestId("advisory-validate"));
+
+    expect(screen.queryByTestId("context-menu")).toBeNull();
+  });
+
+  it("does not call onAdvisoryAction if no selection", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Open menu with selection
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+
+    // Clear selection before action
+    simulateTextSelection(textarea, 5, 5);
+
+    // Trigger advisory action via captured callback
+    if (capturedOnAdvisoryAction) {
+      capturedOnAdvisoryAction("validate");
+    }
+
+    expect(props.onAdvisoryAction).not.toHaveBeenCalled();
+  });
+
+  it("does not enter processing state for Advisory Actions", () => {
+    const props = createDefaultProps();
+    render(<PairWritingEditor {...props} />);
+
+    // Trigger advisory action
+    const textarea = getTextarea();
+    simulateTextSelection(textarea, 18, 37);
+    fireEvent.contextMenu(textarea);
+    fireEvent.click(screen.getByTestId("advisory-validate"));
+
+    // Should NOT show processing state (Advisory Actions are handled by parent)
+    expect(document.querySelector(".pair-writing-editor--processing")).toBeNull();
+    expect(screen.queryByText("Applying changes...")).toBeNull();
+  });
+});
+
+// =============================================================================
+// Quick Action Types Tests
+// =============================================================================
+
+describe("PairWritingEditor - Quick Action types", () => {
+  const actions: Array<"tighten" | "embellish" | "correct" | "polish"> = [
+    "tighten",
+    "embellish",
+    "correct",
+    "polish",
+  ];
+
+  for (const action of actions) {
+    it(`sends correct action type for ${action}`, () => {
+      const props = createDefaultProps();
+      render(<PairWritingEditor {...props} />);
+
+      // Open menu and trigger action via captured callback
+      const textarea = getTextarea();
+      simulateTextSelection(textarea, 18, 37);
+      fireEvent.contextMenu(textarea);
+
+      if (capturedOnAction) {
+        capturedOnAction(action);
+      }
+
+      expect(props.sendMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "quick_action_request",
+          action: action,
+        })
+      );
+    });
+  }
+});
diff --git a/frontend/src/components/__tests__/PairWritingMode.test.tsx b/frontend/src/components/__tests__/PairWritingMode.test.tsx
new file mode 100644
index 00000000..6f67d5cd
--- /dev/null
+++ b/frontend/src/components/__tests__/PairWritingMode.test.tsx
@@ -0,0 +1,233 @@
+/**
+ * Tests for PairWritingMode component
+ *
+ * Tests rendering, layout, exit warning, and component composition.
+ *
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-10, REQ-F-11, REQ-F-14, REQ-F-30
+ */
+
+import { describe, it, expect, afterEach, mock } from "bun:test";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { PairWritingMode } from "../PairWritingMode";
+import { SessionProvider } from "../../contexts/SessionContext";
+
+// Mock components injected via props (no mock.module pollution)
+function MockEditor() {
+  return <div data-testid="pair-writing-editor">PairWritingEditor</div>;
+}
+
+function MockDiscussion() {
+  return (
+    <div data-testid="discussion" aria-label="Pair Writing conversation">
+      <div className="pair-writing-conversation__empty">
+        <p>Select text and use the context menu for AI assistance.</p>
+      </div>
+    </div>
+  );
+}
+
+// Wrapper to provide SessionContext
+function TestWrapper({ children }: { children: ReactNode }) {
+  return <SessionProvider>{children}</SessionProvider>;
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("PairWritingMode", () => {
+  const defaultProps = {
+    filePath: "notes/test-document.md",
+    content: "# Test Document\n\nThis is test content.",
+    assetBaseUrl: "/vault/test-vault/assets",
+    onExit: mock(() => {}),
+    onSave: mock(() => {}),
+    sendMessage: mock(() => {}),
+    lastMessage: null,
+    connectionStatus: "connected" as const,
+    // Inject mock components to avoid mock.module pollution
+    EditorComponent: MockEditor,
+    DiscussionComponent: MockDiscussion,
+  };
+
+  describe("rendering", () => {
+    it("renders the split-screen layout", () => {
+      render(<PairWritingMode {...defaultProps} />, { wrapper: TestWrapper });
+
+      // Should have the main container
+      const container = document.querySelector(".pair-writing-mode");
+      expect(container).not.toBeNull();
+
+      // Should have content area with two panes
+      const content = document.querySelector(".pair-writing-mode__content");
+      expect(content).not.toBeNull();
+
+      // Should have editor and conversation panes
+      const editorPane = document.querySelector(
+        ".pair-writing-mode__editor-pane"
+      );
+      const conversationPane = document.querySelector(
+        ".pair-writing-mode__conversation-pane"
+      );
+      expect(editorPane).not.toBeNull();
+      expect(conversationPane).not.toBeNull();
+    });
+
+    it("renders the toolbar with file path", () => {
+      render(
+        <PairWritingMode {...defaultProps} filePath="path/to/my-file.md" />,
+        { wrapper: TestWrapper }
+      );
+
+      expect(screen.getByText("path/to/my-file.md")).toBeDefined();
+    });
+
+    it("renders child components", () => {
+      render(<PairWritingMode {...defaultProps} />, { wrapper: TestWrapper });
+
+      // PairWritingEditor should be rendered
+      expect(screen.getByTestId("pair-writing-editor")).toBeDefined();
+
+      // Discussion should be rendered (replaces ConversationPane)
+      expect(screen.getByTestId("discussion")).toBeDefined();
+    });
+
+    it("renders Discussion in conversation pane", () => {
+      render(<PairWritingMode {...defaultProps} />, { wrapper: TestWrapper });
+
+      // Discussion component should be visible in the right pane
+      expect(screen.getByTestId("discussion")).toBeDefined();
+    });
+  });
+
+  describe("toolbar interactions", () => {
+    it("calls onSave through toolbar save button", () => {
+      const onSave = mock(() => {});
+      render(<PairWritingMode {...defaultProps} onSave={onSave} />, { wrapper: TestWrapper });
+
+      // Note: The state starts with no unsaved changes, so save button is disabled
+      // We need to trigger a content change first to enable it
+      // For now, just verify the toolbar exists with the save button
+      const saveBtn = screen.getByTitle(/no unsaved changes/i);
+      expect(saveBtn).toBeDefined();
+    });
+
+    it("snapshot button works", () => {
+      render(<PairWritingMode {...defaultProps} />, { wrapper: TestWrapper });
+
+      const snapshotBtn = screen.getByTitle(/take snapshot/i);
+      fireEvent.click(snapshotBtn);
+
+      // After clicking, the button should indicate a snapshot exists
+      expect(screen.getByTitle(/update snapshot/i)).toBeDefined();
+    });
+  });
+
+  describe("exit behavior (REQ-F-14, REQ-F-30)", () => {
+    it("exits directly when no unsaved changes", () => {
+      const onExit = mock(() => {});
+      render(<PairWritingMode {...defaultProps} onExit={onExit} />, { wrapper: TestWrapper });
+
+      const exitBtn = screen.getByTitle(/exit/i);
+      fireEvent.click(exitBtn);
+
+      // Should exit immediately without showing dialog
+      expect(onExit).toHaveBeenCalledTimes(1);
+    });
+
+    it("shows confirmation dialog when unsaved changes exist", () => {
+      const onExit = mock(() => {});
+      render(<PairWritingMode {...defaultProps} onExit={onExit} />, { wrapper: TestWrapper });
+
+      // First, we need to simulate having unsaved changes
+      // The state starts clean, but we can trigger the state by using the hook
+      // For this test, we'll verify the confirmation dialog exists when shown
+
+      // Since we can't easily trigger unsaved state without internal state manipulation,
+      // we'll verify the dialog is present in the component by checking its structure
+      // The actual unsaved change detection is tested in usePairWritingState tests
+
+      // For now, just verify exit works when clean
+      const exitBtn = screen.getByTitle(/exit/i);
+      fireEvent.click(exitBtn);
+
+      // No dialog should appear for clean state
+      expect(screen.queryByRole("dialog")).toBeNull();
+      expect(onExit).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("CSS layout (REQ-F-11)", () => {
+    it("has CSS grid layout for 50/50 split", () => {
+      render(<PairWritingMode {...defaultProps} />, { wrapper: TestWrapper });
+
+      const content = document.querySelector(".pair-writing-mode__content");
+      expect(content).not.toBeNull();
+
+      // Verify the class is present (actual CSS grid verification would be in visual/E2E tests)
+      expect(content?.className).toContain("pair-writing-mode__content");
+    });
+  });
+
+  describe("accessibility", () => {
+    it("has proper aria-label for conversation pane", () => {
+      render(<PairWritingMode {...defaultProps} />, { wrapper: TestWrapper });
+
+      // Discussion component is in the conversation pane
+      const discussionPane = screen.getByTestId("discussion");
+      expect(discussionPane.getAttribute("aria-label")).toBe(
+        "Pair Writing conversation"
+      );
+    });
+  });
+
+  describe("Discussion integration", () => {
+    it("renders Discussion component", () => {
+      render(
+        <PairWritingMode
+          {...defaultProps}
+          assetBaseUrl="/vault/my-vault-123/assets"
+        />,
+        { wrapper: TestWrapper }
+      );
+
+      // Discussion component should be rendered
+      expect(screen.getByTestId("discussion")).toBeDefined();
+    });
+
+    it("handles different assetBaseUrl gracefully", () => {
+      // Should not throw when assetBaseUrl has different format
+      expect(() => {
+        render(
+          <PairWritingMode {...defaultProps} assetBaseUrl="/invalid/url" />,
+          { wrapper: TestWrapper }
+        );
+      }).not.toThrow();
+    });
+  });
+});
+
+describe("PairWritingMode CSS", () => {
+  // Note: CSS media query tests can't be directly tested in JS
+  // These would be verified through visual regression or E2E tests
+  // We document the expected behavior here
+
+  it("should hide on touch devices via media query (REQ-F-10)", () => {
+    // The CSS includes:
+    // @media (hover: none), (pointer: coarse) {
+    //   .pair-writing-mode { display: none; }
+    // }
+    // This hides the component on touch devices
+    // Actual verification requires browser testing with touch device emulation
+    expect(true).toBe(true); // Placeholder for documentation
+  });
+
+  it("should use 50/50 grid split (REQ-F-11)", () => {
+    // The CSS includes:
+    // grid-template-columns: 1fr 1fr
+    // This creates an equal 50/50 split
+    // Actual verification requires visual testing
+    expect(true).toBe(true); // Placeholder for documentation
+  });
+});
diff --git a/frontend/src/components/__tests__/PairWritingToolbar.test.tsx b/frontend/src/components/__tests__/PairWritingToolbar.test.tsx
new file mode 100644
index 00000000..22a28b35
--- /dev/null
+++ b/frontend/src/components/__tests__/PairWritingToolbar.test.tsx
@@ -0,0 +1,167 @@
+/**
+ * Tests for PairWritingToolbar component
+ *
+ * Tests rendering, button states, and user interactions.
+ *
+ * @see .sdd/specs/memory-loop/2026-01-20-pair-writing-mode.md REQ-F-14, REQ-F-23, REQ-F-29
+ */
+
+import { describe, it, expect, afterEach, mock } from "bun:test";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { PairWritingToolbar } from "../PairWritingToolbar";
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("PairWritingToolbar", () => {
+  const defaultProps = {
+    hasUnsavedChanges: false,
+    hasSnapshot: false,
+    isSaving: false,
+    onSnapshot: mock(() => {}),
+    onSave: mock(() => {}),
+    onExit: mock(() => {}),
+    filePath: "notes/test-file.md",
+  };
+
+  describe("rendering", () => {
+    it("renders toolbar with all buttons", () => {
+      render(<PairWritingToolbar {...defaultProps} />);
+
+      expect(screen.getByRole("toolbar")).toBeDefined();
+      expect(screen.getByTitle(/snapshot/i)).toBeDefined();
+      expect(screen.getByTitle(/save/i)).toBeDefined();
+      expect(screen.getByTitle(/exit/i)).toBeDefined();
+    });
+
+    it("displays file path", () => {
+      render(<PairWritingToolbar {...defaultProps} filePath="path/to/document.md" />);
+
+      expect(screen.getByText("path/to/document.md")).toBeDefined();
+    });
+
+    it("shows unsaved indicator when hasUnsavedChanges is true", () => {
+      render(<PairWritingToolbar {...defaultProps} hasUnsavedChanges={true} />);
+
+      expect(screen.getByLabelText("Unsaved changes")).toBeDefined();
+    });
+
+    it("does not show unsaved indicator when hasUnsavedChanges is false", () => {
+      render(<PairWritingToolbar {...defaultProps} hasUnsavedChanges={false} />);
+
+      expect(screen.queryByLabelText("Unsaved changes")).toBeNull();
+    });
+  });
+
+  describe("snapshot button (REQ-F-23)", () => {
+    it("calls onSnapshot when clicked", () => {
+      const onSnapshot = mock(() => {});
+      render(<PairWritingToolbar {...defaultProps} onSnapshot={onSnapshot} />);
+
+      fireEvent.click(screen.getByTitle(/snapshot/i));
+
+      expect(onSnapshot).toHaveBeenCalledTimes(1);
+    });
+
+    it("has aria-pressed false when no snapshot exists", () => {
+      render(<PairWritingToolbar {...defaultProps} hasSnapshot={false} />);
+
+      const snapshotBtn = screen.getByTitle(/take snapshot/i);
+      expect(snapshotBtn.getAttribute("aria-pressed")).toBe("false");
+    });
+
+    it("has aria-pressed true when snapshot exists", () => {
+      render(<PairWritingToolbar {...defaultProps} hasSnapshot={true} />);
+
+      const snapshotBtn = screen.getByTitle(/update snapshot/i);
+      expect(snapshotBtn.getAttribute("aria-pressed")).toBe("true");
+    });
+
+    it("has different title when snapshot exists", () => {
+      const { rerender } = render(<PairWritingToolbar {...defaultProps} hasSnapshot={false} />);
+      expect(screen.getByTitle("Take snapshot for comparison")).toBeDefined();
+
+      rerender(<PairWritingToolbar {...defaultProps} hasSnapshot={true} />);
+      expect(screen.getByTitle("Update snapshot (replaces previous)")).toBeDefined();
+    });
+  });
+
+  describe("save button (REQ-F-29)", () => {
+    it("calls onSave when clicked", () => {
+      const onSave = mock(() => {});
+      render(<PairWritingToolbar {...defaultProps} onSave={onSave} hasUnsavedChanges={true} />);
+
+      fireEvent.click(screen.getByTitle(/save changes/i));
+
+      expect(onSave).toHaveBeenCalledTimes(1);
+    });
+
+    it("is disabled when no unsaved changes", () => {
+      render(<PairWritingToolbar {...defaultProps} hasUnsavedChanges={false} />);
+
+      const saveBtn = screen.getByTitle(/no unsaved changes/i);
+      expect(saveBtn.hasAttribute("disabled")).toBe(true);
+    });
+
+    it("is disabled when saving", () => {
+      render(<PairWritingToolbar {...defaultProps} hasUnsavedChanges={true} isSaving={true} />);
+
+      // Find button that's in saving state
+      const buttons = screen.getAllByRole("button");
+      const saveBtn = buttons.find(btn => btn.textContent?.includes("Saving"));
+      expect(saveBtn).toBeDefined();
+      expect(saveBtn?.hasAttribute("disabled")).toBe(true);
+    });
+
+    it("shows spinner when saving", () => {
+      render(<PairWritingToolbar {...defaultProps} hasUnsavedChanges={true} isSaving={true} />);
+
+      // Check for spinner element
+      const spinner = document.querySelector(".pair-writing-toolbar__spinner");
+      expect(spinner).not.toBeNull();
+    });
+  });
+
+  describe("exit button (REQ-F-14)", () => {
+    it("calls onExit when clicked", () => {
+      const onExit = mock(() => {});
+      render(<PairWritingToolbar {...defaultProps} onExit={onExit} />);
+
+      fireEvent.click(screen.getByTitle(/exit/i));
+
+      expect(onExit).toHaveBeenCalledTimes(1);
+    });
+
+    it("is always enabled", () => {
+      render(<PairWritingToolbar {...defaultProps} hasUnsavedChanges={true} isSaving={true} />);
+
+      const exitBtn = screen.getByTitle(/exit/i);
+      expect(exitBtn.hasAttribute("disabled")).toBe(false);
+    });
+  });
+
+  describe("accessibility", () => {
+    it("has toolbar role", () => {
+      render(<PairWritingToolbar {...defaultProps} />);
+
+      expect(screen.getByRole("toolbar")).toBeDefined();
+    });
+
+    it("has aria-label for toolbar", () => {
+      render(<PairWritingToolbar {...defaultProps} />);
+
+      const toolbar = screen.getByRole("toolbar");
+      expect(toolbar.getAttribute("aria-label")).toBe("Pair Writing toolbar");
+    });
+
+    it("all buttons have type='button'", () => {
+      render(<PairWritingToolbar {...defaultProps} />);
+
+      const buttons = screen.getAllByRole("button");
+      buttons.forEach((button) => {
+        expect(button.getAttribute("type")).toBe("button");
+      });
+    });
+  });
+});
diff --git a/frontend/src/hooks/__tests__/useTextSelection.test.ts b/frontend/src/hooks/__tests__/useTextSelection.test.ts
new file mode 100644
index 00000000..69da22a4
--- /dev/null
+++ b/frontend/src/hooks/__tests__/useTextSelection.test.ts
@@ -0,0 +1,430 @@
+/**
+ * useTextSelection Hook Tests
+ *
+ * Tests line counting, paragraph extraction, and hook behavior.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { renderHook, act } from "@testing-library/react";
+import {
+  useTextSelection,
+  getLineNumber,
+  countTotalLines,
+  extractParagraphBefore,
+  extractParagraphAfter,
+  extractSelectionContext,
+} from "../useTextSelection";
+import { createRef } from "react";
+
+describe("getLineNumber", () => {
+  it("returns 1 for position 0", () => {
+    expect(getLineNumber("hello\nworld", 0)).toBe(1);
+  });
+
+  it("returns 1 for positions on the first line", () => {
+    expect(getLineNumber("hello\nworld", 3)).toBe(1);
+    expect(getLineNumber("hello\nworld", 5)).toBe(1);
+  });
+
+  it("returns 2 for positions after first newline", () => {
+    expect(getLineNumber("hello\nworld", 6)).toBe(2);
+    expect(getLineNumber("hello\nworld", 10)).toBe(2);
+  });
+
+  it("handles multiple lines correctly", () => {
+    const text = "line1\nline2\nline3\nline4";
+    expect(getLineNumber(text, 0)).toBe(1); // start of line1
+    expect(getLineNumber(text, 6)).toBe(2); // start of line2
+    expect(getLineNumber(text, 12)).toBe(3); // start of line3
+    expect(getLineNumber(text, 18)).toBe(4); // start of line4
+  });
+
+  it("handles empty string", () => {
+    expect(getLineNumber("", 0)).toBe(1);
+  });
+
+  it("clamps position to text length", () => {
+    expect(getLineNumber("hello", 100)).toBe(1);
+    expect(getLineNumber("hello\nworld", 100)).toBe(2);
+  });
+
+  it("handles consecutive newlines", () => {
+    const text = "a\n\nb";
+    expect(getLineNumber(text, 0)).toBe(1); // a
+    expect(getLineNumber(text, 2)).toBe(2); // empty line
+    expect(getLineNumber(text, 3)).toBe(3); // b
+  });
+});
+
+describe("countTotalLines", () => {
+  it("returns 1 for empty string", () => {
+    expect(countTotalLines("")).toBe(1);
+  });
+
+  it("returns 1 for single line without newline", () => {
+    expect(countTotalLines("hello")).toBe(1);
+  });
+
+  it("returns 2 for text with one newline", () => {
+    expect(countTotalLines("hello\nworld")).toBe(2);
+  });
+
+  it("counts multiple lines correctly", () => {
+    expect(countTotalLines("a\nb\nc\nd")).toBe(4);
+  });
+
+  it("counts trailing newline as extra line", () => {
+    expect(countTotalLines("hello\n")).toBe(2);
+  });
+
+  it("counts blank lines", () => {
+    expect(countTotalLines("a\n\nb")).toBe(3);
+    expect(countTotalLines("a\n\n\nb")).toBe(4);
+  });
+});
+
+describe("extractParagraphBefore", () => {
+  it("returns empty string when selection is at start", () => {
+    expect(extractParagraphBefore("hello world", 0)).toBe("");
+  });
+
+  it("returns empty string when no paragraph delimiter exists before", () => {
+    expect(extractParagraphBefore("hello world", 5)).toBe("");
+  });
+
+  it("extracts paragraph before when delimiter exists", () => {
+    const text = "First paragraph.\n\nSecond paragraph.";
+    // Selection at start of "Second"
+    expect(extractParagraphBefore(text, 18)).toBe("First paragraph.");
+  });
+
+  it("extracts correct paragraph with multiple paragraphs", () => {
+    const text = "Para one.\n\nPara two.\n\nPara three.";
+    // Selection at "Para three"
+    expect(extractParagraphBefore(text, 22)).toBe("Para two.");
+  });
+
+  it("handles paragraph at document start", () => {
+    const text = "Very first.\n\nSecond.\n\nThird.";
+    // Selection at "Second"
+    expect(extractParagraphBefore(text, 13)).toBe("Very first.");
+  });
+
+  it("handles extra whitespace in paragraphs", () => {
+    const text = "  Para one.  \n\n  Para two.  \n\nPara three.";
+    // Selection at "Para three"
+    expect(extractParagraphBefore(text, 31)).toBe("Para two.");
+  });
+
+  it("returns empty for single paragraph document", () => {
+    const text = "Just one paragraph here.";
+    expect(extractParagraphBefore(text, 10)).toBe("");
+  });
+});
+
+describe("extractParagraphAfter", () => {
+  it("returns empty string when selection is at end", () => {
+    const text = "hello world";
+    expect(extractParagraphAfter(text, text.length)).toBe("");
+  });
+
+  it("returns empty string when no paragraph delimiter exists after", () => {
+    expect(extractParagraphAfter("hello world", 5)).toBe("");
+  });
+
+  it("extracts paragraph after when delimiter exists", () => {
+    const text = "First paragraph.\n\nSecond paragraph.";
+    // Selection ends at "First paragraph."
+    expect(extractParagraphAfter(text, 16)).toBe("Second paragraph.");
+  });
+
+  it("extracts correct paragraph with multiple paragraphs", () => {
+    const text = "Para one.\n\nPara two.\n\nPara three.";
+    // Selection ends at "Para one."
+    expect(extractParagraphAfter(text, 9)).toBe("Para two.");
+  });
+
+  it("handles paragraph at document end", () => {
+    const text = "First.\n\nSecond.\n\nVery last.";
+    // Selection ends at "Second."
+    expect(extractParagraphAfter(text, 15)).toBe("Very last.");
+  });
+
+  it("handles extra whitespace in paragraphs", () => {
+    const text = "Para one.\n\n  Para two.  \n\n  Para three.  ";
+    // Selection ends at "Para one."
+    expect(extractParagraphAfter(text, 9)).toBe("Para two.");
+  });
+
+  it("returns empty for single paragraph document", () => {
+    const text = "Just one paragraph here.";
+    expect(extractParagraphAfter(text, 10)).toBe("");
+  });
+});
+
+describe("extractSelectionContext", () => {
+  const sampleDoc = `# Introduction
+
+This is the first paragraph with some content.
+
+This is the second paragraph.
+
+And this is the third paragraph at the end.`;
+
+  it("returns null for empty selection (start equals end)", () => {
+    expect(extractSelectionContext(sampleDoc, 5, 5)).toBeNull();
+  });
+
+  it("returns null for whitespace-only selection", () => {
+    expect(extractSelectionContext("hello   world", 5, 8)).toBeNull();
+  });
+
+  it("returns null for invalid start position", () => {
+    expect(extractSelectionContext(sampleDoc, -1, 10)).toBeNull();
+  });
+
+  it("returns null for invalid end position", () => {
+    expect(extractSelectionContext(sampleDoc, 0, -1)).toBeNull();
+  });
+
+  it("returns null when start > end", () => {
+    expect(extractSelectionContext(sampleDoc, 10, 5)).toBeNull();
+  });
+
+  it("returns null when positions exceed content length", () => {
+    expect(extractSelectionContext("short", 0, 100)).toBeNull();
+    expect(extractSelectionContext("short", 100, 105)).toBeNull();
+  });
+
+  it("extracts selection text correctly", () => {
+    const result = extractSelectionContext("hello world", 0, 5);
+    expect(result?.text).toBe("hello");
+  });
+
+  it("calculates line numbers correctly for single line selection", () => {
+    const text = "line1\nline2\nline3";
+    // Select "line2"
+    const result = extractSelectionContext(text, 6, 11);
+    expect(result?.startLine).toBe(2);
+    expect(result?.endLine).toBe(2);
+  });
+
+  it("calculates line numbers correctly for multi-line selection", () => {
+    const text = "line1\nline2\nline3\nline4";
+    // Select "line2\nline3"
+    const result = extractSelectionContext(text, 6, 17);
+    expect(result?.startLine).toBe(2);
+    expect(result?.endLine).toBe(3);
+  });
+
+  it("calculates total lines correctly", () => {
+    const text = "line1\nline2\nline3\nline4";
+    const result = extractSelectionContext(text, 0, 5);
+    expect(result?.totalLines).toBe(4);
+  });
+
+  it("extracts paragraph context correctly", () => {
+    const text = "Para 1.\n\nPara 2 selected text here.\n\nPara 3.";
+    // Select "selected" in para 2
+    const result = extractSelectionContext(text, 16, 24);
+    expect(result?.contextBefore).toBe("Para 1.");
+    expect(result?.contextAfter).toBe("Para 3.");
+  });
+
+  it("handles selection in first paragraph", () => {
+    const text = "First paragraph.\n\nSecond paragraph.";
+    const result = extractSelectionContext(text, 0, 5);
+    expect(result?.contextBefore).toBe("");
+    expect(result?.contextAfter).toBe("Second paragraph.");
+  });
+
+  it("handles selection in last paragraph", () => {
+    const text = "First paragraph.\n\nLast paragraph.";
+    const result = extractSelectionContext(text, 18, 22);
+    expect(result?.contextBefore).toBe("First paragraph.");
+    expect(result?.contextAfter).toBe("");
+  });
+
+  it("handles document with no paragraph breaks", () => {
+    const text = "Single paragraph document with no breaks.";
+    const result = extractSelectionContext(text, 7, 16);
+    expect(result?.contextBefore).toBe("");
+    expect(result?.contextAfter).toBe("");
+    expect(result?.text).toBe("paragraph");
+  });
+});
+
+describe("useTextSelection hook", () => {
+  // Mock textarea for testing
+  let mockTextarea: HTMLTextAreaElement;
+
+  beforeEach(() => {
+    mockTextarea = document.createElement("textarea");
+    mockTextarea.value = "Hello\n\nWorld\n\nEnd.";
+    document.body.appendChild(mockTextarea);
+  });
+
+  afterEach(() => {
+    document.body.removeChild(mockTextarea);
+  });
+
+  it("returns null selection initially", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() =>
+      useTextSelection(ref, mockTextarea.value)
+    );
+
+    expect(result.current.selection).toBeNull();
+  });
+
+  it("provides clearSelection function", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() =>
+      useTextSelection(ref, mockTextarea.value)
+    );
+
+    expect(typeof result.current.clearSelection).toBe("function");
+  });
+
+  it("updates selection on select event", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() =>
+      useTextSelection(ref, mockTextarea.value)
+    );
+
+    // Simulate selection
+    act(() => {
+      mockTextarea.selectionStart = 0;
+      mockTextarea.selectionEnd = 5;
+      mockTextarea.dispatchEvent(new Event("select"));
+    });
+
+    expect(result.current.selection).not.toBeNull();
+    expect(result.current.selection?.text).toBe("Hello");
+  });
+
+  it("updates selection on mouseup", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() =>
+      useTextSelection(ref, mockTextarea.value)
+    );
+
+    // Simulate selection via mouseup
+    act(() => {
+      mockTextarea.selectionStart = 7;
+      mockTextarea.selectionEnd = 12;
+      mockTextarea.dispatchEvent(new MouseEvent("mouseup"));
+    });
+
+    expect(result.current.selection).not.toBeNull();
+    expect(result.current.selection?.text).toBe("World");
+  });
+
+  it("clears selection when content changes", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result, rerender } = renderHook(
+      ({ content }) => useTextSelection(ref, content),
+      { initialProps: { content: mockTextarea.value } }
+    );
+
+    // Set up a selection
+    act(() => {
+      mockTextarea.selectionStart = 0;
+      mockTextarea.selectionEnd = 5;
+      mockTextarea.dispatchEvent(new Event("select"));
+    });
+
+    expect(result.current.selection).not.toBeNull();
+
+    // Change content
+    rerender({ content: "Different content entirely" });
+
+    expect(result.current.selection).toBeNull();
+  });
+
+  it("clearSelection sets selection to null", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() =>
+      useTextSelection(ref, mockTextarea.value)
+    );
+
+    // Set up a selection
+    act(() => {
+      mockTextarea.selectionStart = 0;
+      mockTextarea.selectionEnd = 5;
+      mockTextarea.dispatchEvent(new Event("select"));
+    });
+
+    expect(result.current.selection).not.toBeNull();
+
+    // Clear it
+    act(() => {
+      result.current.clearSelection();
+    });
+
+    expect(result.current.selection).toBeNull();
+  });
+
+  it("calculates correct context for middle selection", () => {
+    const content = "First para.\n\nMiddle para has selected text.\n\nLast para.";
+    mockTextarea.value = content;
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() => useTextSelection(ref, content));
+
+    // Select "selected" in middle paragraph
+    // "First para.\n\nMiddle para has selected text.\n\nLast para."
+    // "selected" starts at index 29 and ends at 37
+    act(() => {
+      mockTextarea.selectionStart = 29;
+      mockTextarea.selectionEnd = 37;
+      mockTextarea.dispatchEvent(new Event("select"));
+    });
+
+    expect(result.current.selection?.text).toBe("selected");
+    expect(result.current.selection?.contextBefore).toBe("First para.");
+    expect(result.current.selection?.contextAfter).toBe("Last para.");
+  });
+
+  it("returns null for null ref", () => {
+    const ref = createRef<HTMLTextAreaElement>();
+    // ref.current is null
+
+    const { result } = renderHook(() => useTextSelection(ref, "some content"));
+
+    expect(result.current.selection).toBeNull();
+  });
+
+  it("returns correct line numbers", () => {
+    const content = "Line 1\nLine 2\nLine 3\nLine 4";
+    mockTextarea.value = content;
+    const ref = createRef<HTMLTextAreaElement>();
+    (ref as { current: HTMLTextAreaElement }).current = mockTextarea;
+
+    const { result } = renderHook(() => useTextSelection(ref, content));
+
+    // Select "Line 2\nLine 3"
+    act(() => {
+      mockTextarea.selectionStart = 7;
+      mockTextarea.selectionEnd = 20;
+      mockTextarea.dispatchEvent(new Event("select"));
+    });
+
+    expect(result.current.selection?.startLine).toBe(2);
+    expect(result.current.selection?.endLine).toBe(3);
+    expect(result.current.selection?.totalLines).toBe(4);
+  });
+});
diff --git a/frontend/src/hooks/useLongPress.test.ts b/frontend/src/hooks/useLongPress.test.ts
new file mode 100644
index 00000000..222850eb
--- /dev/null
+++ b/frontend/src/hooks/useLongPress.test.ts
@@ -0,0 +1,276 @@
+import { describe, test, expect, mock } from "bun:test";
+import { renderHook, act } from "@testing-library/react";
+import { useLongPress, DEFAULT_LONG_PRESS_DURATION } from "./useLongPress";
+
+describe("useLongPress", () => {
+
+  /**
+   * Helper to create a mock touch event
+   */
+  function createTouchEvent(type: "start" | "move" | "end"): React.TouchEvent {
+    const prevented = { current: false };
+    return {
+      type: `touch${type}`,
+      preventDefault: () => {
+        prevented.current = true;
+      },
+      touches: [{ clientX: 100, clientY: 200 }],
+      changedTouches: [{ clientX: 100, clientY: 200 }],
+      // Expose for test assertions
+      _prevented: prevented,
+    } as unknown as React.TouchEvent & { _prevented: { current: boolean } };
+  }
+
+  describe("default duration", () => {
+    test("exports DEFAULT_LONG_PRESS_DURATION as 500ms", () => {
+      expect(DEFAULT_LONG_PRESS_DURATION).toBe(500);
+    });
+
+    test("uses 500ms duration by default", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback));
+
+      const event = createTouchEvent("start");
+      act(() => {
+        result.current.onTouchStart(event);
+      });
+
+      // Not called immediately
+      expect(callback).not.toHaveBeenCalled();
+
+      // Wait less than 500ms
+      await new Promise((resolve) => setTimeout(resolve, 400));
+      expect(callback).not.toHaveBeenCalled();
+
+      // Wait past 500ms
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("custom duration", () => {
+    test("respects custom duration option", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback, { duration: 200 }));
+
+      const event = createTouchEvent("start");
+      act(() => {
+        result.current.onTouchStart(event);
+      });
+
+      // Not called at 150ms
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      expect(callback).not.toHaveBeenCalled();
+
+      // Called after 200ms
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("callback invocation", () => {
+    test("calls callback with the touch event", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback, { duration: 50 }));
+
+      const event = createTouchEvent("start");
+      act(() => {
+        result.current.onTouchStart(event);
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).toHaveBeenCalledTimes(1);
+      // The callback receives the event
+      expect(callback).toHaveBeenCalledWith(event);
+    });
+
+    test("does not call callback if undefined", async () => {
+      const { result } = renderHook(() => useLongPress(undefined, { duration: 50 }));
+
+      const event = createTouchEvent("start");
+      act(() => {
+        result.current.onTouchStart(event);
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      // No error thrown, just no callback
+    });
+  });
+
+  describe("preventDefault", () => {
+    test("calls preventDefault on touchstart to suppress system context menu", () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback));
+
+      const event = createTouchEvent("start") as React.TouchEvent & {
+        _prevented: { current: boolean };
+      };
+      act(() => {
+        result.current.onTouchStart(event);
+      });
+
+      expect(event._prevented.current).toBe(true);
+    });
+  });
+
+  describe("cancellation on move", () => {
+    test("cancels timer when touch moves", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback, { duration: 100 }));
+
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+
+      // Move before timer fires
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      act(() => {
+        result.current.onTouchMove(createTouchEvent("move"));
+      });
+
+      // Wait past original timer
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("cancellation on end", () => {
+    test("cancels timer when touch ends", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback, { duration: 100 }));
+
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+
+      // End before timer fires
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      act(() => {
+        result.current.onTouchEnd(createTouchEvent("end"));
+      });
+
+      // Wait past original timer
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("cleanup", () => {
+    test("cleans up timer on unmount", async () => {
+      const callback = mock(() => {});
+      const { result, unmount } = renderHook(() => useLongPress(callback, { duration: 100 }));
+
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+
+      // Unmount before timer fires
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      unmount();
+
+      // Wait past original timer
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("multiple interactions", () => {
+    test("can trigger multiple long presses sequentially", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback, { duration: 50 }));
+
+      // First long press
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      // End first touch
+      act(() => {
+        result.current.onTouchEnd(createTouchEvent("end"));
+      });
+
+      // Second long press
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).toHaveBeenCalledTimes(2);
+    });
+
+    test("restarting touch before timer fires resets the timer", async () => {
+      const callback = mock(() => {});
+      const { result } = renderHook(() => useLongPress(callback, { duration: 100 }));
+
+      // Start first touch
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+
+      // Wait 60ms, then end
+      await new Promise((resolve) => setTimeout(resolve, 60));
+      act(() => {
+        result.current.onTouchEnd(createTouchEvent("end"));
+      });
+
+      // Start new touch immediately
+      act(() => {
+        result.current.onTouchStart(createTouchEvent("start"));
+      });
+
+      // Wait another 60ms (total 120ms from first start, but only 60ms from second)
+      await new Promise((resolve) => setTimeout(resolve, 60));
+      expect(callback).not.toHaveBeenCalled();
+
+      // Wait for second timer to complete
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("return value stability", () => {
+    test("returns consistent handler references when dependencies unchanged", () => {
+      const callback = mock(() => {});
+      const { result, rerender } = renderHook(() => useLongPress(callback, { duration: 500 }));
+
+      const firstHandlers = result.current;
+      rerender();
+      const secondHandlers = result.current;
+
+      expect(secondHandlers.onTouchStart).toBe(firstHandlers.onTouchStart);
+      expect(secondHandlers.onTouchMove).toBe(firstHandlers.onTouchMove);
+      expect(secondHandlers.onTouchEnd).toBe(firstHandlers.onTouchEnd);
+    });
+
+    test("updates handlers when callback changes", () => {
+      const callback1 = mock(() => {});
+      const callback2 = mock(() => {});
+      const { result, rerender } = renderHook(
+        ({ cb }) => useLongPress(cb, { duration: 500 }),
+        { initialProps: { cb: callback1 } }
+      );
+
+      const firstStart = result.current.onTouchStart;
+      rerender({ cb: callback2 });
+      const secondStart = result.current.onTouchStart;
+
+      // onTouchStart should be different because callback changed
+      expect(secondStart).not.toBe(firstStart);
+    });
+
+    test("updates handlers when duration changes", () => {
+      const callback = mock(() => {});
+      const { result, rerender } = renderHook(
+        ({ dur }) => useLongPress(callback, { duration: dur }),
+        { initialProps: { dur: 500 } }
+      );
+
+      const firstStart = result.current.onTouchStart;
+      rerender({ dur: 1000 });
+      const secondStart = result.current.onTouchStart;
+
+      expect(secondStart).not.toBe(firstStart);
+    });
+  });
+});
diff --git a/frontend/src/hooks/useLongPress.ts b/frontend/src/hooks/useLongPress.ts
new file mode 100644
index 00000000..66079137
--- /dev/null
+++ b/frontend/src/hooks/useLongPress.ts
@@ -0,0 +1,114 @@
+/**
+ * useLongPress Hook
+ *
+ * Provides touch event handlers for detecting long-press gestures.
+ * Used for triggering context menus and other actions on mobile devices.
+ */
+
+import { useRef, useCallback, useEffect } from "react";
+
+/**
+ * Touch event handlers returned by the useLongPress hook.
+ */
+export interface LongPressHandlers {
+  onTouchStart: (e: React.TouchEvent) => void;
+  onTouchMove: (e: React.TouchEvent) => void;
+  onTouchEnd: (e: React.TouchEvent) => void;
+}
+
+/**
+ * Options for configuring long press behavior.
+ */
+export interface UseLongPressOptions {
+  /** Duration in milliseconds before triggering the callback. Default: 500ms */
+  duration?: number;
+}
+
+/** Default long press duration in milliseconds */
+export const DEFAULT_LONG_PRESS_DURATION = 500;
+
+/**
+ * React hook for detecting long-press gestures on touch devices.
+ *
+ * Starts a timer on touch start, cancels on move or end, and fires
+ * the callback if the touch is held for the specified duration.
+ *
+ * @param callback - Function to call when long press is detected
+ * @param options - Configuration options (duration)
+ * @returns Touch event handlers to attach to an element
+ *
+ * @example
+ * ```tsx
+ * const handlers = useLongPress(
+ *   (e) => showContextMenu(e),
+ *   { duration: 500 }
+ * );
+ *
+ * return (
+ *   <button {...handlers}>
+ *     Long press me
+ *   </button>
+ * );
+ * ```
+ */
+export function useLongPress(
+  callback: ((e: React.TouchEvent) => void) | undefined,
+  options: UseLongPressOptions = {}
+): LongPressHandlers {
+  const { duration = DEFAULT_LONG_PRESS_DURATION } = options;
+
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const eventRef = useRef<React.TouchEvent | null>(null);
+
+  // Cleanup timer on unmount
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+
+  const clearTimer = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    eventRef.current = null;
+  }, []);
+
+  const onTouchStart = useCallback(
+    (e: React.TouchEvent) => {
+      if (!callback) return;
+
+      // Prevent system context menu from appearing
+      e.preventDefault();
+
+      // Store event for callback
+      eventRef.current = e;
+
+      timerRef.current = setTimeout(() => {
+        if (eventRef.current) {
+          callback(eventRef.current);
+        }
+        timerRef.current = null;
+        eventRef.current = null;
+      }, duration);
+    },
+    [callback, duration]
+  );
+
+  const onTouchMove = useCallback(() => {
+    clearTimer();
+  }, [clearTimer]);
+
+  const onTouchEnd = useCallback(() => {
+    clearTimer();
+  }, [clearTimer]);
+
+  return {
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+  };
+}
diff --git a/frontend/src/hooks/usePairWritingState.test.ts b/frontend/src/hooks/usePairWritingState.test.ts
new file mode 100644
index 00000000..aac68fd4
--- /dev/null
+++ b/frontend/src/hooks/usePairWritingState.test.ts
@@ -0,0 +1,326 @@
+/**
+ * Tests for usePairWritingState hook.
+ *
+ * Covers all state transitions and ensures session-scoped behavior (REQ-F-27).
+ *
+ * Conversation state is now managed by SessionContext (shared with Discussion),
+ * so conversation-related tests have been removed from this file.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { renderHook, act } from "@testing-library/react";
+import { usePairWritingState } from "./usePairWritingState";
+
+describe("usePairWritingState", () => {
+  describe("initial state", () => {
+    test("starts inactive with empty state", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      expect(result.current.state).toEqual({
+        isActive: false,
+        content: "",
+        snapshot: null,
+        hasUnsavedChanges: false,
+      });
+    });
+  });
+
+  describe("activate", () => {
+    test("sets isActive to true and initializes content", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("# Hello World");
+      });
+
+      expect(result.current.state.isActive).toBe(true);
+      expect(result.current.state.content).toBe("# Hello World");
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+    });
+
+    test("clears previous state when reactivating", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      // Set up some state
+      act(() => {
+        result.current.actions.activate("initial content");
+        result.current.actions.takeSnapshot();
+        result.current.actions.setContent("modified content");
+      });
+
+      // Reactivate with new content
+      act(() => {
+        result.current.actions.activate("new content");
+      });
+
+      expect(result.current.state.content).toBe("new content");
+      expect(result.current.state.snapshot).toBeNull();
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+    });
+  });
+
+  describe("deactivate", () => {
+    test("clears all state (REQ-F-27: session-scoped)", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      // Set up some state
+      act(() => {
+        result.current.actions.activate("content");
+        result.current.actions.takeSnapshot();
+        result.current.actions.setContent("modified");
+      });
+
+      // Deactivate
+      act(() => {
+        result.current.actions.deactivate();
+      });
+
+      expect(result.current.state).toEqual({
+        isActive: false,
+        content: "",
+        snapshot: null,
+        hasUnsavedChanges: false,
+      });
+    });
+  });
+
+  describe("setContent", () => {
+    test("updates content and sets hasUnsavedChanges", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("initial");
+      });
+
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+
+      act(() => {
+        result.current.actions.setContent("modified");
+      });
+
+      expect(result.current.state.content).toBe("modified");
+      expect(result.current.state.hasUnsavedChanges).toBe(true);
+    });
+
+    test("marks unsaved even if content is same (intentional simplicity)", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("same");
+        result.current.actions.setContent("same");
+      });
+
+      // This is intentional: we don't track original content for comparison
+      expect(result.current.state.hasUnsavedChanges).toBe(true);
+    });
+  });
+
+  describe("takeSnapshot (REQ-F-23, REQ-F-24)", () => {
+    test("captures current content as snapshot", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("snapshot this");
+        result.current.actions.takeSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBe("snapshot this");
+    });
+
+    test("new snapshot replaces previous (REQ-F-24: only one at a time)", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("first snapshot");
+        result.current.actions.takeSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBe("first snapshot");
+
+      act(() => {
+        result.current.actions.setContent("second snapshot");
+        result.current.actions.takeSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBe("second snapshot");
+    });
+  });
+
+  describe("clearSnapshot", () => {
+    test("clears the snapshot", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("content");
+        result.current.actions.takeSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBe("content");
+
+      act(() => {
+        result.current.actions.clearSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBeNull();
+    });
+  });
+
+  describe("clearAll", () => {
+    test("is an alias for deactivate (REQ-F-27)", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("content");
+        result.current.actions.takeSnapshot();
+        result.current.actions.setContent("modified");
+      });
+
+      act(() => {
+        result.current.actions.clearAll();
+      });
+
+      expect(result.current.state.isActive).toBe(false);
+      expect(result.current.state.content).toBe("");
+      expect(result.current.state.snapshot).toBeNull();
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+    });
+  });
+
+  describe("markSaved", () => {
+    test("clears hasUnsavedChanges flag", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("initial");
+        result.current.actions.setContent("modified");
+      });
+
+      expect(result.current.state.hasUnsavedChanges).toBe(true);
+
+      act(() => {
+        result.current.actions.markSaved();
+      });
+
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+    });
+  });
+
+  describe("reloadContent", () => {
+    test("updates content without marking as unsaved", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("initial");
+        result.current.actions.setContent("user edits");
+      });
+
+      expect(result.current.state.hasUnsavedChanges).toBe(true);
+
+      // Simulate Quick Action completing and reloading file from disk
+      act(() => {
+        result.current.actions.reloadContent("claude edited this");
+      });
+
+      expect(result.current.state.content).toBe("claude edited this");
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+    });
+
+    test("preserves snapshot", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("initial");
+        result.current.actions.takeSnapshot();
+      });
+
+      act(() => {
+        result.current.actions.reloadContent("reloaded");
+      });
+
+      expect(result.current.state.content).toBe("reloaded");
+      expect(result.current.state.snapshot).toBe("initial");
+    });
+  });
+
+  describe("action reference stability", () => {
+    test("actions are stable across re-renders", () => {
+      const { result, rerender } = renderHook(() => usePairWritingState());
+
+      const firstActions = result.current.actions;
+      rerender();
+      const secondActions = result.current.actions;
+
+      // All action references should be stable (useCallback)
+      expect(secondActions.activate).toBe(firstActions.activate);
+      expect(secondActions.deactivate).toBe(firstActions.deactivate);
+      expect(secondActions.setContent).toBe(firstActions.setContent);
+      expect(secondActions.takeSnapshot).toBe(firstActions.takeSnapshot);
+      expect(secondActions.clearSnapshot).toBe(firstActions.clearSnapshot);
+      expect(secondActions.clearAll).toBe(firstActions.clearAll);
+      expect(secondActions.markSaved).toBe(firstActions.markSaved);
+      expect(secondActions.reloadContent).toBe(firstActions.reloadContent);
+    });
+  });
+
+  describe("session-scoped behavior (REQ-F-27)", () => {
+    test("snapshot is cleared on exit", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      act(() => {
+        result.current.actions.activate("content");
+        result.current.actions.takeSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBe("content");
+
+      act(() => {
+        result.current.actions.clearAll();
+      });
+
+      expect(result.current.state.snapshot).toBeNull();
+    });
+  });
+
+  describe("typical workflow", () => {
+    test("edit-snapshot-compare workflow", () => {
+      const { result } = renderHook(() => usePairWritingState());
+
+      // 1. Enter Pair Writing Mode with file content
+      act(() => {
+        result.current.actions.activate("# Original Title\n\nSome content here.");
+      });
+
+      expect(result.current.state.isActive).toBe(true);
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+
+      // 2. Take a snapshot before making changes
+      act(() => {
+        result.current.actions.takeSnapshot();
+      });
+
+      expect(result.current.state.snapshot).toBe("# Original Title\n\nSome content here.");
+
+      // 3. User edits the document
+      act(() => {
+        result.current.actions.setContent("# Better Title\n\nRevised content here.");
+      });
+
+      expect(result.current.state.hasUnsavedChanges).toBe(true);
+
+      // 4. User saves
+      act(() => {
+        result.current.actions.markSaved();
+      });
+
+      expect(result.current.state.hasUnsavedChanges).toBe(false);
+
+      // 5. Exit clears session state
+      act(() => {
+        result.current.actions.clearAll();
+      });
+
+      expect(result.current.state.isActive).toBe(false);
+      expect(result.current.state.snapshot).toBeNull();
+    });
+  });
+});
diff --git a/frontend/src/hooks/usePairWritingState.ts b/frontend/src/hooks/usePairWritingState.ts
new file mode 100644
index 00000000..7e56f7f0
--- /dev/null
+++ b/frontend/src/hooks/usePairWritingState.ts
@@ -0,0 +1,222 @@
+/**
+ * Pair Writing Mode State Hook
+ *
+ * Manages session-scoped state for Pair Writing Mode including:
+ * - Editor content and unsaved changes tracking
+ * - Manual snapshot for comparison
+ *
+ * Conversation state is now managed by SessionContext and displayed by the
+ * embedded Discussion component. This hook only tracks editor-specific state.
+ *
+ * @see .sdd/plans/memory-loop/2026-01-20-pair-writing-mode-plan.md TD-5
+ */
+
+import { useReducer, useCallback } from "react";
+
+// ----------------------------------------------------------------------------
+// Types
+// ----------------------------------------------------------------------------
+
+/**
+ * Pair Writing Mode state.
+ * Session-scoped: snapshot is cleared when exiting Pair Writing Mode (REQ-F-27).
+ * Conversation state is now managed by SessionContext (shared with Discussion).
+ */
+export interface PairWritingState {
+  /** Whether Pair Writing Mode is active */
+  isActive: boolean;
+  /** Current editor content */
+  content: string;
+  /** Manual snapshot for comparison (REQ-F-23, REQ-F-24) */
+  snapshot: string | null;
+  /** Whether there are unsaved manual edits (REQ-F-30) */
+  hasUnsavedChanges: boolean;
+}
+
+/**
+ * Actions returned by the hook for state management.
+ */
+export interface PairWritingActions {
+  /** Activate Pair Writing Mode with initial content */
+  activate: (content: string) => void;
+  /** Deactivate Pair Writing Mode (clears all state per REQ-F-27) */
+  deactivate: () => void;
+  /** Update editor content */
+  setContent: (content: string) => void;
+  /** Take a snapshot of current content (REQ-F-23) */
+  takeSnapshot: () => void;
+  /** Clear the current snapshot */
+  clearSnapshot: () => void;
+  /** Clear all state (alias for deactivate, used on exit) */
+  clearAll: () => void;
+  /** Mark changes as saved (resets hasUnsavedChanges) */
+  markSaved: () => void;
+  /** Reload content from disk (updates content, clears unsaved flag) */
+  reloadContent: (content: string) => void;
+}
+
+// ----------------------------------------------------------------------------
+// Reducer
+// ----------------------------------------------------------------------------
+
+type PairWritingAction =
+  | { type: "ACTIVATE"; content: string }
+  | { type: "DEACTIVATE" }
+  | { type: "SET_CONTENT"; content: string }
+  | { type: "TAKE_SNAPSHOT" }
+  | { type: "CLEAR_SNAPSHOT" }
+  | { type: "MARK_SAVED" }
+  | { type: "RELOAD_CONTENT"; content: string };
+
+/**
+ * Initial state for Pair Writing Mode.
+ */
+function createInitialState(): PairWritingState {
+  return {
+    isActive: false,
+    content: "",
+    snapshot: null,
+    hasUnsavedChanges: false,
+  };
+}
+
+/**
+ * Pair Writing state reducer.
+ */
+function pairWritingReducer(
+  state: PairWritingState,
+  action: PairWritingAction
+): PairWritingState {
+  switch (action.type) {
+    case "ACTIVATE":
+      return {
+        ...createInitialState(),
+        isActive: true,
+        content: action.content,
+      };
+
+    case "DEACTIVATE":
+      // Clear all state per REQ-F-27 (session-scoped)
+      return createInitialState();
+
+    case "SET_CONTENT":
+      // Track unsaved changes when content differs from what was loaded
+      return {
+        ...state,
+        content: action.content,
+        hasUnsavedChanges: true,
+      };
+
+    case "TAKE_SNAPSHOT":
+      // REQ-F-24: Only one snapshot at a time; new snapshot replaces previous
+      return {
+        ...state,
+        snapshot: state.content,
+      };
+
+    case "CLEAR_SNAPSHOT":
+      return {
+        ...state,
+        snapshot: null,
+      };
+
+    case "MARK_SAVED":
+      return {
+        ...state,
+        hasUnsavedChanges: false,
+      };
+
+    case "RELOAD_CONTENT":
+      // Used after Quick Actions complete (file was written by Claude)
+      // Updates content without marking as unsaved
+      return {
+        ...state,
+        content: action.content,
+        hasUnsavedChanges: false,
+      };
+
+    default:
+      return state;
+  }
+}
+
+// ----------------------------------------------------------------------------
+// Hook
+// ----------------------------------------------------------------------------
+
+/**
+ * Hook for managing Pair Writing Mode state.
+ *
+ * State is session-scoped: snapshot is cleared when deactivating Pair Writing
+ * Mode (REQ-F-27). Conversation state is now managed by SessionContext (shared
+ * with the Discussion component).
+ *
+ * @example
+ * ```tsx
+ * const { state, actions } = usePairWritingState();
+ *
+ * // Enter Pair Writing Mode
+ * actions.activate(fileContent);
+ *
+ * // Take a snapshot before editing
+ * actions.takeSnapshot();
+ *
+ * // Update content as user types
+ * actions.setContent(newContent);
+ *
+ * // Exit (clears snapshot)
+ * actions.clearAll();
+ * ```
+ */
+export function usePairWritingState(): {
+  state: PairWritingState;
+  actions: PairWritingActions;
+} {
+  const [state, dispatch] = useReducer(pairWritingReducer, undefined, createInitialState);
+
+  const activate = useCallback((content: string) => {
+    dispatch({ type: "ACTIVATE", content });
+  }, []);
+
+  const deactivate = useCallback(() => {
+    dispatch({ type: "DEACTIVATE" });
+  }, []);
+
+  const setContent = useCallback((content: string) => {
+    dispatch({ type: "SET_CONTENT", content });
+  }, []);
+
+  const takeSnapshot = useCallback(() => {
+    dispatch({ type: "TAKE_SNAPSHOT" });
+  }, []);
+
+  const clearSnapshot = useCallback(() => {
+    dispatch({ type: "CLEAR_SNAPSHOT" });
+  }, []);
+
+  const clearAll = useCallback(() => {
+    dispatch({ type: "DEACTIVATE" });
+  }, []);
+
+  const markSaved = useCallback(() => {
+    dispatch({ type: "MARK_SAVED" });
+  }, []);
+
+  const reloadContent = useCallback((content: string) => {
+    dispatch({ type: "RELOAD_CONTENT", content });
+  }, []);
+
+  return {
+    state,
+    actions: {
+      activate,
+      deactivate,
+      setContent,
+      takeSnapshot,
+      clearSnapshot,
+      clearAll,
+      markSaved,
+      reloadContent,
+    },
+  };
+}
diff --git a/frontend/src/hooks/useTextSelection.ts b/frontend/src/hooks/useTextSelection.ts
new file mode 100644
index 00000000..fb75a21f
--- /dev/null
+++ b/frontend/src/hooks/useTextSelection.ts
@@ -0,0 +1,311 @@
+/**
+ * useTextSelection Hook
+ *
+ * Tracks the current text selection within an element and provides
+ * context information for AI-assisted text revision.
+ *
+ * Features:
+ * - Listens for selection changes via Selection API
+ * - Calculates line numbers (1-indexed)
+ * - Extracts paragraph context (delimited by \n\n)
+ * - Returns null when no text is selected
+ *
+ * Spec Requirements:
+ * - REQ-F-4: Selection + surrounding context sent to Claude
+ * - TD-4: Paragraph context extraction (one paragraph before/after)
+ */
+
+import { useState, useEffect, useCallback, useRef } from "react";
+
+/**
+ * Context information about the current text selection.
+ * Used for Quick Actions and Advisory Actions in Pair Writing Mode.
+ */
+export interface SelectionContext {
+  /** The selected text */
+  text: string;
+  /** 1-indexed line number where selection starts */
+  startLine: number;
+  /** 1-indexed line number where selection ends */
+  endLine: number;
+  /** Total lines in the document */
+  totalLines: number;
+  /** Paragraph before the selection (delimited by \n\n) */
+  contextBefore: string;
+  /** Paragraph after the selection (delimited by \n\n) */
+  contextAfter: string;
+}
+
+/**
+ * Return type for the useTextSelection hook.
+ */
+export interface UseTextSelectionResult {
+  /** Current selection context, or null if no selection */
+  selection: SelectionContext | null;
+  /** Manually clear the selection state */
+  clearSelection: () => void;
+}
+
+/**
+ * Counts the number of newlines before a given position in text.
+ * Returns the 1-indexed line number.
+ */
+export function getLineNumber(text: string, position: number): number {
+  const clampedPosition = Math.min(position, text.length);
+  const textBefore = text.substring(0, clampedPosition);
+  const newlines = (textBefore.match(/\n/g) ?? []).length;
+  return newlines + 1;
+}
+
+/**
+ * Counts total lines in text (number of newlines + 1).
+ */
+export function countTotalLines(text: string): number {
+  if (text === "") return 1;
+  const newlines = (text.match(/\n/g) ?? []).length;
+  return newlines + 1;
+}
+
+/**
+ * Extracts the paragraph before a given position.
+ * Paragraphs are delimited by blank lines (\n\n).
+ * Returns the full paragraph text (without trailing delimiter).
+ */
+export function extractParagraphBefore(
+  text: string,
+  selectionStart: number
+): string {
+  if (selectionStart === 0) return "";
+
+  const textBefore = text.substring(0, selectionStart);
+
+  // Find the last paragraph delimiter before selection
+  const lastDelimiter = textBefore.lastIndexOf("\n\n");
+
+  if (lastDelimiter === -1) {
+    // No delimiter found, everything before selection is the context
+    // But we want the paragraph, not partial text, so return empty
+    // Actually per spec, we want the preceding paragraph content
+    // If no delimiter, the "paragraph before" doesn't exist
+    return "";
+  }
+
+  // Find the start of that paragraph (look for another \n\n before it)
+  const paragraphStart = textBefore.lastIndexOf("\n\n", lastDelimiter - 1);
+
+  if (paragraphStart === -1) {
+    // The paragraph starts at the beginning of the document
+    return textBefore.substring(0, lastDelimiter).trim();
+  }
+
+  // Extract the paragraph between the two delimiters
+  return textBefore.substring(paragraphStart + 2, lastDelimiter).trim();
+}
+
+/**
+ * Extracts the paragraph after a given position.
+ * Paragraphs are delimited by blank lines (\n\n).
+ * Returns the full paragraph text (without leading delimiter).
+ */
+export function extractParagraphAfter(
+  text: string,
+  selectionEnd: number
+): string {
+  if (selectionEnd >= text.length) return "";
+
+  const textAfter = text.substring(selectionEnd);
+
+  // Find the first paragraph delimiter after selection
+  const firstDelimiter = textAfter.indexOf("\n\n");
+
+  if (firstDelimiter === -1) {
+    // No delimiter found, no complete paragraph after
+    return "";
+  }
+
+  // Find the end of the next paragraph (another \n\n or end of text)
+  const nextDelimiter = textAfter.indexOf("\n\n", firstDelimiter + 2);
+
+  if (nextDelimiter === -1) {
+    // Paragraph extends to end of document
+    return textAfter.substring(firstDelimiter + 2).trim();
+  }
+
+  // Extract the paragraph between the two delimiters
+  return textAfter.substring(firstDelimiter + 2, nextDelimiter).trim();
+}
+
+/**
+ * Extracts full selection context from document content.
+ * This is the core logic used by the hook, exposed for testing.
+ */
+export function extractSelectionContext(
+  content: string,
+  selectionStart: number,
+  selectionEnd: number
+): SelectionContext | null {
+  // Validate inputs
+  if (selectionStart < 0 || selectionEnd < 0) return null;
+  if (selectionStart > content.length || selectionEnd > content.length)
+    return null;
+  if (selectionStart >= selectionEnd) return null;
+
+  const selectedText = content.substring(selectionStart, selectionEnd);
+
+  // Empty or whitespace-only selection is treated as no selection
+  if (selectedText.trim() === "") return null;
+
+  return {
+    text: selectedText,
+    startLine: getLineNumber(content, selectionStart),
+    endLine: getLineNumber(content, selectionEnd),
+    totalLines: countTotalLines(content),
+    contextBefore: extractParagraphBefore(content, selectionStart),
+    contextAfter: extractParagraphAfter(content, selectionEnd),
+  };
+}
+
+/**
+ * Gets selection information from a textarea or contenteditable element.
+ * Returns start/end offsets or null if element doesn't support selection.
+ */
+function getElementSelection(
+  element: HTMLElement
+): { start: number; end: number } | null {
+  if (element instanceof HTMLTextAreaElement) {
+    return {
+      start: element.selectionStart,
+      end: element.selectionEnd,
+    };
+  }
+
+  // For contenteditable elements, use Selection API
+  const selection = window.getSelection();
+  if (!selection || selection.rangeCount === 0) return null;
+
+  const range = selection.getRangeAt(0);
+
+  // Check if selection is within our element
+  if (!element.contains(range.commonAncestorContainer)) return null;
+
+  // Calculate offsets relative to the element's text content
+  const preCaretRange = range.cloneRange();
+  preCaretRange.selectNodeContents(element);
+  preCaretRange.setEnd(range.startContainer, range.startOffset);
+  const start = preCaretRange.toString().length;
+
+  preCaretRange.setEnd(range.endContainer, range.endOffset);
+  const end = preCaretRange.toString().length;
+
+  return { start, end };
+}
+
+/**
+ * React hook for tracking text selection within an element.
+ *
+ * @param elementRef - Ref to the element to track selection in (textarea or contenteditable)
+ * @param content - The current text content of the element
+ * @returns Selection context or null if no selection
+ *
+ * @example
+ * ```tsx
+ * const textareaRef = useRef<HTMLTextAreaElement>(null);
+ * const [content, setContent] = useState("");
+ * const { selection } = useTextSelection(textareaRef, content);
+ *
+ * if (selection) {
+ *   console.log(`Selected "${selection.text}" on lines ${selection.startLine}-${selection.endLine}`);
+ * }
+ * ```
+ */
+export function useTextSelection(
+  elementRef: React.RefObject<HTMLElement | null>,
+  content: string
+): UseTextSelectionResult {
+  const [selection, setSelection] = useState<SelectionContext | null>(null);
+
+  // Keep content ref for use in event handlers
+  const contentRef = useRef(content);
+  contentRef.current = content;
+
+  const clearSelection = useCallback(() => {
+    setSelection(null);
+  }, []);
+
+  // Update selection on selection change events
+  const updateSelection = useCallback(() => {
+    const element = elementRef.current;
+    if (!element) {
+      setSelection(null);
+      return;
+    }
+
+    const elementSelection = getElementSelection(element);
+    if (!elementSelection) {
+      setSelection(null);
+      return;
+    }
+
+    const context = extractSelectionContext(
+      contentRef.current,
+      elementSelection.start,
+      elementSelection.end
+    );
+
+    setSelection(context);
+  }, [elementRef]);
+
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element) return;
+
+    // For textarea, listen to select event
+    if (element instanceof HTMLTextAreaElement) {
+      const handleSelect = () => updateSelection();
+      const handleMouseUp = () => updateSelection();
+      const handleKeyUp = (e: KeyboardEvent) => {
+        // Update on shift+arrow keys (selection change)
+        if (e.shiftKey || e.key === "Escape") {
+          updateSelection();
+        }
+      };
+
+      element.addEventListener("select", handleSelect);
+      element.addEventListener("mouseup", handleMouseUp);
+      element.addEventListener("keyup", handleKeyUp);
+
+      return () => {
+        element.removeEventListener("select", handleSelect);
+        element.removeEventListener("mouseup", handleMouseUp);
+        element.removeEventListener("keyup", handleKeyUp);
+      };
+    }
+
+    // For contenteditable, listen to document selectionchange
+    const handleSelectionChange = () => {
+      updateSelection();
+    };
+
+    document.addEventListener("selectionchange", handleSelectionChange);
+
+    return () => {
+      document.removeEventListener("selectionchange", handleSelectionChange);
+    };
+  }, [elementRef, updateSelection]);
+
+  // Clear selection when content changes
+  // We don't have the original character positions, so we can't revalidate.
+  // User will re-select if needed.
+  useEffect(() => {
+    if (selection) {
+      setSelection(null);
+    }
+    // Intentionally only depend on content, not selection.
+    // We want to clear when content changes, not re-run when selection changes.
+  }, [content]);
+
+  return {
+    selection,
+    clearSelection,
+  };
+}
diff --git a/shared/src/index.ts b/shared/src/index.ts
index c2e38ea1..3481414c 100644
--- a/shared/src/index.ts
+++ b/shared/src/index.ts
@@ -139,6 +139,11 @@ export type {
   AskUserQuestionItem,
   AskUserQuestionResponseMessage,
   AskUserQuestionRequestMessage,
+  // Pair Writing types
+  QuickActionType,
+  QuickActionRequestMessage,
+  AdvisoryActionType,
+  AdvisoryActionRequestMessage,
   // Client message types
   SelectVaultMessage,
   CaptureNoteMessage,
diff --git a/shared/src/protocol.ts b/shared/src/protocol.ts
index 9c924272..e07f826f 100644
--- a/shared/src/protocol.ts
+++ b/shared/src/protocol.ts
@@ -686,6 +686,77 @@ export const CreateVaultMessageSchema = z.object({
   title: z.string().min(1, "Vault title is required"),
 });
 
+// =============================================================================
+// Pair Writing Mode Client Messages
+// =============================================================================
+
+/**
+ * Action types for Quick Actions (transformative, all platforms)
+ * - tighten: Make more concise without losing meaning
+ * - embellish: Add detail, nuance, or context
+ * - correct: Fix typos and grammar only
+ * - polish: Correct + improve prose
+ */
+export const QuickActionTypeSchema = z.enum(["tighten", "embellish", "correct", "polish"]);
+
+/**
+ * Action types for Advisory Actions (Pair Writing Mode, desktop only)
+ * - validate: Fact-check the claim
+ * - critique: Analyze clarity, voice, structure
+ * - compare: Compare current text to snapshot
+ */
+export const AdvisoryActionTypeSchema = z.enum(["validate", "critique", "compare"]);
+
+/**
+ * Client requests a Quick Action on selected text (all platforms)
+ * Claude uses Read/Edit tools to modify the file directly
+ */
+export const QuickActionRequestMessageSchema = z.object({
+  type: z.literal("quick_action_request"),
+  /** The action to perform */
+  action: QuickActionTypeSchema,
+  /** The selected text to transform */
+  selection: z.string().min(1, "Selection is required"),
+  /** Paragraph before the selection (for context) */
+  contextBefore: z.string(),
+  /** Paragraph after the selection (for context) */
+  contextAfter: z.string(),
+  /** Path to the file being edited (relative to content root) */
+  filePath: z.string().min(1, "File path is required"),
+  /** 1-indexed line number where selection starts */
+  selectionStartLine: z.number().int().min(1, "Selection start line must be at least 1"),
+  /** 1-indexed line number where selection ends */
+  selectionEndLine: z.number().int().min(1, "Selection end line must be at least 1"),
+  /** Total lines in the document (for position hint calculation) */
+  totalLines: z.number().int().min(1, "Total lines must be at least 1"),
+});
+
+/**
+ * Client requests an Advisory Action on selected text (Pair Writing Mode, desktop)
+ * Response appears in conversation pane; user manually applies changes
+ */
+export const AdvisoryActionRequestMessageSchema = z.object({
+  type: z.literal("advisory_action_request"),
+  /** The advisory action to perform */
+  action: AdvisoryActionTypeSchema,
+  /** The selected text to analyze */
+  selection: z.string().min(1, "Selection is required"),
+  /** Paragraph before the selection (for context) */
+  contextBefore: z.string(),
+  /** Paragraph after the selection (for context) */
+  contextAfter: z.string(),
+  /** Path to the file being edited (relative to content root) */
+  filePath: z.string().min(1, "File path is required"),
+  /** 1-indexed line number where selection starts */
+  selectionStartLine: z.number().int().min(1, "Selection start line must be at least 1"),
+  /** 1-indexed line number where selection ends */
+  selectionEndLine: z.number().int().min(1, "Selection end line must be at least 1"),
+  /** Total lines in the document (for position hint calculation) */
+  totalLines: z.number().int().min(1, "Total lines must be at least 1"),
+  /** For compare action: the corresponding text from the snapshot */
+  snapshotSelection: z.string().optional(),
+});
+
 // =============================================================================
 // Memory Extraction Client Messages
 // =============================================================================
@@ -787,6 +858,9 @@ export const ClientMessageSchema = z.discriminatedUnion("type", [
   SetPinnedAssetsMessageSchema,
   UpdateVaultConfigMessageSchema,
   CreateVaultMessageSchema,
+  // Pair Writing Mode
+  QuickActionRequestMessageSchema,
+  AdvisoryActionRequestMessageSchema,
   // Memory Extraction
   GetMemoryMessageSchema,
   SaveMemoryMessageSchema,
@@ -1558,6 +1632,11 @@ export type GetPinnedAssetsMessage = z.infer<typeof GetPinnedAssetsMessageSchema
 export type SetPinnedAssetsMessage = z.infer<typeof SetPinnedAssetsMessageSchema>;
 export type UpdateVaultConfigMessage = z.infer<typeof UpdateVaultConfigMessageSchema>;
 export type CreateVaultMessage = z.infer<typeof CreateVaultMessageSchema>;
+// Pair Writing Mode types
+export type QuickActionType = z.infer<typeof QuickActionTypeSchema>;
+export type AdvisoryActionType = z.infer<typeof AdvisoryActionTypeSchema>;
+export type QuickActionRequestMessage = z.infer<typeof QuickActionRequestMessageSchema>;
+export type AdvisoryActionRequestMessage = z.infer<typeof AdvisoryActionRequestMessageSchema>;
 export type GetMemoryMessage = z.infer<typeof GetMemoryMessageSchema>;
 export type SaveMemoryMessage = z.infer<typeof SaveMemoryMessageSchema>;
 export type GetExtractionPromptMessage = z.infer<typeof GetExtractionPromptMessageSchema>;