diff --git a/README.md b/README.md
index 03dfecc..efb6140 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,9 @@ Chromium Manifest V3 **browser extension** for **FOC TPMs and team members** wor
 
 ## Features
 
-1. **Make FOC's project board "global" (i.e., support cross-org issues and PRs)** — Manage the board (add items, edit fields where the API allows) from GitHub issues and pull requests on configured repos, with a native-style sidebar and **autosave** for supported field types (single select, number, text, iteration).
+1. **Make FOC’s project board "global" (i.e., support cross-org issues and PRs)** — Manage the board (add items, edit fields where the API allows) from GitHub issues and pull requests on configured repos, with a native-style sidebar and **autosave** for supported field types (single select, number, text, iteration).
 2. **Global auto-expand for project panels** — Optional setting so GitHub’s right-hand **Project** panel **auto-expands** for issues and PRs (works across projects, not only FOC).
+3. **OR filter for project boards** — Enter OR queries in the project board filter bar (e.g. `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)`) to see merged results from multiple filter branches in a single view. The extension splits the query, fetches each branch separately, deduplicates, and renders the combined results through GitHub’s native UI.  This is particularly useful during standups where you want to see all your active and recently completed work in a single view. Configure which boards support this in **Options → OR filter for project boards** (defaults to all FilOzone projects).
 
 ### 🎥 2026-03-29 Demo
 
diff --git a/docs/canonical-test-urls.md b/docs/canonical-test-urls.md
index e68e708..5fc4a53 100644
--- a/docs/canonical-test-urls.md
+++ b/docs/canonical-test-urls.md
@@ -60,6 +60,27 @@ Use this when validating **Options → expand Project panel** (and related conte
 
 **Expectation**: With auto-expand on, native **Projects** sections **expand** as implemented for this feature ([spec 003](../specs/003-auto-expand-panels/spec.md)); the **inline FOC** card from scenarios 3–6 still follows global-board / target-repo rules and is unrelated to this check.
 
+## Project Board OR Filter (spec 007)
+
+Use these URLs when verifying the **OR query filter** on project board views ([spec 007](../specs/007-project-board-or-filter/spec.md)).
+
+| View | URL | Notes |
+|------|-----|-------|
+| Current by Status | [FilOzone/projects/14/views/20](https://github.com/orgs/FilOzone/projects/14/views/20) | Grouped by Status, filtered by cycle. Primary test view. |
+| All | [FilOzone/projects/14/views/2](https://github.com/orgs/FilOzone/projects/14/views/2) | Large item set (~360 items), exercises pagination. |
+| Recently Updated | [FilOzone/projects/14/views/33](https://github.com/orgs/FilOzone/projects/14/views/33) | Different sort/filter configuration. |
+
+### Test queries
+
+| Query | Expected |
+|-------|----------|
+| `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)` | Merged results from both branches, no duplicates |
+| `(-status:"🎉 Done") OR (-last-updated:1days)` | Two branches with no shared prefix |
+| `cycle:202605-2 -status:"🎉 Done"` | Non-OR query — native pass-through, unchanged behavior |
+| `((nested))` | Invalid OR — native pass-through, console warning |
+| `(a) OR (b) trailing` | Invalid OR — native pass-through, console warning |
+| `(a OR b)` | Invalid OR — native pass-through, console warning |
+
 ## Related docs
 
 - [Global boards picker status](global-boards-picker-status.md) — picker vs sidebar scope.
diff --git a/extension/manifest.json b/extension/manifest.json
index 6f2d592..15ae5ba 100644
--- a/extension/manifest.json
+++ b/extension/manifest.json
@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "FOC GH",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Utilities for FOC team members working in GitHub.",
   "icons": {
     "16": "icons/icon16.png",
@@ -36,11 +36,18 @@
       ],
       "js": ["content.js"],
       "run_at": "document_idle"
+    },
+    {
+      "matches": [
+        "https://github.com/orgs/*/projects/*/views/*"
+      ],
+      "js": ["board-filter.js"],
+      "run_at": "document_start"
     }
   ],
   "web_accessible_resources": [
     {
-      "resources": ["sidebar.css", "pr-expand-main-world.js"],
+      "resources": ["sidebar.css", "pr-expand-main-world.js", "board-data-injector.js"],
       "matches": ["https://github.com/*"]
     }
   ]
diff --git a/extension/src/content/board-filter/board-data-injector.ts b/extension/src/content/board-filter/board-data-injector.ts
new file mode 100644
index 0000000..fdc67d0
--- /dev/null
+++ b/extension/src/content/board-filter/board-data-injector.ts
@@ -0,0 +1,267 @@
+/**
+ * Main-world fetch interceptor for project board OR queries.
+ *
+ * Runs in the PAGE's main world (injected via <script src> from board-filter-main.ts).
+ * Monkey-patches window.fetch to intercept calls to /memexes/{id}/paginated_items.
+ *
+ * On every paginated_items fetch, reads the filter bar's current value and checks
+ * for OR syntax. If found, intercepts the call, runs multi-branch fetch + merge,
+ * and returns the merged response. If not, passes through unchanged.
+ *
+ * Strategy: clone the original intercepted URL and only replace the `q` parameter
+ * for each branch. This preserves all native params (sortedBy, groupedBy, sliceBy,
+ * fieldIds, layout, sumFields, hierarchy) exactly as the React app sends them.
+ */
+
+import type { GroupedItemsResponse, GroupItems } from './memex-api.js'
+import { mergeResponses } from './result-merger.js'
+import { parseORQuery } from './or-query-parser.js'
+
+// Guard against double-injection (Turbo SPA navigation can re-run content scripts)
+if ((window as unknown as Record<string, unknown>).__filozFetchInterceptorInstalled) {
+  // Already installed — skip
+} else {
+(window as unknown as Record<string, unknown>).__filozFetchInterceptorInstalled = true
+
+const originalFetch = window.fetch.bind(window)
+
+/** Track in-flight OR query so we can abort on supersession. */
+let activeController: AbortController | null = null
+
+/**
+ * Fetch a single page and return the parsed JSON.
+ */
+async function fetchJson(url: string, signal?: AbortSignal): Promise<GroupedItemsResponse> {
+  const resp = await originalFetch(url, {
+    credentials: 'same-origin',
+    headers: {
+      Accept: 'application/json',
+      'X-Requested-With': 'XMLHttpRequest',
+    },
+    signal,
+  })
+  if (!resp.ok) {
+    throw new Error(`paginated_items fetch failed: ${resp.status} ${resp.statusText}`)
+  }
+  return resp.json()
+}
+
+/**
+ * Clone a URL and replace the `q` parameter while removing pagination cursors.
+ */
+function cloneUrlWithQuery(originalUrl: URL, query: string): string {
+  const cloned = new URL(originalUrl.href)
+  cloned.searchParams.set('q', query)
+  // Remove pagination params — we want the first page for each branch
+  cloned.searchParams.delete('after')
+  // Remove group-scoped pagination (groupedBy[value]) — we want all groups
+  cloned.searchParams.delete('groupedBy[value]')
+  return cloned.href
+}
+
+/**
+ * Build a pagination URL for a specific group within a branch response.
+ */
+function buildPaginationUrl(originalUrl: URL, query: string, group: GroupItems, endCursor: string): string {
+  const cloned = new URL(originalUrl.href)
+  cloned.searchParams.set('q', query)
+  cloned.searchParams.set('after', endCursor)
+  // Scope pagination to the specific group
+  cloned.searchParams.set('groupedBy[value]', group.groupId)
+  return cloned.href
+}
+
+/**
+ * Fetch all items for a single branch query, following pagination cursors per group.
+ */
+async function fetchBranch(
+  originalUrl: URL,
+  query: string,
+  signal: AbortSignal,
+): Promise<GroupedItemsResponse> {
+  const firstUrl = cloneUrlWithQuery(originalUrl, query)
+  console.log('[FilOz] Branch fetch:', query, '→', firstUrl)
+  const first = await fetchJson(firstUrl, signal)
+
+  // Follow pagination within each group
+  const groupedItems: GroupItems[] = first.groupedItems.map((g) => ({
+    ...g,
+    nodes: [...g.nodes],
+  }))
+
+  for (let idx = 0; idx < groupedItems.length; idx++) {
+    let current = groupedItems[idx]
+    while (current.pageInfo?.hasNextPage && current.pageInfo.endCursor) {
+      const nextUrl = buildPaginationUrl(originalUrl, query, current, current.pageInfo.endCursor)
+      const nextPage = await fetchJson(nextUrl, signal)
+      // When paginating with groupedBy[value], the API may return only the
+      // requested group (at index 0), not at the original group index.
+      // Find the matching group by groupId rather than assuming index alignment.
+      const nextGroup = nextPage.groupedItems?.find(
+        (g) => g.groupId === current.groupId,
+      ) ?? nextPage.groupedItems?.[0]
+      if (!nextGroup) break
+      groupedItems[idx].nodes.push(...nextGroup.nodes)
+      current = nextGroup
+    }
+    groupedItems[idx].pageInfo = {
+      ...groupedItems[idx].pageInfo,
+      hasNextPage: false,
+    }
+  }
+
+  return { ...first, groupedItems }
+}
+
+/**
+ * Execute multi-branch fetch and merge for an OR query.
+ */
+async function executeBranchFetches(
+  originalUrl: URL,
+  prefix: string,
+  branches: string[],
+): Promise<GroupedItemsResponse> {
+  // Abort any previous in-flight OR query
+  activeController?.abort()
+  const controller = new AbortController()
+  activeController = controller
+
+  const branchQueries = branches.map((branch) =>
+    prefix ? `${prefix} ${branch}` : branch,
+  )
+
+  console.log('[FilOz] Fetching', branchQueries.length, 'branches:', branchQueries)
+
+  const results = await Promise.all(
+    branchQueries.map((query) => fetchBranch(originalUrl, query, controller.signal)),
+  )
+
+  activeController = null
+  const merged = mergeResponses(results)
+  console.log('[FilOz] Merged results:', merged.totalCount.value, 'items')
+  return merged
+}
+
+// Monkey-patch fetch
+window.fetch = async function patchedFetch(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): Promise<Response> {
+  // Parse the URL from the request
+  let url: URL
+  try {
+    const rawUrl = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url
+    url = new URL(rawUrl, window.location.origin)
+  } catch {
+    return originalFetch(input, init)
+  }
+
+  // Only intercept initial paginated_items requests (not pagination follow-ups)
+  const match = url.pathname.match(/\/memexes\/(\d+)\/paginated_items/)
+  if (!match) return originalFetch(input, init)
+
+  // Skip pagination requests (these are follow-ups we handle internally)
+  if (url.searchParams.has('after')) return originalFetch(input, init)
+
+  // Read the filter bar's current value to check for OR syntax
+  const filterInput = document.querySelector<HTMLInputElement>('input#filter-bar-component-input')
+  if (!filterInput) return originalFetch(input, init)
+
+  const filterText = filterInput.value
+  const parseResult = parseORQuery(filterText)
+
+  if (parseResult.kind !== 'or_query') {
+    if (parseResult.kind === 'invalid_or') {
+      console.warn('[FilOz] Invalid OR syntax, passing through:', parseResult.error.message)
+    }
+    return originalFetch(input, init)
+  }
+
+  const { prefix, branches } = parseResult.query
+
+  console.log('[FilOz] Intercepted paginated_items for OR query, memex', match[1])
+
+  try {
+    const merged = await executeBranchFetches(url, prefix, branches)
+
+    return new Response(JSON.stringify(merged), {
+      status: 200,
+      statusText: 'OK',
+      headers: { 'Content-Type': 'application/json' },
+    })
+  } catch (err) {
+    if (err instanceof DOMException && err.name === 'AbortError') {
+      console.log('[FilOz] OR query fetch aborted (superseded)')
+      throw err
+    }
+    console.error('[FilOz] OR query fetch failed, falling through to native:', err)
+    return originalFetch(input, init)
+  }
+} as typeof fetch
+
+console.log('[FilOz] Fetch interceptor installed')
+
+/**
+ * Handle initial page load with an OR query in the URL.
+ *
+ * On initial load, GitHub server-renders 0 results (it doesn't understand OR).
+ * Fix: wait for the filter bar, then append a space via execCommand. This
+ * creates a trusted InputEvent that React sees as a filter change. The new
+ * query (with trailing space) isn't in React's cache, so it fires a fresh
+ * paginated_items fetch — which our interceptor catches and returns merged
+ * data. The trailing space doesn't affect OR parsing (we trim).
+ *
+ * Important: do NOT remove the space afterward. React caches query results,
+ * and restoring the original text would return the cached 0-result response.
+ */
+function handleInitialOrQuery(): void {
+  const urlParams = new URLSearchParams(window.location.search)
+  const filterQuery = urlParams.get('filterQuery')
+  if (!filterQuery) return
+
+  const result = parseORQuery(filterQuery)
+  if (result.kind !== 'or_query') return
+
+  console.log('[FilOz] OR query in URL on initial load, will nudge filter bar')
+
+  function waitAndNudge(): void {
+    const input = document.querySelector<HTMLInputElement>('input#filter-bar-component-input')
+    if (input) {
+      nudge(input)
+      return
+    }
+    const observer = new MutationObserver(() => {
+      const el = document.querySelector<HTMLInputElement>('input#filter-bar-component-input')
+      if (!el) return
+      observer.disconnect()
+      nudge(el)
+    })
+    observer.observe(document.documentElement, { childList: true, subtree: true })
+    setTimeout(() => observer.disconnect(), 15_000)
+  }
+
+  function nudge(input: HTMLInputElement): void {
+    // Wait for React to finish mounting and the filter to be interactive
+    setTimeout(() => {
+      input.focus()
+      const val = input.value
+      if (val.endsWith(' ')) {
+        // Trailing space exists — remove it by selecting it and deleting
+        console.log('[FilOz] Nudging filter: removing trailing space to trigger re-fetch')
+        input.setSelectionRange(val.length - 1, val.length)
+        document.execCommand('delete')
+      } else {
+        // No trailing space — add one
+        console.log('[FilOz] Nudging filter: appending space to trigger re-fetch')
+        input.setSelectionRange(val.length, val.length)
+        document.execCommand('insertText', false, ' ')
+      }
+    }, 500)
+  }
+
+  waitAndNudge()
+}
+
+handleInitialOrQuery()
+
+} // end guard
diff --git a/extension/src/content/board-filter/board-filter-main.ts b/extension/src/content/board-filter/board-filter-main.ts
new file mode 100644
index 0000000..8eed495
--- /dev/null
+++ b/extension/src/content/board-filter/board-filter-main.ts
@@ -0,0 +1,52 @@
+/**
+ * Board Filter content script entry point.
+ *
+ * Architecture: content script (this file) → main-world script (board-data-injector.ts)
+ *   → fetch interception → merge
+ *
+ * Runs at document_start to inject the main-world fetch interceptor BEFORE
+ * GitHub's React app initializes. This is critical so the interceptor can
+ * patch window.fetch before the React app makes its first API call.
+ *
+ * The config check (which boards are enabled) runs async but the injection
+ * must happen synchronously at startup to avoid missing the initial fetch.
+ * If the board doesn't match the config, the injector is a no-op (it only
+ * activates when OR syntax is detected in the filter bar).
+ */
+
+import { loadConfig, isOrFilterBoard } from '../../lib/project-config.js'
+
+const LOG_PREFIX = '[FilOz:board-filter]'
+
+/** Inject the main-world fetch interceptor immediately. */
+function injectMainWorldScript(): void {
+  const id = 'filoz-board-data-injector'
+  if (document.getElementById(id)) return
+
+  const script = document.createElement('script')
+  script.id = id
+  script.src = chrome.runtime.getURL('board-data-injector.js')
+  ;(document.head ?? document.documentElement).appendChild(script)
+  console.log(LOG_PREFIX, 'Main-world interceptor injected')
+}
+
+// Check the URL — if it looks like a project board, inject immediately.
+// The config check runs async afterward; the injector is harmless on
+// non-configured boards (only activates when OR syntax is in the filter bar).
+const url = window.location.href
+if (/github\.com\/orgs\/[^/]+\/projects\/\d+\/views\/\d+/.test(url)) {
+  console.log(LOG_PREFIX, 'Content script loaded (document_start)')
+  injectMainWorldScript()
+
+  // Async config check — if the board doesn't match, remove the injector
+  void loadConfig().then((cfg) => {
+    const baseUrl = url.replace(/\/views\/\d+.*$/, '')
+    if (!isOrFilterBoard(cfg, baseUrl)) {
+      console.log(LOG_PREFIX, 'OR filter not enabled for this board, disabling')
+      // Signal the injector to deactivate
+      document.dispatchEvent(new CustomEvent('filoz-or-filter-disabled'))
+    } else {
+      console.log(LOG_PREFIX, 'OR filter enabled for this board')
+    }
+  })
+}
diff --git a/extension/src/content/board-filter/memex-api.ts b/extension/src/content/board-filter/memex-api.ts
new file mode 100644
index 0000000..b15e57e
--- /dev/null
+++ b/extension/src/content/board-filter/memex-api.ts
@@ -0,0 +1,60 @@
+/**
+ * Type definitions for GitHub's internal memex paginated items API.
+ *
+ * These types describe the response shape from GET /memexes/{id}/paginated_items.
+ * Used by board-data-injector.ts (fetch interception) and result-merger.ts (merging).
+ */
+
+export interface GroupNode {
+  groupValue: string
+  groupId: string
+  groupMetadata: {
+    id: string
+    name: string
+    nameHtml: string
+    color: string
+    description: string
+    descriptionHtml: string
+  }
+  totalCount: { value: number; isApproximate: boolean }
+  fieldMetrics: unknown[]
+}
+
+export interface MemexItem {
+  id: number
+  contentId: number
+  contentType: 'Issue' | 'PullRequest'
+  contentRepositoryId: number
+  updatedAt: string
+  createdAt: string
+  state: string
+  memexProjectColumnValues: { memexProjectColumnId: string | number; value: unknown }[]
+  content: unknown
+  [key: string]: unknown
+}
+
+export interface PageInfo {
+  startCursor?: string
+  endCursor: string
+  hasNextPage: boolean
+  hasPreviousPage?: boolean
+}
+
+export interface GroupItems {
+  groupId: string
+  nodes: MemexItem[]
+  pageInfo: PageInfo
+}
+
+export interface SliceInfo {
+  sliceId: string
+  sliceValue: string
+  totalCount: { value: number; isApproximate: boolean }
+}
+
+export interface GroupedItemsResponse {
+  groups: { nodes: GroupNode[]; pageInfo: PageInfo }
+  groupedItems: GroupItems[]
+  slices: SliceInfo[]
+  totalCount: { value: number; isApproximate: boolean }
+}
diff --git a/extension/src/content/board-filter/or-query-parser.ts b/extension/src/content/board-filter/or-query-parser.ts
new file mode 100644
index 0000000..342dfbe
--- /dev/null
+++ b/extension/src/content/board-filter/or-query-parser.ts
@@ -0,0 +1,133 @@
+/**
+ * OR Query Parser
+ *
+ * Parses a project board filter string for OR syntax and returns
+ * a structured representation of the query branches.
+ *
+ * Valid syntax: "shared-prefix (branch-1) OR (branch-2) [OR (branch-N)]"
+ */
+
+export interface ORQuery {
+  prefix: string
+  branches: string[]
+  raw: string
+}
+
+export interface ORParseError {
+  type: 'nested_parens' | 'trailing_terms' | 'or_inside_parens' | 'single_branch' | 'too_many_branches'
+  message: string
+  raw: string
+}
+
+export type ORParseResult =
+  | { kind: 'or_query'; query: ORQuery }
+  | { kind: 'plain_query'; raw: string }
+  | { kind: 'invalid_or'; error: ORParseError }
+
+const MAX_BRANCHES = 5
+
+export function parseORQuery(filterText: string): ORParseResult {
+  const raw = filterText.trim()
+  if (!raw) return { kind: 'plain_query', raw }
+
+  // Quick check: does this contain parentheses at all?
+  if (!raw.includes('(')) return { kind: 'plain_query', raw }
+
+  // Check for nested parentheses: (( or )) patterns
+  if (/\(\s*\(/.test(raw) || /\)\s*\)/.test(raw)) {
+    return {
+      kind: 'invalid_or',
+      error: { type: 'nested_parens', message: 'Nested parentheses are not supported', raw },
+    }
+  }
+
+  // Check for OR inside parentheses: (... OR ...)
+  // Match content inside parens and look for standalone OR keyword
+  const parenContentRe = /\(([^)]*)\)/g
+  let match: RegExpExecArray | null
+  while ((match = parenContentRe.exec(raw)) !== null) {
+    // Check for standalone OR (word boundary) inside parens
+    if (/(?:^|\s)OR(?:\s|$)/.test(match[1])) {
+      return {
+        kind: 'invalid_or',
+        error: { type: 'or_inside_parens', message: 'OR keyword cannot appear inside parentheses', raw },
+      }
+    }
+  }
+
+  // Extract parenthesized groups and the text between them
+  // Build a structural view: prefix (group1) separator (group2) ... trailing
+  const groupRe = /\(([^)]*)\)/g
+  const groups: string[] = []
+  const groupPositions: { start: number; end: number }[] = []
+
+  let m: RegExpExecArray | null
+  while ((m = groupRe.exec(raw)) !== null) {
+    groups.push(m[1].trim())
+    groupPositions.push({ start: m.index, end: m.index + m[0].length })
+  }
+
+  if (groups.length === 0) return { kind: 'plain_query', raw }
+
+  // Check for text after the final closing paren
+  const afterLast = raw.slice(groupPositions[groupPositions.length - 1].end).trim()
+  if (afterLast) {
+    // If there are groups and OR keywords, this is invalid trailing terms
+    if (groups.length >= 2 || raw.includes(' OR ')) {
+      return {
+        kind: 'invalid_or',
+        error: { type: 'trailing_terms', message: 'Filter terms after the final group are not supported', raw },
+      }
+    }
+    // Otherwise it's just a plain query with parens (not OR syntax)
+    return { kind: 'plain_query', raw }
+  }
+
+  // Single group without OR — plain query
+  if (groups.length === 1) {
+    // Check if there's an OR keyword somewhere (malformed)
+    if (/(?:^|\s)OR(?:\s|$)/.test(raw)) {
+      return {
+        kind: 'invalid_or',
+        error: { type: 'single_branch', message: 'OR requires at least two parenthesized groups', raw },
+      }
+    }
+    return { kind: 'plain_query', raw }
+  }
+
+  // Multiple groups — verify OR separators between each pair
+  for (let i = 0; i < groupPositions.length - 1; i++) {
+    const between = raw.slice(groupPositions[i].end, groupPositions[i + 1].start).trim()
+    if (between !== 'OR') {
+      // Groups exist but aren't separated by OR — plain query
+      return { kind: 'plain_query', raw }
+    }
+  }
+
+  // Valid OR syntax — extract prefix and branches
+  const prefix = raw.slice(0, groupPositions[0].start).trim()
+  const branches = groups.filter((g) => g.length > 0)
+
+  if (branches.length < 2) {
+    return {
+      kind: 'invalid_or',
+      error: { type: 'single_branch', message: 'OR requires at least two non-empty branches', raw },
+    }
+  }
+
+  if (branches.length > MAX_BRANCHES) {
+    return {
+      kind: 'invalid_or',
+      error: {
+        type: 'too_many_branches',
+        message: `Maximum ${MAX_BRANCHES} OR branches supported, got ${branches.length}`,
+        raw,
+      },
+    }
+  }
+
+  return {
+    kind: 'or_query',
+    query: { prefix, branches, raw },
+  }
+}
diff --git a/extension/src/content/board-filter/result-merger.ts b/extension/src/content/board-filter/result-merger.ts
new file mode 100644
index 0000000..6a95936
--- /dev/null
+++ b/extension/src/content/board-filter/result-merger.ts
@@ -0,0 +1,98 @@
+/**
+ * Result Merger
+ *
+ * Merges multiple paginated items API responses (one per OR branch) into a single
+ * deduplicated response that the React app can render natively.
+ */
+
+import type { GroupedItemsResponse, GroupNode, MemexItem, GroupItems, SliceInfo } from './memex-api.js'
+
+/**
+ * Merge multiple API responses (one per OR branch) into a single response.
+ *
+ * - Deduplicates items by `item.id` (first occurrence wins)
+ * - Unions group metadata from all branches
+ * - Assigns items to correct groups based on their field values
+ * - Recalculates totalCount as the count of unique items
+ * - Merges slice data from all branches
+ */
+export function mergeResponses(responses: GroupedItemsResponse[]): GroupedItemsResponse {
+  if (responses.length === 0) {
+    return {
+      groups: { nodes: [], pageInfo: { endCursor: '', hasNextPage: false } },
+      groupedItems: [],
+      slices: [],
+      totalCount: { value: 0, isApproximate: false },
+    }
+  }
+  if (responses.length === 1) return responses[0]
+
+  // 1. Collect all unique groups across branches (by groupId)
+  const groupMap = new Map<string, GroupNode>()
+  const groupOrder: string[] = []
+  for (const resp of responses) {
+    for (const group of resp.groups.nodes) {
+      if (!groupMap.has(group.groupId)) {
+        groupMap.set(group.groupId, { ...group, totalCount: { value: 0, isApproximate: false } })
+        groupOrder.push(group.groupId)
+      }
+    }
+  }
+
+  // 2. Collect all unique items per group (deduplicate by id, first occurrence wins)
+  const seenIds = new Set<number>()
+  const itemsByGroup = new Map<string, MemexItem[]>()
+  for (const gid of groupOrder) itemsByGroup.set(gid, [])
+
+  for (const resp of responses) {
+    for (const groupItems of resp.groupedItems) {
+      const groupId = groupItems.groupId
+      if (!itemsByGroup.has(groupId)) {
+        itemsByGroup.set(groupId, [])
+      }
+      for (const item of groupItems.nodes) {
+        if (seenIds.has(item.id)) continue
+        seenIds.add(item.id)
+        itemsByGroup.get(groupId)!.push(item)
+      }
+    }
+  }
+
+  // 3. Build merged groupedItems array and update group totalCounts
+  const mergedGroupedItems: GroupItems[] = []
+  let totalItems = 0
+
+  for (const groupId of groupOrder) {
+    const items = itemsByGroup.get(groupId) ?? []
+    totalItems += items.length
+
+    const groupNode = groupMap.get(groupId)!
+    groupNode.totalCount = { value: items.length, isApproximate: false }
+
+    mergedGroupedItems.push({
+      groupId,
+      nodes: items,
+      pageInfo: { endCursor: '', hasNextPage: false },
+    })
+  }
+
+  // 4. Merge slices (union by sliceId, deduplicate)
+  const sliceMap = new Map<string, SliceInfo>()
+  for (const resp of responses) {
+    for (const slice of resp.slices ?? []) {
+      if (!sliceMap.has(slice.sliceId)) {
+        sliceMap.set(slice.sliceId, { ...slice })
+      }
+    }
+  }
+
+  return {
+    groups: {
+      nodes: groupOrder.map((gid) => groupMap.get(gid)!),
+      pageInfo: { endCursor: '', hasNextPage: false },
+    },
+    groupedItems: mergedGroupedItems,
+    slices: Array.from(sliceMap.values()),
+    totalCount: { value: totalItems, isApproximate: false },
+  }
+}
diff --git a/extension/src/lib/project-config.ts b/extension/src/lib/project-config.ts
index f1a661a..dc9cb0f 100644
--- a/extension/src/lib/project-config.ts
+++ b/extension/src/lib/project-config.ts
@@ -11,6 +11,8 @@ export const STORAGE_KEYS = {
   crossOrgTargetRepos: 'cross_org_target_repos',
   /** When true (default), FOC sidebar card field body loads expanded on issues/PRs. */
   issuePrProjectsAutoExpand: 'issue_pr_projects_auto_expand',
+  /** URL patterns (glob-style) for project boards where OR filter support is enabled. */
+  orFilterBoardPatterns: 'or_filter_board_patterns',
 } as const
 
 export const DEFAULT_BOARD_URLS = ['https://github.com/orgs/FilOzone/projects/14'] as const
@@ -23,6 +25,10 @@ export const DEFAULT_TARGET_REPOS = [
   'filecoin-project/github-mgmt',
 ] as const
 
+export const DEFAULT_OR_FILTER_BOARD_PATTERNS = [
+  'https://github.com/orgs/FilOzone/projects/*',
+] as const
+
 export const DEFAULT_STATUS_FIELD_NAME = 'Status'
 
 export type AuthMethod = 'pat' | 'oauth' | 'none'
@@ -35,6 +41,7 @@ export type StoredConfig = {
   crossOrgBoardUrls: string[]
   crossOrgTargetRepos: string[]
   issuePrProjectsAutoExpand: boolean
+  orFilterBoardPatterns: string[]
 }
 
 export function normalizeRepoKey(owner: string, name: string): string {
@@ -89,10 +96,12 @@ export async function loadConfig(): Promise<StoredConfig> {
     STORAGE_KEYS.crossOrgBoardUrls,
     STORAGE_KEYS.crossOrgTargetRepos,
     STORAGE_KEYS.issuePrProjectsAutoExpand,
+    STORAGE_KEYS.orFilterBoardPatterns,
   ])
 
   const urls = raw[STORAGE_KEYS.crossOrgBoardUrls] as string[] | undefined
   const repos = raw[STORAGE_KEYS.crossOrgTargetRepos] as string[] | undefined
+  const orPatterns = raw[STORAGE_KEYS.orFilterBoardPatterns] as string[] | undefined
   const autoRaw = raw[STORAGE_KEYS.issuePrProjectsAutoExpand]
   const issuePrProjectsAutoExpand = autoRaw === false ? false : true
 
@@ -128,9 +137,33 @@ export async function loadConfig(): Promise<StoredConfig> {
     crossOrgTargetRepos:
       Array.isArray(repos) && repos.length > 0 ? repos : [...DEFAULT_TARGET_REPOS],
     issuePrProjectsAutoExpand,
+    orFilterBoardPatterns:
+      Array.isArray(orPatterns) ? orPatterns : [...DEFAULT_OR_FILTER_BOARD_PATTERNS],
   }
 }
 
+/**
+ * Convert a glob-style URL pattern to a RegExp.
+ * Supports `*` as wildcard for any characters.
+ */
+function globToRegExp(pattern: string): RegExp {
+  const escaped = pattern
+    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
+  return new RegExp(`^${escaped}$`, 'i')
+}
+
+/** Check whether a URL matches any of the configured OR filter board patterns. */
+export function isOrFilterBoard(config: StoredConfig, pageUrl: string): boolean {
+  return config.orFilterBoardPatterns.some((pattern) => {
+    try {
+      return globToRegExp(pattern.trim()).test(pageUrl)
+    } catch {
+      return false
+    }
+  })
+}
+
 export function isTargetRepo(config: StoredConfig, owner: string, name: string): boolean {
   const key = normalizeRepoKey(owner, name)
   return config.crossOrgTargetRepos.some((r) => r.trim().toLowerCase() === key)
diff --git a/extension/src/options/options.html b/extension/src/options/options.html
index 8c72fb8..3dcf112 100644
--- a/extension/src/options/options.html
+++ b/extension/src/options/options.html
@@ -334,6 +334,19 @@ <h2>Expand all projects in sidebar</h2>
         Uncheck to leave initial collapse state to GitHub: status rows stay visible. Selecting this option means project detail sections expand.
       </p>
 
+      <h2>OR filter for project boards</h2>
+      <p class="section-lead">
+        Enable <strong>OR query support</strong> in the filter bar on matching project board pages.
+        Enter URL patterns (one per line, <code>*</code> = wildcard).
+        Leave empty to disable.
+      </p>
+      <label class="form-label" for="or-filter-patterns">Board URL patterns</label>
+      <textarea id="or-filter-patterns" aria-describedby="or-filter-patterns-hint"></textarea>
+      <p id="or-filter-patterns-hint" class="hint">
+        Example: <code>https://github.com/orgs/FilOzone/projects/*</code> matches all FilOzone project views.
+        Use <code>*</code> for any characters. Queries like <code>(-status:"Done") OR (-last-updated:1days)</code> will be split, fetched per branch, and merged.
+      </p>
+
       <div class="save-row">
         <button id="save" type="button" class="primary">Save</button>
         <p id="status" role="status" class="hint" style="margin-top: 0.5rem"></p>
diff --git a/extension/src/options/options.ts b/extension/src/options/options.ts
index 963ca79..3b3dcce 100644
--- a/extension/src/options/options.ts
+++ b/extension/src/options/options.ts
@@ -1,6 +1,7 @@
 import {
   DEFAULT_BOARD_URLS,
   DEFAULT_TARGET_REPOS,
+  DEFAULT_OR_FILTER_BOARD_PATTERNS,
   STORAGE_KEYS,
 } from '../lib/project-config.js'
 
@@ -25,6 +26,7 @@ const sampleRunBtn = document.querySelector<HTMLButtonElement>('#sample-run')
 const sampleCopyBtn = document.querySelector<HTMLButtonElement>('#sample-copy')
 const sampleOutEl = document.querySelector<HTMLPreElement>('#sample-out')
 const issuePrProjectsAutoExpandEl = document.querySelector<HTMLInputElement>('#issuePrProjectsAutoExpand')
+const orFilterPatternsEl = document.querySelector<HTMLTextAreaElement>('#or-filter-patterns')
 
 function authMode(): 'github' | 'pat' {
   return authModePatEl?.checked === true ? 'pat' : 'github'
@@ -98,6 +100,7 @@ async function load(): Promise<void> {
     STORAGE_KEYS.crossOrgBoardUrls,
     STORAGE_KEYS.crossOrgTargetRepos,
     STORAGE_KEYS.issuePrProjectsAutoExpand,
+    STORAGE_KEYS.orFilterBoardPatterns,
   ])
 
   const storedMethod = raw[STORAGE_KEYS.authMethod] as string | undefined
@@ -145,6 +148,12 @@ async function load(): Promise<void> {
   if (issuePrProjectsAutoExpandEl) {
     issuePrProjectsAutoExpandEl.checked = raw[STORAGE_KEYS.issuePrProjectsAutoExpand] !== false
   }
+  const orPatterns = raw[STORAGE_KEYS.orFilterBoardPatterns] as string[] | undefined
+  if (orFilterPatternsEl) {
+    orFilterPatternsEl.value = listToLines(
+      Array.isArray(orPatterns) ? orPatterns : [...DEFAULT_OR_FILTER_BOARD_PATTERNS],
+    )
+  }
 
   await refreshAuthUi()
 }
@@ -153,10 +162,13 @@ async function save(): Promise<void> {
   const urls = boardsEl ? linesToList(boardsEl.value) : [...DEFAULT_BOARD_URLS]
   const repos = reposEl ? linesToList(reposEl.value) : [...DEFAULT_TARGET_REPOS]
 
+  const orPatterns = orFilterPatternsEl ? linesToList(orFilterPatternsEl.value) : [...DEFAULT_OR_FILTER_BOARD_PATTERNS]
+
   const common: Record<string, unknown> = {
     [STORAGE_KEYS.crossOrgBoardUrls]: urls.length ? urls : [...DEFAULT_BOARD_URLS],
     [STORAGE_KEYS.crossOrgTargetRepos]: repos.length ? repos : [...DEFAULT_TARGET_REPOS],
     [STORAGE_KEYS.issuePrProjectsAutoExpand]: issuePrProjectsAutoExpandEl?.checked !== false,
+    [STORAGE_KEYS.orFilterBoardPatterns]: orPatterns,
   }
 
   if (authMode() === 'pat') {
diff --git a/package-lock.json b/package-lock.json
index 44e4b16..ba56e8f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "foc-gh",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "foc-gh",
-      "version": "0.1.0",
+      "version": "0.3.0",
       "devDependencies": {
         "@types/chrome": "^0.0.287",
         "archiver": "^7.0.1",
diff --git a/package.json b/package.json
index 8bcebb4..2568b48 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "foc-gh",
   "private": true,
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "scripts": {
     "build": "node scripts/build.mjs",
diff --git a/scripts/build.mjs b/scripts/build.mjs
index 8d383c4..e8b6126 100644
--- a/scripts/build.mjs
+++ b/scripts/build.mjs
@@ -163,6 +163,24 @@ await esbuild.build({
   outfile: path.join(dist, 'pr-expand-main-world.js'),
 })
 
+await esbuild.build({
+  entryPoints: [path.join(root, 'extension', 'src', 'content', 'board-filter', 'board-filter-main.ts')],
+  bundle: true,
+  format: 'iife',
+  platform: 'browser',
+  target: 'es2022',
+  outfile: path.join(dist, 'board-filter.js'),
+})
+
+await esbuild.build({
+  entryPoints: [path.join(root, 'extension', 'src', 'content', 'board-filter', 'board-data-injector.ts')],
+  bundle: true,
+  format: 'iife',
+  platform: 'browser',
+  target: 'es2022',
+  outfile: path.join(dist, 'board-data-injector.js'),
+})
+
 await esbuild.build({
   entryPoints: [path.join(root, 'extension', 'src', 'options', 'options.ts')],
   bundle: true,
diff --git a/specs/007-project-board-or-filter/checklists/requirements.md b/specs/007-project-board-or-filter/checklists/requirements.md
new file mode 100644
index 0000000..a38a509
--- /dev/null
+++ b/specs/007-project-board-or-filter/checklists/requirements.md
@@ -0,0 +1,36 @@
+# Specification Quality Checklist: Enable Project Board Filtering with OR Conditions
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning  
+**Created**: 2026-05-27  
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- All items pass validation. Spec is ready for `/speckit.clarify` or `/speckit.plan`.
+- The spec references "GitHub GraphQL API" and "GitHub CSS custom properties" in EXT-* requirements — these are platform constraints necessary for trust/data documentation, not implementation prescriptions.
+- cSpell warnings for "biglep" (a username) and "standups" are expected domain terms, not errors.
diff --git a/specs/007-project-board-or-filter/contracts/memex-api.ts b/specs/007-project-board-or-filter/contracts/memex-api.ts
new file mode 100644
index 0000000..9df06c7
--- /dev/null
+++ b/specs/007-project-board-or-filter/contracts/memex-api.ts
@@ -0,0 +1,80 @@
+/**
+ * Contract: Memex Paginated Items API Types
+ *
+ * Type definitions for GitHub's internal paginated items API response.
+ * These types were verified empirically against live API responses.
+ *
+ * NOTE: The original spec assumed groupedItems and slices were Record<number, T>
+ * (numeric-keyed objects). Empirical testing confirmed they are actual Arrays.
+ * The groups object also includes a pageInfo field.
+ */
+
+/** A single page response from the paginated items API (grouped) */
+export interface GroupedItemsResponse {
+  groups: { nodes: GroupNode[]; pageInfo: PageInfo }
+  groupedItems: GroupItems[]
+  slices: SliceInfo[]
+  totalCount: { value: number; isApproximate: boolean }
+}
+
+export interface PageInfo {
+  startCursor?: string
+  endCursor: string
+  hasNextPage: boolean
+  hasPreviousPage?: boolean
+}
+
+export interface GroupNode {
+  groupValue: string
+  groupId: string
+  groupMetadata: {
+    id: string
+    name: string
+    nameHtml: string
+    color: string
+    description: string
+    descriptionHtml: string
+  }
+  totalCount: { value: number; isApproximate: boolean }
+  fieldMetrics: unknown[]
+}
+
+export interface GroupItems {
+  groupId: string
+  nodes: MemexItem[]
+  pageInfo: PageInfo
+}
+
+export interface SliceInfo {
+  sliceId: string
+  sliceValue: string
+  totalCount: { value: number; isApproximate: boolean }
+}
+
+export interface MemexItem {
+  id: number
+  contentId: number
+  contentType: 'Issue' | 'PullRequest'
+  contentRepositoryId: number
+  updatedAt: string
+  createdAt: string
+  state: string
+  memexProjectColumnValues: ColumnValue[]
+  content: unknown
+  [key: string]: unknown
+}
+
+export interface ColumnValue {
+  memexProjectColumnId: string | number
+  value: unknown
+}
+
+/**
+ * Extract memexId and view configuration from the current page's embedded data.
+ *
+ * Implementation note: In the shipped code, memexId extraction and view param
+ * parsing are handled inline in board-data-injector.ts rather than as a
+ * standalone function. The interceptor clones the original URL from the React
+ * app's fetch call and only replaces the `q` parameter, preserving all other
+ * params (sortedBy, groupedBy, sliceBy, fieldIds, layout, sumFields, hierarchy).
+ */
diff --git a/specs/007-project-board-or-filter/contracts/or-query-parser.ts b/specs/007-project-board-or-filter/contracts/or-query-parser.ts
new file mode 100644
index 0000000..3728b9e
--- /dev/null
+++ b/specs/007-project-board-or-filter/contracts/or-query-parser.ts
@@ -0,0 +1,47 @@
+/**
+ * Contract: OR Query Parser
+ *
+ * Parses a project board filter string for OR syntax and returns
+ * a structured representation of the query branches.
+ */
+
+/** Result of parsing a filter string for OR syntax */
+export interface ORQuery {
+  /** Shared filter terms before the first parenthesized group */
+  prefix: string
+  /** Filter conditions for each OR branch (contents of parenthesized groups) */
+  branches: string[]
+  /** Original unparsed query string */
+  raw: string
+}
+
+/** Parse error when OR syntax is detected but malformed */
+export interface ORParseError {
+  type: 'nested_parens' | 'trailing_terms' | 'or_inside_parens' | 'single_branch' | 'too_many_branches'
+  message: string
+  raw: string
+}
+
+/** Result of attempting to parse OR syntax */
+export type ORParseResult =
+  | { kind: 'or_query'; query: ORQuery }
+  | { kind: 'plain_query'; raw: string }     // No OR syntax — pass through
+  | { kind: 'invalid_or'; error: ORParseError } // Malformed OR syntax
+
+/**
+ * Parse a filter string for OR syntax.
+ *
+ * Valid OR syntax: "shared-prefix (branch-1) OR (branch-2) [OR (branch-N)]"
+ *
+ * Rules:
+ * - At least 2 parenthesized groups separated by uppercase "OR"
+ * - Shared prefix (before first group) is applied to all branches
+ * - No nested parentheses
+ * - No filter terms after the final closing parenthesis
+ * - No "OR" keyword inside parentheses
+ * - Maximum 5 branches
+ *
+ * @param filterText - The raw filter string from the filter bar
+ * @returns Parsed result: OR query, plain query, or invalid OR error
+ */
+export declare function parseORQuery(filterText: string): ORParseResult
diff --git a/specs/007-project-board-or-filter/contracts/result-merger.ts b/specs/007-project-board-or-filter/contracts/result-merger.ts
new file mode 100644
index 0000000..ac85293
--- /dev/null
+++ b/specs/007-project-board-or-filter/contracts/result-merger.ts
@@ -0,0 +1,26 @@
+/**
+ * Contract: Result Merger
+ *
+ * Merges multiple paginated items API responses into a single
+ * deduplicated response that the React app can render natively.
+ */
+
+import type { GroupedItemsResponse } from './memex-api'
+
+/**
+ * Merge multiple API responses (one per OR branch) into a single response.
+ *
+ * - Deduplicates items by `item.id` (first occurrence wins)
+ * - Unions group metadata from all branches (by groupId)
+ * - Assigns items to correct groups based on their source branch grouping
+ * - Recalculates totalCount as the count of unique items
+ * - Merges slice data from all branches (dedup by sliceId; note: per-slice
+ *   totalCounts are kept from the first branch seen — they may be inconsistent
+ *   after deduplication, but GitHub's UI handles this gracefully)
+ *
+ * @param responses - Array of responses, one per OR branch
+ * @returns Single merged response compatible with the React app's expected format
+ */
+export declare function mergeResponses(
+  responses: GroupedItemsResponse[]
+): GroupedItemsResponse
diff --git a/specs/007-project-board-or-filter/data-model.md b/specs/007-project-board-or-filter/data-model.md
new file mode 100644
index 0000000..78f3145
--- /dev/null
+++ b/specs/007-project-board-or-filter/data-model.md
@@ -0,0 +1,131 @@
+# Data Model: Project Board OR Filter
+
+**Branch**: `007-project-board-or-filter` | **Date**: 2026-05-27
+
+## Entities
+
+### ORQuery
+
+Parsed representation of a filter string containing OR syntax.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `prefix` | `string` | Shared filter terms before the first parenthesized group (may be empty) |
+| `branches` | `string[]` | Array of filter conditions, one per OR branch (contents of each parenthesized group) |
+| `raw` | `string` | Original unparsed query string |
+
+**Validation rules**:
+- At least 2 branches required
+- No nested parentheses within branches
+- No filter terms after the final closing parenthesis
+- No `OR` keyword inside parentheses
+- Maximum 5 branches (practical limit from tpm-utils spec)
+
+**Examples**:
+- `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)`
+  → `{ prefix: "cycle:202605-2 biglep", branches: ['-status:"🎉 Done"', "-last-updated:1days"] }`
+- `(-status:"🎉 Done") OR (-last-updated:1days)`
+  → `{ prefix: "", branches: ['-status:"🎉 Done"', "-last-updated:1days"] }`
+
+### MemexPaginatedResponse (Grouped)
+
+API response from `/memexes/{id}/paginated_items` when `groupedBy` is specified.
+
+**Note**: `groupedItems` and `slices` are **arrays**, not numeric-keyed objects. This was verified empirically against the live API. The `groups` object also includes a `pageInfo` field.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `groups` | `{ nodes: GroupNode[], pageInfo: PageInfo }` | Group definitions with metadata and pagination |
+| `groupedItems` | `GroupItems[]` | Items organized by group (array, not Record) |
+| `slices` | `SliceInfo[]` | Slice/category breakdowns (array, not Record) |
+| `totalCount` | `{ value: number, isApproximate: boolean }` | Total items matching the filter |
+
+### GroupNode
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `groupValue` | `string` | Display name (e.g., "🐱 Todo") |
+| `groupId` | `string` | Base64-encoded unique identifier |
+| `groupMetadata` | `{ id, name, nameHtml, color, description, descriptionHtml }` | Display metadata |
+| `totalCount` | `{ value: number, isApproximate: boolean }` | Items in this group |
+| `fieldMetrics` | `unknown[]` | Field-level aggregation metrics |
+
+### GroupItems
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `groupId` | `string` | Matches `GroupNode.groupId` |
+| `nodes` | `MemexItem[]` | Items in this group |
+| `pageInfo` | `{ hasNextPage: boolean, endCursor: string }` | Pagination within group |
+
+### MemexItem
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `number` | **Deduplication key** — unique project item ID |
+| `contentId` | `number` | ID of the underlying Issue or PR |
+| `contentType` | `"Issue" \| "PullRequest"` | Type discriminator |
+| `contentRepositoryId` | `number` | Repository ID |
+| `priority` | `number \| null` | Item priority |
+| `virtualPriority` | `string` | Sort key for priority ordering |
+| `updatedAt` | `string` (ISO 8601) | Last update timestamp |
+| `createdAt` | `string` (ISO 8601) | Creation timestamp |
+| `state` | `string` | Issue/PR state (open, closed, merged) |
+| `memexProjectColumnValues` | `ColumnValue[]` | Field values for this item |
+| `content` | `object` | Nested issue/PR metadata (title, labels, assignees, etc.) |
+
+### ColumnValue
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `memexProjectColumnId` | `string \| number` | Column identifier (e.g., "Title", "Status", or numeric ID) |
+| `value` | `object` | Column-type-specific value object |
+
+### ViewConfig
+
+Extracted from `#memex-views` script tag. Defines the current view's parameters needed for API calls.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `number` | View ID |
+| `number` | `number` | View number (in URL) |
+| `name` | `string` | Display name |
+| `filter` | `string` | Default filter for this view |
+| `layout` | `string` | Layout type (e.g., "table_layout") |
+| `groupBy` | `number[]` | Column IDs to group by |
+| `sortBy` | `[number, string][]` | Column ID + direction pairs |
+| `visibleFields` | `number[]` | Column IDs to include in response |
+
+## State Transitions
+
+```
+IDLE → OR_DETECTED → FETCHING → MERGING → RENDERED
+  │                                           │
+  │         ← (user changes filter) ←────────┘
+  │
+  └── (no OR syntax) → PASS_THROUGH (native filtering)
+```
+
+| State | Description |
+|-------|-------------|
+| `IDLE` | No active OR query; normal board behavior |
+| `OR_DETECTED` | OR syntax parsed from filter input; preparing to intercept |
+| `FETCHING` | Making paginated_items API calls for each branch |
+| `MERGING` | All branches fetched; merging and deduplicating |
+| `RENDERED` | Merged data returned to React app; board displays combined results |
+| `PASS_THROUGH` | No OR syntax; fetch interception disabled, native behavior |
+
+## Relationships
+
+```
+ORQuery 1──* QueryBranch (prefix + branch = complete filter)
+     │
+     ▼ (one API call per branch)
+MemexPaginatedResponse *──* MemexItem (items from all branches)
+     │
+     ▼ (merge + deduplicate by item.id)
+MergedResponse 1──* MemexItem (union, no duplicates)
+     │
+     ▼ (returned to React app)
+Board UI renders naturally
+```
diff --git a/specs/007-project-board-or-filter/plan.md b/specs/007-project-board-or-filter/plan.md
new file mode 100644
index 0000000..03898d9
--- /dev/null
+++ b/specs/007-project-board-or-filter/plan.md
@@ -0,0 +1,189 @@
+# Implementation Plan: Enable Project Board Filtering with OR Conditions
+
+**Branch**: `007-project-board-or-filter` | **Date**: 2026-05-27 | **Spec**: [spec.md](spec.md)
+**Input**: Feature specification from `/specs/007-project-board-or-filter/spec.md`
+
+## Summary
+
+Enable OR-condition filtering on GitHub project board views by intercepting filter submissions, parsing OR syntax, executing multiple calls to GitHub's internal paginated items API (one per branch), merging and deduplicating results, and rendering the combined data in the board's existing UI. The extension currently only targets issue/PR pages; this feature adds content scripts for project board pages.
+
+## Technical Context
+
+**Language/Version**: TypeScript (esbuild-compiled, Manifest V3 Chrome extension)
+**Primary Dependencies**: Chrome Extensions API, GitHub internal memex API (`/memexes/{id}/paginated_items`)
+**Storage**: `chrome.storage.local` (existing config — no new storage for this feature)
+**Testing**: Manual verification (per constitution Principle IV); automated tests optional
+**Target Platform**: Chromium browsers (Manifest V3)
+**Project Type**: Browser extension (content scripts + service worker)
+**Performance Goals**: OR query results within a few seconds for typical 2-3 branch queries
+**Constraints**: Must not break existing extension features; must handle GitHub's internal API changes gracefully
+**Scale/Scope**: Internal FilOzone team usage; 2-5 OR branches per query typical
+
+## Constitution Check
+
+*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
+
+Gates derived from `.specify/memory/constitution.md` (TPM Utils GitHub Extension):
+
+- **Least privilege**: New content script match `https://github.com/orgs/*/projects/*/views/*` is within existing `host_permissions` (`https://github.com/*`). No new permissions, OAuth scopes, or host permissions required. API calls use session cookies (same-origin) — no token access needed beyond existing auth. **PASS**
+- **User credentials**: No new credential handling. Same-origin fetch to GitHub's internal API uses the user's existing session. No tokens stored or transmitted. **PASS**
+- **API discipline**: Uses GitHub's internal `/memexes/{id}/paginated_items` API (same-origin, session-authenticated). Rate limiting handled by concurrent request throttling (max 5 branches). Partial failure shows successful branches + error notification. **PASS**
+- **Verification (internal velocity)**: Manual verification steps documented below. No manifest/auth/host-permission changes beyond content_scripts match addition. Smoke checklist included for the new content script match. **PASS**
+- **Incremental scope**: MVP is a single feature slice: OR query parsing + multi-fetch + merge + render. No speculative features. **PASS**
+- **UI fidelity**: No custom UI injected — merged data is rendered by GitHub's own React app. No light/dark mode concerns. **PASS**
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/007-project-board-or-filter/
+├── plan.md              # This file
+├── research.md          # Phase 0 output — API and DOM research
+├── data-model.md        # Phase 1 output — data structures
+├── quickstart.md        # Phase 1 output — dev setup
+├── contracts/           # Phase 1 output — internal interfaces
+└── tasks.md             # Phase 2 output (/speckit.tasks)
+```
+
+### Source Code (repository root)
+
+```text
+extension/
+├── manifest.json                          # Add content_scripts match for project board pages
+├── src/
+│   ├── content/
+│   │   ├── board-filter/                  # NEW — project board OR filter feature
+│   │   │   ├── board-filter-main.ts       # Entry point: DOM observation, filter interception
+│   │   │   ├── or-query-parser.ts         # Parse OR syntax into prefix + branches
+│   │   │   ├── memex-api.ts              # Fetch paginated_items API, handle pagination
+│   │   │   ├── result-merger.ts           # Merge + deduplicate items from multiple branches
+│   │   │   ├── board-data-injector.ts     # Inject merged data into React app
+│   │   └── ... (existing content scripts)
+│   ├── lib/
+│   │   └── messages.ts                    # Add message types if service worker relay needed
+│   └── background/
+│       └── service-worker.ts              # May need relay for API calls (if CORS issues)
+```
+
+**Structure Decision**: New code lives in `extension/src/content/board-filter/` as a self-contained module. The OR query parser is isolated for testability. The feature shares the existing service worker and message infrastructure but operates independently from the issue/PR sidebar features.
+
+## Complexity Tracking
+
+| Violation | Why Needed | Simpler Alternative Rejected Because |
+|-----------|------------|-------------------------------------|
+| Internal API dependency (`/memexes/{id}/paginated_items`) | GitHub's public API doesn't support board filter syntax (cycle, last-updated, keyword) | Public GraphQL API lacks filter support; HTML parsing is more fragile than JSON API |
+| Main-world script injection (for fetch interception) | Need to intercept/modify the React app's API calls transparently | Content-script-only approach can't interact with page's JS context for seamless rendering |
+
+## Phase 0: Research (Complete)
+
+See [research.md](research.md) for full findings. Key decisions:
+
+1. **Data source**: GitHub's internal `GET /memexes/{memexId}/paginated_items?q={filter}` API
+2. **Interception point**: Filter bar input (`#filter-bar-component-input`) Enter key event
+3. **Rendering strategy**: Intercept the React app's fetch calls via main-world script to return merged data transparently (Option B from research)
+4. **Pagination**: Cursor-based (`after` param); must follow all pages per branch before merging
+
+## Phase 1: Design
+
+### Architecture
+
+```
+User types OR query → Enter key
+        │
+        ▼
+[Content Script: board-filter-main.ts]
+   Observes filter bar, detects OR syntax
+        │
+        ▼
+[or-query-parser.ts]
+   Parses: "prefix (branch1) OR (branch2)" → { prefix, branches: ["branch1", "branch2"] }
+        │
+        ▼
+[Main-world script: board-data-injector.ts]
+   Intercepts fetch("/memexes/{id}/paginated_items")
+   For each branch:
+     └── [memex-api.ts] fetches paginated_items?q=prefix+branch
+          └── Follows pagination cursors
+        │
+        ▼
+[result-merger.ts]
+   Merges items from all branches
+   Deduplicates by item.id
+   Reconstructs groups, slices, totalCount
+        │
+        ▼
+   Returns merged response to React app
+   (React renders naturally — no DOM manipulation needed)
+```
+
+### Implementation Phases
+
+**Phase 1a — OR Query Parser (P1, standalone)**
+- Parse the filter string for OR syntax
+- Validate syntax rules (no nesting, no trailing terms, etc.)
+- Return structured result: `{ prefix: string, branches: string[] }` or `null` (no OR detected)
+- Pure function, easily testable
+
+**Phase 1b — Memex API Client (P1, standalone)**
+- Fetch `GET /memexes/{id}/paginated_items` with given query params
+- Handle cursor-based pagination (follow `after` until no more pages)
+- Extract memexId from `#memex-item-get-api-data` script tag
+- Extract view params (sort, group, slice, fields) from `#memex-views` script tag
+- Return complete item set for a single filter query
+
+**Phase 1c — Result Merger (P1, standalone)**
+- Take multiple API responses (one per branch)
+- Deduplicate items by `id`
+- Merge group metadata (union of groups from all branches)
+- Reconstruct `groupedItems` with items assigned to correct groups
+- Recalculate `totalCount` and `slices`
+
+**Phase 1d — Board Data Injector / Fetch Interceptor (P1, integration)**
+- Main-world script that patches `window.fetch`
+- Detects calls to `/memexes/{id}/paginated_items`
+- When an OR query is active: intercepts the call, runs multi-branch fetch + merge, returns merged response
+- When no OR query: passes through to original fetch unchanged
+- Communication with content script via `CustomEvent` or `window.postMessage`
+
+**Phase 1e — Content Script Entry Point (P1, integration)**
+- New content script registered in manifest for `https://github.com/orgs/*/projects/*/views/*`
+- Observes `#filter-bar-component-input` for Enter key submission
+- Parses filter text for OR syntax
+- If OR detected: signals main-world script to activate fetch interception for the upcoming API call
+- If no OR: does nothing (full pass-through)
+
+### Key Design Decisions
+
+1. **Fetch interception over DOM manipulation**: By intercepting the React app's API calls and returning merged data, we let GitHub's own rendering code handle display. This is more robust than trying to manipulate the DOM or React state directly.
+
+2. **Content script + main-world script**: The content script handles DOM observation and OR detection. A main-world script (injected like the existing `pr-expand-main-world.ts`) handles fetch interception, since content scripts can't access the page's JS context.
+
+3. **Same-origin fetch**: API calls to `/memexes/{id}/paginated_items` are same-origin (github.com → github.com), so session cookies are sent automatically. No need to relay through the service worker.
+
+4. **Graceful degradation**: If the internal API changes format or the fetch interception fails, the extension falls back to native filtering (the unmodified API call goes through).
+
+### Manual Verification Plan
+
+**Smoke checklist** (required for new content script match):
+1. Load extension, navigate to `https://github.com/orgs/FilOzone/projects/14/views/20`
+2. Verify content script loads (check console for log marker)
+3. Verify existing issue/PR sidebar features still work on issue pages
+4. Verify no errors on project board pages without OR queries
+
+**Feature verification**:
+1. Enter `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)` in filter bar
+2. Verify merged results appear (items from both branches)
+3. Verify no duplicates in results
+4. Test with invalid OR syntax: `((nested))`, `(a) OR (b) trailing` — verify native filtering still works
+5. Test without OR syntax: verify normal filtering unchanged
+6. Test on views with different layouts (table, board) if applicable
+
+**Test URLs** (for `docs/canonical-test-urls.md`):
+- `https://github.com/orgs/FilOzone/projects/14/views/20` — "Current by Status" view (filtered, grouped)
+- `https://github.com/orgs/FilOzone/projects/14/views/2` — "All" view (large item set, pagination)
+- `https://github.com/orgs/FilOzone/projects/14/views/33` — "Recently Updated" view
+
+## Phase 2: Task Breakdown
+
+*To be generated by `/speckit.tasks`*
diff --git a/specs/007-project-board-or-filter/quickstart.md b/specs/007-project-board-or-filter/quickstart.md
new file mode 100644
index 0000000..9d8e6ea
--- /dev/null
+++ b/specs/007-project-board-or-filter/quickstart.md
@@ -0,0 +1,95 @@
+# Quickstart: Project Board OR Filter Development
+
+**Branch**: `007-project-board-or-filter`
+
+## Prerequisites
+
+- Node.js installed
+- Chrome browser
+- GitHub account with access to FilOzone org projects
+
+## Setup
+
+```bash
+# 1. Clone and switch to feature branch
+git checkout 007-project-board-or-filter
+npm install
+
+# 2. Build the extension
+npm run build
+
+# 3. Launch Chrome with remote debugging (required for reload scripts)
+/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
+  --remote-debugging-port=9222 \
+  --remote-allow-origins='*' \
+  --user-data-dir="$HOME/.chrome-dev-profile"
+
+# 4. Load the extension in Chrome
+#    - Navigate to chrome://extensions
+#    - Enable "Developer mode"
+#    - Click "Load unpacked" → select the extension/dist/ directory
+
+# 5. Navigate to a project board to test
+#    https://github.com/orgs/FilOzone/projects/14/views/20
+```
+
+## Development Loop
+
+```bash
+# Make code changes, then:
+npm run build && node scripts/cdp-reload.mjs
+
+# To stream service worker logs:
+node scripts/sw-logs.mjs
+```
+
+## Key Files to Edit
+
+| File | Purpose |
+|------|---------|
+| `extension/manifest.json` | Add content_scripts match for project board pages |
+| `extension/src/content/board-filter/board-filter-main.ts` | Entry point: observe filter bar, detect OR syntax |
+| `extension/src/content/board-filter/or-query-parser.ts` | Parse OR syntax into structured query |
+| `extension/src/content/board-filter/memex-api.ts` | Call paginated_items API with pagination handling |
+| `extension/src/content/board-filter/result-merger.ts` | Merge + deduplicate items from multiple branches |
+| `extension/src/content/board-filter/board-data-injector.ts` | Main-world fetch interception |
+
+## Test Queries
+
+**Valid OR queries**:
+- `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)`
+- `(-status:"🎉 Done") OR (-last-updated:1days)`
+
+**Invalid OR queries** (should fall back to native filter):
+- `((nested))` — nested parentheses
+- `(a) OR (b) trailing` — terms after final group
+- `(a OR b)` — OR inside parentheses
+
+**Non-OR queries** (should pass through unchanged):
+- `cycle:202605-2 -status:"🎉 Done"`
+- `biglep`
+
+## Key API Endpoint
+
+```
+GET /memexes/{memexId}/paginated_items
+  ?q={filter-string}
+  &sortedBy[direction]={asc|desc}
+  &sortedBy[columnId]={columnId}
+  &groupedBy[columnId]={columnId}
+  &sliceBy[columnId]={columnId}
+  &fieldIds=[...]
+  &after={cursor}        # for pagination
+```
+
+- `memexId`: Extract from `#memex-item-get-api-data` script tag on the page
+- View params: Extract from `#memex-views` script tag
+- Auth: Session cookies (same-origin, automatic)
+
+## Browser Debugging Tips
+
+- Open DevTools on the project board page
+- Network tab: filter by `paginated_items` to see API calls
+- Console: look for `[FilOz]` prefix from extension logs
+- Elements: search for `#memex-paginated-items-data` to see embedded data
+- Sources: check content script is loaded under `chrome-extension://` sources
diff --git a/specs/007-project-board-or-filter/research.md b/specs/007-project-board-or-filter/research.md
new file mode 100644
index 0000000..9732b6a
--- /dev/null
+++ b/specs/007-project-board-or-filter/research.md
@@ -0,0 +1,126 @@
+# Research: Enable Project Board Filtering with OR Conditions
+
+**Date**: 2026-05-27  
+**Branch**: `007-project-board-or-filter`
+
+## Key Findings
+
+### 1. GitHub Project Board Data Architecture
+
+**Decision**: The extension must intercept filter submission and use GitHub's internal memex API to fetch multiple filtered item sets.
+
+**Rationale**: GitHub project boards (internally called "memex") use a two-phase data loading model:
+
+- **Initial page load**: Data is server-rendered into a `<script id="memex-paginated-items-data">` tag (~190KB JSON blob). The board renders from this on first paint.
+- **Subsequent interactions** (filter changes, view switches): The React app calls `GET /memexes/{memexId}/paginated_items?q={filter}&sortedBy[direction]=...&groupedBy[columnId]=...&fieldIds=[...]` — an internal API that returns filtered items. The embedded script tag becomes stale after the first interaction.
+- Individual issue details are lazy-loaded via `GET /_graphql` (IssueViewerViewQuery) as rows scroll into view.
+- The board is rendered by a `<projects-v2 id="memex-root">` custom element. GitHub uses **Turbo** for SPA navigation (no full page reloads on view/filter changes).
+
+**Alternatives considered**:
+- Intercepting GraphQL queries — rejected: the board uses `/memexes/{id}/paginated_items`, not GraphQL, for item listing.
+- Using the public GitHub ProjectV2 GraphQL API — rejected: it doesn't support the board's filter syntax (`cycle:`, `last-updated:`, keyword matching, etc.).
+- Parsing full HTML pages for each branch — rejected: now that we know the API endpoint, calling it directly is cleaner and more efficient.
+
+### 2. The Memex Paginated Items API
+
+**Decision**: Use `GET /memexes/{memexId}/paginated_items` as the primary data source for OR branches.
+
+**Observed API contract** (reverse-engineered from browser network traffic):
+
+```
+GET /memexes/{memexId}/paginated_items
+  ?q={filter-string}                    # The filter query (same syntax as filter bar)
+  &sortedBy[direction]={asc|desc}       # Sort direction
+  &sortedBy[columnId]={columnId}        # Sort field
+  &groupedBy[columnId]={Status|...}     # Group-by field
+  &sliceBy[columnId]={columnId}         # Slice field (optional)
+  &fieldIds=[id1,id2,...]              # Which field values to return
+  &after={base64-cursor}               # Pagination cursor (for subsequent pages)
+```
+
+**Pagination**: Uses cursor-based pagination via the `after` parameter (base64-encoded cursor). When loading the "All" view (360 items), 3 successive `paginated_items` calls were observed with different `after` cursors. All items for a view are fetched eagerly (not lazily on scroll).
+
+**Authentication**: Same-origin requests use session cookies automatically. No additional auth needed from the extension.
+
+**Key parameters**:
+- `q`: The filter string, identical to what the user types in the filter bar
+- `memexId`: Found in `#memex-item-get-api-data` script tag (`{"url":"/memexes/{memexId}/items"}`)
+- View-specific params (`sortedBy`, `groupedBy`, `sliceBy`, `fieldIds`): Derived from the current view configuration in `#memex-views` script tag
+
+### 3. Embedded Data Structure
+
+The initial embedded JSON (`#memex-paginated-items-data`) and API responses share this structure:
+```
+{
+  groups: { nodes: [{ groupValue, groupId, groupMetadata, totalCount, fieldMetrics }] },
+  groupedItems: { 0: { groupId, nodes: [items...], pageInfo }, 1: {...}, ... },
+  slices: { 0: { sliceId, sliceValue, totalCount }, ... },
+  totalCount: { value, isApproximate }
+}
+```
+
+Each item contains:
+- `id` (numeric, unique project item ID — **deduplication key**)
+- `contentId`, `contentType` (Issue/PullRequest), `contentRepositoryId`
+- `updatedAt`, `createdAt`, `state`
+- `memexProjectColumnValues` — array of field values (Title, Status, Assignees, Cycle, etc.)
+- `content` — nested issue/PR metadata
+
+### 4. Page Structure and Entry Points
+
+**Decision**: Add a new content script match for project board pages. Intercept the filter bar's submit event to detect OR syntax.
+
+**Key DOM elements**:
+- Filter input: `<input id="filter-bar-component-input" role="combobox" placeholder="Filter by keyword or by field">`
+- Project root: `<projects-v2 id="memex-root">`
+- Embedded data: `<script id="memex-paginated-items-data" type="application/json">`
+- View metadata: `<script id="memex-views" type="application/json">` — contains filter, layout, groupBy, sortBy per view
+- API endpoints: `<script id="memex-item-get-api-data">` → `{"url":"/memexes/{memexId}/items"}`
+
+**Content script matching**: The extension currently only matches issue/PR pages. Project board pages are at `https://github.com/orgs/*/projects/*/views/*`. No new host_permissions needed (already has `https://github.com/*`).
+
+**SPA behavior**: Filter changes and view switches are SPA transitions (Turbo + React). The fetch interceptor survives across these transitions — no full page reloads occur.
+
+### 5. Implementation Approach
+
+**Decision**: Intercept-fetch-merge strategy using the internal paginated items API.
+
+When user submits an OR query:
+1. **Intercept**: Content script listens for Enter key on `#filter-bar-component-input`. If OR syntax detected, prevent default behavior and intercept the React app's API call.
+2. **Parse**: Split query into shared prefix + parenthesized branches per the OR syntax rules.
+3. **Fetch**: For each branch, call `GET /memexes/{memexId}/paginated_items?q={prefix+branch}&...` with the current view's sort/group/slice/field params. Handle pagination (follow `after` cursors until all pages are fetched per branch).
+4. **Merge**: Union items from all branches, deduplicate by item `id`. Reconstruct groups, groupedItems, slices, and totalCount from the merged set.
+5. **Render**: Inject merged data into the React app. Two approaches to explore:
+   - **Option A**: Replace `#memex-paginated-items-data` script content and force re-mount of `<projects-v2>` element
+   - **Option B**: Intercept the React app's fetch call (monkey-patch `fetch` in main world) to return merged data transparently
+   - **Option C**: Build a custom overlay table that replaces the native table with merged results
+
+**Recommended**: Option B (fetch interception) is the most seamless — the React app renders naturally from what it thinks is a single API response. Research during implementation will determine if this is feasible or if Option A/C is needed as fallback.
+
+### 6. Other Embedded Metadata Scripts
+
+| Script ID | Purpose | Size |
+|-----------|---------|------|
+| `memex-data` | Project metadata (id, name, description) | ~700B |
+| `memex-views` | View configs (filter, layout, groupBy, sortBy) | varies |
+| `memex-columns-data` | Field/column definitions (types, options, names) | ~8KB |
+| `memex-viewer-privileges` | User permissions (role, capabilities) | ~90B |
+| `memex-paginated-items-data` | Board items (initial load only) | ~190KB |
+| `memex-*-api-data` | Internal API endpoint URLs | ~30-60B each |
+
+### 7. Chrome Dev Workflow
+
+Existing tooling:
+- **Build**: `npm run build` (esbuild)
+- **Chrome launch**: `/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222 --remote-allow-origins='*' --user-data-dir="$HOME/.chrome-dev-profile"`
+- **Reload**: `node scripts/cdp-reload.mjs` (reloads service worker + GitHub tabs via CDP)
+- **SW logs**: `node scripts/sw-logs.mjs` (streams service worker console output)
+
+## Open Risks
+
+1. **Fetch interception feasibility**: Monkey-patching `fetch` in main world to intercept and modify the paginated_items response is the cleanest approach but requires a main-world script injection (similar to existing `pr-expand-main-world.ts`). The timing of the patch relative to the React app's module initialization is a risk.
+2. **API response format**: The exact response format of `/memexes/{id}/paginated_items` needs to be captured during implementation (the research observed request parameters but not response bodies). It likely matches the `#memex-paginated-items-data` structure.
+3. **Group reconstruction**: Merging items from different branches requires combining group metadata (new groups from one branch may not exist in another). The merged `groupedItems` must correctly assign items to their groups.
+4. **Pagination across branches**: Each branch may require multiple paginated fetches. With 5 branches and 3 pages each, that's 15 API calls — acceptable but should show progress.
+5. **Turbo snapshot cache**: Turbo may cache pages and restore stale data on back/forward. May need to handle cache invalidation for OR-filtered views.
+6. **Internal API stability**: The `/memexes/{id}/paginated_items` endpoint is undocumented and internal to GitHub. It could change without notice. The extension should degrade gracefully if the API changes.
diff --git a/specs/007-project-board-or-filter/spec.md b/specs/007-project-board-or-filter/spec.md
new file mode 100644
index 0000000..6028372
--- /dev/null
+++ b/specs/007-project-board-or-filter/spec.md
@@ -0,0 +1,109 @@
+# Feature Specification: Enable Project Board Filtering with OR Conditions
+
+**Feature Branch**: `007-project-board-or-filter`  
+**Created**: 2026-05-27  
+**Status**: Draft  
+**Input**: User description: "Support enriched query syntax on GitHub project boards — specifically OR conditions (GitHub issue #8)."
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Standup View with OR Filter (Priority: P1)
+
+A TPM navigates to a GitHub project board view (e.g., FilOzone projects/14) and enters a filter query containing OR syntax in the board's filter bar. For example: `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)`. The extension detects the OR syntax, splits the query into separate branches sharing the common prefix, executes multiple GitHub API queries, merges and deduplicates the results, and updates the board view with the combined result set. The TPM sees all items matching **any** of the OR branches without switching between multiple views.
+
+**Why this priority**: This is the core use case — daily standups require seeing both open items and recently completed work in a single view. Without this, TPMs must manually switch between two board views, which disrupts standup flow and causes items to be missed.
+
+**Independent Test**: Can be fully tested by entering an OR query on a project board and verifying the combined results appear. Delivers immediate standup productivity value.
+
+**Acceptance Scenarios**:
+
+1. **Given** a project board view is open with the extension active, **When** the user enters a filter query containing `(branch-1) OR (branch-2)` syntax, **Then** the board displays items matching either branch-1 or branch-2 (union), with shared prefix conditions applied to both branches.
+2. **Given** a filter query with OR syntax that would return overlapping items from both branches, **When** the query executes, **Then** duplicate items appear only once in the results.
+3. **Given** a filter query with a shared prefix and two OR branches, **When** the query executes, **Then** the shared prefix is applied to every branch (e.g., `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)` becomes two queries: `cycle:202605-2 biglep -status:"🎉 Done"` and `cycle:202605-2 biglep -last-updated:1days`).
+
+---
+
+### User Story 2 - Visual Feedback During OR Query Execution (Priority: P2)
+
+While the extension is executing multiple API calls for an OR query, the TPM sees a visual indicator that work is in progress. Once all branches resolve, results appear together. If one branch fails, the user sees partial results along with a notification about the failed branch.
+
+**Why this priority**: OR queries require multiple API calls, which may take longer than a single query. Without feedback, users may think the board is broken or attempt to re-enter the query.
+
+**Independent Test**: Can be tested by entering an OR query on a board and observing loading state and error handling behavior.
+
+**Acceptance Scenarios**:
+
+1. **Given** an OR query is submitted, **When** the extension begins executing multiple API calls, **Then** the user sees a loading indicator distinct from GitHub's native loading state.
+2. **Given** an OR query where one branch returns results and another fails (e.g., due to a rate limit), **When** results are displayed, **Then** the successful branch results are shown and a non-blocking notification explains which branch failed and why.
+
+---
+
+### User Story 3 - Graceful Fallback for Invalid OR Syntax (Priority: P3)
+
+A user enters a malformed OR query (e.g., nested parentheses, OR inside parentheses, or trailing filter terms after the last group). The extension detects the syntax error, falls back to passing the raw query to GitHub's native filter, and shows a brief tooltip or notification explaining valid OR syntax.
+
+**Why this priority**: Prevents confusion when users experiment with the syntax. Ensures the extension never blocks normal filtering, even on bad input.
+
+**Independent Test**: Can be tested by entering various malformed OR queries and verifying fallback behavior.
+
+**Acceptance Scenarios**:
+
+1. **Given** a query with nested parentheses `((condition))`, **When** the extension parses the query, **Then** it falls back to native GitHub filtering and shows a syntax hint.
+2. **Given** a query with filter terms after the final OR group, **When** the extension parses the query, **Then** it falls back to native GitHub filtering and shows a syntax hint.
+3. **Given** a query without any OR syntax or parentheses, **When** the extension parses the query, **Then** it passes the query through to GitHub's native filter unchanged (full backward compatibility).
+
+---
+
+### Edge Cases
+
+- What happens when an OR query returns zero results from all branches? The board should show an empty state consistent with GitHub's native "no items" message.
+- What happens when one OR branch returns hundreds of items? The extension should handle pagination per branch and merge paginated results.
+- What happens when the user modifies the filter query while a previous OR query is still in flight? The in-flight request should be cancelled and replaced by the new query.
+- What happens when the user is rate-limited by GitHub's API mid-query? The extension should display partial results from completed branches and notify the user about the rate limit.
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: The extension MUST detect OR syntax in the project board filter bar by recognizing the pattern: optional shared prefix followed by two or more parenthesized groups separated by the uppercase keyword `OR`.
+- **FR-002**: The extension MUST split an OR query into its constituent branches, prepending the shared prefix to each branch.
+- **FR-003**: The extension MUST execute one API query per OR branch and merge the results into a single deduplicated item set (deduplication by project item ID).
+- **FR-004**: The extension MUST preserve the board's existing sort order and column layout when displaying merged OR results.
+- **FR-005**: The extension MUST pass queries that do not contain OR syntax through to GitHub's native filtering unchanged (full backward compatibility).
+- **FR-006**: The extension MUST reject invalid OR syntax (nested parentheses, OR inside parentheses, filter terms after the final group) and fall back to native filtering with a user-visible syntax hint.
+- **FR-007**: The extension MUST show a loading indicator while OR branch queries are in flight.
+- **FR-008**: The extension MUST handle partial failures gracefully — display results from successful branches and notify the user about failed branches.
+- **FR-009**: The extension MUST cancel in-flight OR queries when the user changes the filter query before results return.
+- **FR-010**: The extension MUST handle pagination within each OR branch so that large result sets are fully merged.
+
+### Extension trust and data *(mandatory)*
+
+- **EXT-001**: This feature reads project board item data (title, status, fields, assignees, labels, updated timestamps) via the GitHub GraphQL API using the user's existing authenticated token (PAT or OAuth). No new GitHub data categories are accessed beyond what the extension already reads for project board rendering. No data is written by this feature.
+- **EXT-002**: No additional data is persisted locally by this feature. Merged query results are held in memory for display only and discarded on navigation or filter change.
+- **EXT-003**: This feature does not introduce server-side storage of user tokens or data. All API calls go directly from the extension to `api.github.com` using the user's own credentials.
+- **EXT-UI-001**: The loading indicator and syntax-hint notifications injected on `github.com` project board pages must use GitHub CSS custom properties (`--bgColor-*`, `--fgColor-*`, `--borderColor-*`) and follow Primer design patterns to maintain seamless integration in both light and dark modes, consistent with Principle VI of the constitution.
+
+### Key Entities
+
+- **OR Query**: A filter query string containing a shared prefix and two or more parenthesized branch conditions separated by the `OR` keyword. Parsed into a structured representation of prefix + branches.
+- **Query Branch**: A single set of filter conditions extracted from an OR query. Each branch is an independent query that includes the shared prefix.
+- **Merged Result Set**: The deduplicated union of project items returned by all OR branches, identified by project item ID.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: A TPM can view both open items and recently completed items for a sprint in a single board view using one OR query, eliminating the need to switch between multiple views during standup.
+- **SC-002**: OR query results appear within a reasonable time after submission, with a loading indicator visible during the wait.
+- **SC-003**: Queries without OR syntax continue to work identically to before — zero regressions in native filtering behavior.
+- **SC-004**: 100% of duplicate items across OR branches are eliminated in the merged result set.
+- **SC-005**: Invalid OR syntax is detected and handled gracefully in all documented invalid patterns (nested parens, trailing terms, OR inside parens) — no silent failures or broken board states.
+
+## Assumptions
+
+- The user has the FOC GH extension installed and authenticated with a GitHub token that has project board read access (existing prerequisite — no new permissions needed).
+- The GitHub ProjectV2 GraphQL API supports filtering via the same query syntax used in the project board filter bar. The extension can construct valid API queries from parsed OR branches.
+- GitHub project board pages expose a DOM element or event that the extension can observe to detect filter query changes (the filter input bar).
+- The extension operates on `github.com/orgs/*/projects/*/views/*` pages where project board views are rendered.
+- OR queries will typically have 2-3 branches; supporting up to 5 branches covers all practical use cases per the tpm-utils OR syntax documentation.
+- Rate limits from executing multiple API calls per OR query are manageable for typical usage (2-5 branches per query, infrequent re-queries).
diff --git a/specs/007-project-board-or-filter/tasks.md b/specs/007-project-board-or-filter/tasks.md
new file mode 100644
index 0000000..add154b
--- /dev/null
+++ b/specs/007-project-board-or-filter/tasks.md
@@ -0,0 +1,165 @@
+# Tasks: Enable Project Board Filtering with OR Conditions
+
+**Input**: Design documents from `/specs/007-project-board-or-filter/`
+**Prerequisites**: plan.md, spec.md, research.md, data-model.md, contracts/
+
+**Tests**: Automated tests are optional per constitution Principle IV. Manual verification is the primary validation method.
+
+**UI**: No custom UI injected — merged data is rendered by GitHub's own React app. No light/dark theme work needed.
+
+**Manual verification URLs**: See Test URLs in plan.md and `docs/canonical-test-urls.md`.
+
+**Organization**: Tasks are grouped by user story to enable independent implementation and testing of each story.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (e.g., US1, US3)
+- Include exact file paths in descriptions
+
+---
+
+## Phase 1: Setup
+
+**Purpose**: Add project board content script match and create file structure for the new feature module.
+
+- [x] T001 Add content_scripts entry for project board pages (`https://github.com/orgs/*/projects/*/views/*`) in `extension/manifest.json`
+- [x] T002 Add new esbuild entry point for board-filter content script in `scripts/build.mjs`
+- [x] T003 Create directory `extension/src/content/board-filter/` and empty entry point `extension/src/content/board-filter/board-filter-main.ts`
+- [x] T004 Add `board-data-injector.js` to `web_accessible_resources` in `extension/manifest.json` (needed for main-world script injection)
+
+---
+
+## Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose**: Implement the three standalone modules that all user stories depend on. These are pure logic with no DOM or browser dependencies and can be built in parallel.
+
+**CRITICAL**: No user story integration work can begin until these modules are complete.
+
+- [x] T005 [P] Implement OR query parser in `extension/src/content/board-filter/or-query-parser.ts` — parse filter string into `{ prefix, branches }` per contract in `specs/007-project-board-or-filter/contracts/or-query-parser.ts`; handle valid OR syntax, plain queries (no OR), and return structured `ORParseResult`
+- [x] T006 [P] Define memex API types in `extension/src/content/board-filter/memex-api.ts` (API client logic moved into board-data-injector.ts) — extract `memexId` from `#memex-item-get-api-data` script tag, extract view params (sort, group, slice, fields) from `#memex-views` script tag, fetch `GET /memexes/{memexId}/paginated_items` with query params, follow cursor-based pagination via `after` parameter until all pages fetched
+- [x] T007 [P] Implement result merger in `extension/src/content/board-filter/result-merger.ts` — take array of API responses (one per OR branch), deduplicate items by `item.id`, union group metadata from all branches, reconstruct `groupedItems` with items in correct groups, recalculate `totalCount` and merge `slices`
+
+**Checkpoint**: All three standalone modules are complete and can be exercised via console/unit tests.
+
+---
+
+## Phase 3: User Story 1 — Standup View with OR Filter (Priority: P1) MVP
+
+**Goal**: A TPM can enter an OR query in the project board filter bar and see merged results from all branches in a single view — eliminating the need to switch between multiple board views during standup.
+
+**Independent Test**: Navigate to `https://github.com/orgs/FilOzone/projects/14/views/20`, enter `cycle:202605-2 biglep (-status:"🎉 Done") OR (-last-updated:1days)` in filter bar, verify merged results from both branches appear with no duplicates.
+
+### Implementation for User Story 1
+
+- [x] T008 [US1] Implement main-world fetch interceptor in `extension/src/content/board-filter/board-data-injector.ts` — monkey-patch `window.fetch` to detect calls to `/memexes/{id}/paginated_items`; when an OR query is active, intercept the call, invoke multi-branch fetch (one call per branch using `memex-api.ts`), merge results (using `result-merger.ts`), and return merged response as if it were a single API response; when no OR query is active, pass through to original fetch unchanged
+- [x] T009 [US1] Implement content script entry point in `extension/src/content/board-filter/board-filter-main.ts` (config-gated injection of main-world interceptor; OR detection moved to interceptor itself) — observe `#filter-bar-component-input` for Enter key and form submission events; parse filter text using `or-query-parser.ts`; if OR detected, signal main-world script (via `window.postMessage` or `CustomEvent`) with the parsed query; inject main-world script (`board-data-injector.ts`) into the page on load (following the pattern in `extension/src/content/pr-expand-main-world.ts`)
+- [x] T010 [US1] Wire content script and main-world script (interceptor reads filter bar directly at fetch time — no message protocol needed) in `extension/src/content/board-filter/board-filter-main.ts` and `extension/src/content/board-filter/board-data-injector.ts` — define message protocol for: (a) content script → main-world: "OR query active with these branches", (b) content script → main-world: "no OR query, pass through", (c) handle SPA navigation (view switches) by re-detecting filter bar and re-attaching listeners
+- [x] T011 [US1] Build and manually verify end-to-end on `https://github.com/orgs/FilOzone/projects/14/views/20` — run `npm run build && node scripts/cdp-reload.mjs`, enter OR query, confirm merged results appear, confirm no duplicates, confirm non-OR queries still work, confirm existing issue/PR sidebar features are unaffected
+
+**Checkpoint**: User Story 1 is fully functional. OR queries work on project board pages. Non-OR queries pass through unchanged. Existing features unaffected.
+
+---
+
+## Phase 4: User Story 3 — Graceful Fallback for Invalid OR Syntax (Priority: P3)
+
+**Goal**: Invalid OR syntax (nested parens, trailing terms, OR inside parens) is detected, and the extension falls back to native GitHub filtering without breaking the board.
+
+**Independent Test**: Enter `((nested))` or `(a) OR (b) trailing` in filter bar and verify the board filters normally (native behavior) with no errors.
+
+### Implementation for User Story 3
+
+- [x] T012 [US3] Add invalid OR syntax detection to `extension/src/content/board-filter/or-query-parser.ts` — handle all invalid patterns: nested parentheses `((…))`, filter terms after final `)`, `OR` keyword inside parentheses, single branch `(…)` without OR; return `{ kind: 'invalid_or', error }` with specific error type
+- [x] T013 [US3] Handle `invalid_or` parse result in `board-data-injector.ts` (moved to main-world interceptor — logs warning, passes through to native) — when parser returns `invalid_or`, do nothing (let native filtering proceed); log a console warning with the parse error for debugging
+- [x] T014 [US3] Manually verify fallback behavior — enter each invalid pattern on `https://github.com/orgs/FilOzone/projects/14/views/20`, confirm native GitHub filtering works normally, confirm no console errors beyond the debug warning
+
+**Checkpoint**: All invalid OR patterns degrade gracefully to native filtering. No user-visible errors.
+
+---
+
+## Phase 5: Polish & Cross-Cutting Concerns
+
+**Purpose**: Documentation updates, edge case hardening, and verification across multiple views.
+
+- [x] T015 [P] Update `docs/canonical-test-urls.md` with project board OR filter test URLs and scenarios per plan.md verification section
+- [x] T016 [P] Add `extension/src/content/board-filter/` module overview comment in `board-filter-main.ts` explaining architecture (content script → main-world script → fetch interception → merge)
+- [x] T017 Verify on multiple views: test OR queries on "All" view (`/views/2`, large item set with pagination), "Recently Updated" view (`/views/33`), and a board-layout view if available
+- [ ] T018 Verify cancellation behavior: change filter while OR query is in-flight, confirm no stale results or errors appear
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Setup (Phase 1)**: No dependencies — start immediately
+- **Foundational (Phase 2)**: Depends on Setup (T001-T004) — BLOCKS all user stories
+- **User Story 1 (Phase 3)**: Depends on Foundational (T005-T007) — core feature
+- **User Story 3 (Phase 4)**: Depends on Foundational (T005) for parser — can run in parallel with US1 since T012 extends the parser independently
+- **Polish (Phase 5)**: Depends on US1 completion (T011)
+
+### User Story Dependencies
+
+- **User Story 1 (P1)**: Requires all three foundational modules (parser, API client, merger). This is the MVP.
+- **User Story 3 (P3)**: Requires only the parser module (T005). Parser edge-case work (T012) can proceed in parallel with US1 integration work.
+
+### Within Each User Story
+
+- Foundational modules before integration
+- Integration before verification
+- Each story is independently testable at its checkpoint
+
+### Parallel Opportunities
+
+- T005, T006, T007 can all run in parallel (different files, no shared dependencies)
+- T012 (US3 parser edge cases) can run in parallel with T008-T010 (US1 integration) since they touch different parts of the parser
+- T015, T016 can run in parallel (different files)
+
+---
+
+## Parallel Example: Foundational Phase
+
+```
+# These three modules are independent and can be built simultaneously:
+T005: OR query parser in extension/src/content/board-filter/or-query-parser.ts
+T006: Memex API client in extension/src/content/board-filter/memex-api.ts
+T007: Result merger in extension/src/content/board-filter/result-merger.ts
+```
+
+## Parallel Example: US1 + US3
+
+```
+# After foundational phase, these can proceed in parallel:
+Developer A (US1): T008 → T009 → T010 → T011
+Developer B (US3): T012 → T013 → T014
+```
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 1 Only)
+
+1. Complete Phase 1: Setup (T001-T004)
+2. Complete Phase 2: Foundational (T005-T007) — build in parallel
+3. Complete Phase 3: User Story 1 (T008-T011) — integration and verification
+4. **STOP and VALIDATE**: Test OR query on project board, confirm merged results
+5. Deploy if ready — this delivers the core standup use case
+
+### Incremental Delivery
+
+1. Setup + Foundational → modules ready
+2. Add User Story 1 → Test → Deploy (MVP — standups unblocked!)
+3. Add User Story 3 → Test → Deploy (invalid syntax handled gracefully)
+4. Polish → Docs, multi-view verification
+
+---
+
+## Notes
+
+- [P] tasks = different files, no dependencies on incomplete tasks
+- [Story] label maps task to specific user story for traceability
+- No automated tests required per constitution; manual verification at each checkpoint
+- Commit after each task or logical group
+- The main-world script injection follows the existing pattern in `extension/src/content/pr-expand-main-world.ts`
+- The internal `/memexes/{id}/paginated_items` API is undocumented; if GitHub changes it, the extension degrades to native filtering (pass-through)