@@ -107,6 +107,7 @@ In sections with more than 1 item, a `>> N` button is available (where `N` is th
 Note:
 - you can break out from the sequence at any time by closing the dialog.
 - by default this only processes tasks that are currently shown -- so it won't process any ones of lower priority that you have hidden. If you turn off the setting 'Do "Move all items" buttons only move shown items when filtering?', then `>> N` and Interactive Processing include those hidden lower-priority items as well.
+- for **Active Projects** and **Projects to Review**, `>> N` walks project rows only (not the next-action tasks under them). Active Projects allows skip back; Projects to Review is forward-only. **Start Reviews** is unchanged.
 - there are 3 settings that control aspects of this in the Dashboard Settings dialog.
 
 ### Add Task/Checklist items
@@ -253,6 +254,8 @@ The actions available in the Edit dialog for this section are:
 
 The 'Start Reviews' button does the same as the button of the same name in the Project & Reviews plugin, and is the equivalent of its **/start reviews** command. See the documentation for how that works, and which commands to follow it with once you've done reviewed the note.
 
+Both project sections also support **Interactive Processing** (the `>> N` button) when there is more than one project row: same project edit dialog, walked one project at a time. See [Interactive Processing Dialog](#interactive-processing-dialog) above.
+
 ### Overdue section
 This finds open items with a schedule date (e.g. `>2025-01-22`) in the past. This can generate a lot of tasks, and take a while, so there's a setting "Number of days to look back for Overdue tasks", which if set to any number > 0, will filter by due date (if set) or on date of a calendar note.
 
 
@@ -2,7 +2,7 @@
 //-----------------------------------------------------------------------------
 // Constants for Dashboard code.
 // Check each of them when adding a new Section.
-// Last updated 2026-08-01 for v2.4.0.b59, @jgclark + @CursorAI
+// Last updated 2026-08-21 for v2.5.0, @jgclark + @CursorAI
 //-----------------------------------------------------------------------------
 import pluginJson from '../plugin.json'
 import type { TSectionDetails, TSectionCode } from './types'
@@ -63,7 +63,7 @@ export const sectionsPriorityBeforeTagWhenCalendarFocus: Array<TSectionCode> = [
 export const dontDedupeSectionCodes = ['INFO', 'PROJACT', 'PROJREVIEW', 'SEARCH', 'SAVEDSEARCH']
 
 // Enable interactive processing for these itemTypes:
-export const interactiveProcessingPossibleSectionTypes = ['DT', 'DY', 'DO', 'LW', 'W', 'M', 'Q', 'Y', 'TAG', 'OVERDUE', 'PRIORITY', 'REM']
+export const interactiveProcessingPossibleSectionTypes = ['DT', 'DY', 'DO', 'LW', 'W', 'M', 'Q', 'Y', 'TAG', 'OVERDUE', 'PRIORITY', 'REM', 'PROJACT', 'PROJREVIEW']
 
 // When the user toggles visibility of a calendar period section only, refresh these sections (if enabled).
 // This ensures Wins / Priority / Overdue deduping stays correct.
 
@@ -27,6 +27,7 @@ type Props = {
 /**
  * Display a Dialog for a Task, Reminder, or Project if reactSettings.dialogData.isOpen is true.
  * Reminder vs task is chosen from details.item.itemType so Interactive Processing can switch mid-session (#779).
+ * Project dialogs use isTask false (PROJACT / PROJREVIEW IP).
  * @param {Props} props The properties for the Dialog component.
  * @return {?React$Node} Renderable React node or null.
  */
 
@@ -2,7 +2,7 @@
 //--------------------------------------------------------------------------
 // Dashboard React component to show a whole Dashboard Section
 // Called by Dashboard component.
-// Last updated 2026-08-21 for v2.4.1 by @jgclark + @CursorAI
+// Last updated 2026-08-21 for v2.5.0, @jgclark + @CursorAI
 //--------------------------------------------------------------------------
 
 //--------------------------------------------------------------------------
@@ -369,22 +369,25 @@ const Section = ({ section, onButtonClick, isViewVisible = true }: SectionProps)
 
   // handle a click to start interactive processing
   // When moveOnlyShownItemsWhenFiltered is false, include lower-priority (and limit-hidden) items, not just those currently shown.
-  // Count and start list both use getInteractiveProcessingItems (open/checklist/reminder) (#779)
+// Count and start list both use getInteractiveProcessingItems (open/checklist/reminder/project)
   const handleInteractiveProcessingClick = useCallback(
     (e: MouseEvent): void => {
       const moveOnlyShownItemsWhenFiltered = dashboardSettings?.moveOnlyShownItemsWhenFiltered ?? true
       const sourceItems = moveOnlyShownItemsWhenFiltered ? itemsToShow : allSortedItems
-      const processableItems = getInteractiveProcessingItems(sourceItems)
+      const processableItems = getInteractiveProcessingItems(sourceItems, section.sectionCode)
       if (processableItems.length === 0) {
         logDebug(
           'Section',
-          `Interactive Processing click on ${section.sectionCode}: no processable open/checklist/reminder items (source had ${String(sourceItems.length)} row(s))`,
+          `Interactive Processing click on ${section.sectionCode}: no processable open/checklist/reminder/project items (source had ${String(sourceItems.length)} row(s))`,
         )
         return
       }
 
+      const firstItem = processableItems[0]
       const clickPosition = { clientY: e.clientY, clientX: e.clientX + 200 }
-      const itemDetails = { actionType: '', item: processableItems[0], sectionCodes: [section.sectionCode] }
+      const itemDetails = { actionType: '', item: firstItem, sectionCodes: [section.sectionCode] }
+      // Project rows need isTask false so Dialog.jsx routes to DialogForProjectItems
+      const isTask = firstItem.itemType !== 'project'
       setReactSettings((prevSettings) => {
         const newReactSettings = {
           ...prevSettings,
@@ -396,7 +399,7 @@ const Section = ({ section, onButtonClick, isViewVisible = true }: SectionProps)
             visibleItems: [...processableItems],
             clickPosition,
           },
-          dialogData: { isOpen: true, isTask: true, details: itemDetails, clickPosition },
+          dialogData: { isOpen: true, isTask, details: itemDetails, clickPosition },
         }
         return newReactSettings
       })
@@ -603,12 +606,11 @@ const Section = ({ section, onButtonClick, isViewVisible = true }: SectionProps)
     ) : null
 
   // Decide whether to show interactiveProcessing button:
-  // - N and the start list use the same processable filter (open/checklist/reminder) (#779)
+// - N and the start list use the same processable filter (open/checklist/reminder/project)
   // - when moveOnlyShownItemsWhenFiltered, source is visible rows; otherwise allSortedItems (incl. priority/limit-hidden)
-  // - hide when there is nothing actionable for the chosen mode (e.g. all tasks priority-filtered and only-shown on)
-  // - TODO(later): enable for PROJREVIEW/PROJACT
+// - hide when there is nothing actionable for the chosen mode (e.g. all tasks priority-filtered and only-shown on)
   const ipSourceItems = moveOnlyShownItemsWhenFiltered ? itemsToShow : allSortedItems
-  const ipItemCount = countInteractiveProcessingItems(ipSourceItems)
+const ipItemCount = countInteractiveProcessingItems(ipSourceItems, section.sectionCode)
   const showIPButton =
     dashboardSettings.enableInteractiveProcessing &&
     interactiveProcessingPossibleSectionTypes.includes(section.sectionCode) &&
 
@@ -1,7 +1,7 @@
 // @flow
 //--------------------------------------------------------------------------
 // Helpers for the Section component.
-// Last updated 2026-08-21 for v2.4.1 by @jgclark + @CursorAI
+// Last updated 2026-08-21 for v2.5.0, @jgclark + @CursorAI
 //--------------------------------------------------------------------------
 
 import type { TSection, TSectionItem, TDashboardSettings, TDashboardSettingsIn, TSectionCode, TSectionDetails, TSettingItem } from '../../../types.js'
@@ -23,31 +23,39 @@ export function countRealSectionItems(items: ?Array<TSectionItem>): number {
 
 /**
  * Whether a section row can be walked by Interactive Processing.
- * Includes open tasks, checklists, and Apple Reminders (#779).
+ * Includes open tasks, checklists, Apple Reminders (#779), and project rows (PROJACT/PROJREVIEW).
+ * Callers for PROJ* must still restrict to `project` only via getInteractiveProcessingItems(sectionCode).
  * @param {TSectionItem} item
  * @returns {boolean}
  */
 export function isInteractiveProcessingItem(item: TSectionItem): boolean {
-  return item.itemType === 'open' || item.itemType === 'checklist' || item.itemType === 'reminder'
+  return item.itemType === 'open' || item.itemType === 'checklist' || item.itemType === 'reminder' || item.itemType === 'project'
 }
 
 /**
  * Rows Interactive Processing will actually process from a candidate list.
+ * For PROJACT / PROJREVIEW, only `project` rows (not next-action task children).
  * @param {?Array<TSectionItem>} items
+ * @param {?TSectionCode | string} sectionCode
  * @returns {Array<TSectionItem>}
  */
-export function getInteractiveProcessingItems(items: ?Array<TSectionItem>): Array<TSectionItem> {
+export function getInteractiveProcessingItems(items: ?Array<TSectionItem>, sectionCode: ?TSectionCode | string = null): Array<TSectionItem> {
   if (!items || items.length === 0) return []
-  return items.filter(isInteractiveProcessingItem)
+  const processable = items.filter(isInteractiveProcessingItem)
+  if (sectionCode === 'PROJACT' || sectionCode === 'PROJREVIEW') {
+    return processable.filter((item) => item.itemType === 'project')
+  }
+  return processable
 }
 
 /**
  * Count of Interactive Processing processable rows (must match getInteractiveProcessingItems).
  * @param {?Array<TSectionItem>} items
+ * @param {?TSectionCode | string} sectionCode
  * @returns {number}
  */
-export function countInteractiveProcessingItems(items: ?Array<TSectionItem>): number {
-  return getInteractiveProcessingItems(items).length
+export function countInteractiveProcessingItems(items: ?Array<TSectionItem>, sectionCode: ?TSectionCode | string = null): number {
+  return getInteractiveProcessingItems(items, sectionCode).length
 }
 
 /**
 
@@ -1,6 +1,6 @@
 // @flow
 //--------------------------------------------------------------------------
-// Shared Interactive Processing helpers for task and reminder dialogs.
+// Shared Interactive Processing helpers for task, reminder, and project dialogs.
 // Last updated 2026-08-21 for v2.4.1 by @CursorAI
 //--------------------------------------------------------------------------
 
@@ -16,6 +16,16 @@ export type TInteractiveProcessingState = {
   clickPosition?: { clientX: number, clientY: number },
 }
 
+/**
+ * Whether Dialog.jsx should use the task/reminder slot (vs project dialog).
+ * Reminders keep isTask true and are routed by itemType; projects need isTask false.
+ * @param {?TIPVisibleItem | TSectionItem} item
+ * @returns {boolean}
+ */
+export function isTaskDialogItem(item: ?TIPVisibleItem | TSectionItem): boolean {
+  return item?.itemType !== 'project'
+}
+
 /**
  * Next unprocessed index in the IP list (forward by default), or -1 if none remain.
  * @param {?Array<TIPVisibleItem>} visibleItems
@@ -97,14 +107,15 @@ export function buildReactSettingsForIPBackNavigate(prevSettings: any): any {
   if (!visibleItems || typeof currentIPIndex !== 'number' || currentIPIndex <= 0) return prevSettings
 
   const newIPIndex = currentIPIndex - 1
+  const nextItem = visibleItems[newIPIndex]
   return {
     ...prevSettings,
     interactiveProcessing: { ...interactiveProcessing, currentIPIndex: newIPIndex },
     dialogData: {
       ...prevSettings.dialogData,
       isOpen: true,
-      isTask: true,
-      details: { ...prevSettings.dialogData.details, item: visibleItems[newIPIndex] },
+      isTask: isTaskDialogItem(nextItem),
+      details: { ...prevSettings.dialogData.details, item: nextItem },
     },
     lastChange: `_Dashboard-handleIPBackNavigate to index ${String(newIPIndex)}`,
   }
@@ -131,15 +142,16 @@ export function buildReactSettingsAfterIPAdvance(
   const newIPIndex = getNextIPIndex(visibleItems, currentIPIndex, !skipForward)
 
   if (newIPIndex !== -1) {
+    const nextItem = visibleItems[newIPIndex]
     return {
       ...prevSettings,
       interactiveProcessing: { ...interactiveProcessing, currentIPIndex: newIPIndex, visibleItems },
       dialogData: {
         ...prevSettings.dialogData,
         isOpen: true,
-        // Keep non-project dialogs in the task/reminder slot; Dialog.jsx routes by itemType
-        isTask: true,
-        details: { ...prevSettings.dialogData.details, item: visibleItems[newIPIndex] },
+        // Project rows need isTask false; reminders keep true and Dialog.jsx routes by itemType
+        isTask: isTaskDialogItem(nextItem),
+        details: { ...prevSettings.dialogData.details, item: nextItem },
       },
       lastChange: `_Dashboard-handleIPItemProcessed more IP items to process`,
     }
@@ -151,7 +163,7 @@ export function buildReactSettingsAfterIPAdvance(
     dialogData: {
       ...prevSettings.dialogData,
       isOpen: false,
-      isTask: true,
+      isTask: isTaskDialogItem(visibleItems[currentIPIndex]),
     },
     lastChange: `_Dashboard-handleIPItemProcessed no more IP items to process`,
   }
 
@@ -9,6 +9,7 @@ import {
   canNavigateBackInIP,
   getNextIPIndex,
   ipItemsHaveBeenSkipped,
+  isTaskDialogItem,
   markCurrentIPItemProcessed,
 } from '../interactiveProcessingHelpers.js'
 
@@ -63,6 +64,15 @@ describe('interactiveProcessingHelpers', () => {
     })
   })
 
+  describe('isTaskDialogItem', () => {
+    test('is false only for project rows', () => {
+      expect(isTaskDialogItem({ ID: 'p', itemType: 'project' })).toBe(false)
+      expect(isTaskDialogItem({ ID: 't', itemType: 'open' })).toBe(true)
+      expect(isTaskDialogItem({ ID: 'r', itemType: 'reminder' })).toBe(true)
+      expect(isTaskDialogItem(null)).toBe(true)
+    })
+  })
+
   describe('canNavigateBackInIP / buildReactSettingsForIPBackNavigate', () => {
     test('canNavigateBackInIP is true from the second item', () => {
       expect(canNavigateBackInIP(0)).toBe(false)
@@ -80,10 +90,23 @@ describe('interactiveProcessingHelpers', () => {
       const next = buildReactSettingsForIPBackNavigate(prev)
       expect(next.interactiveProcessing.currentIPIndex).toBe(0)
       expect(next.dialogData.details.item).toEqual(a)
+      expect(next.dialogData.isTask).toBe(true)
 
       const atStart = { ...prev, interactiveProcessing: { ...prev.interactiveProcessing, currentIPIndex: 0 } }
       expect(buildReactSettingsForIPBackNavigate(atStart)).toBe(atStart)
     })
+
+    test('buildReactSettingsForIPBackNavigate sets isTask false for projects', () => {
+      const a = { ID: 'a', itemType: 'project' }
+      const b = { ID: 'b', itemType: 'project' }
+      const prev = {
+        interactiveProcessing: { currentIPIndex: 1, totalTasks: 2, visibleItems: [a, b] },
+        dialogData: { isOpen: true, isTask: false, details: { item: b } },
+      }
+      const next = buildReactSettingsForIPBackNavigate(prev)
+      expect(next.dialogData.isTask).toBe(false)
+      expect(next.dialogData.details.item).toEqual(a)
+    })
   })
 
   describe('buildReactSettingsAfterIPAdvance', () => {
@@ -102,10 +125,28 @@ describe('interactiveProcessingHelpers', () => {
       expect(mid.interactiveProcessing.currentIPIndex).toBe(1)
       expect(mid.dialogData.details.item).toEqual(reminder)
       expect(mid.dialogData.isOpen).toBe(true)
+      expect(mid.dialogData.isTask).toBe(true)
 
       const end = buildReactSettingsAfterIPAdvance(mid, { skippedItem: false, skipForward: true })
       expect(end.interactiveProcessing).toBeNull()
       expect(end.dialogData.isOpen).toBe(false)
     })
+
+    test('keeps isTask false when advancing between project rows', () => {
+      const p1 = { ID: 'p1', itemType: 'project' }
+      const p2 = { ID: 'p2', itemType: 'project' }
+      const prev = {
+        interactiveProcessing: {
+          currentIPIndex: 0,
+          totalTasks: 2,
+          visibleItems: [p1, p2],
+        },
+        dialogData: { isOpen: true, isTask: false, details: { item: p1 } },
+      }
+      const mid = buildReactSettingsAfterIPAdvance(prev, { skippedItem: false, skipForward: true, markTaskChildren: false })
+      expect(mid.interactiveProcessing.currentIPIndex).toBe(1)
+      expect(mid.dialogData.isTask).toBe(false)
+      expect(mid.dialogData.details.item).toEqual(p2)
+    })
   })
 })
@@ -20,25 +20,34 @@ describe('sectionHelpers', () => {
     const openTask = { ID: '1', itemType: 'open' }
     const checklist = { ID: '2', itemType: 'checklist' }
     const reminder = { ID: '3', itemType: 'reminder' }
+    const project = { ID: '6', itemType: 'project' }
     const congrats = { ID: '4', itemType: 'itemCongrats' }
     const filterMsg = { ID: '5', itemType: 'filterIndicator' }
 
-    test('isInteractiveProcessingItem is true for open, checklist, and reminder', () => {
+    test('isInteractiveProcessingItem is true for open, checklist, reminder, and project', () => {
       expect(sh.isInteractiveProcessingItem(openTask)).toBe(true)
       expect(sh.isInteractiveProcessingItem(checklist)).toBe(true)
       expect(sh.isInteractiveProcessingItem(reminder)).toBe(true)
+      expect(sh.isInteractiveProcessingItem(project)).toBe(true)
       expect(sh.isInteractiveProcessingItem(congrats)).toBe(false)
       expect(sh.isInteractiveProcessingItem(filterMsg)).toBe(false)
     })
 
-    test('getInteractiveProcessingItems keeps tasks and reminders; drops message rows', () => {
-      const mixed = [openTask, reminder, checklist, congrats, filterMsg]
-      expect(sh.getInteractiveProcessingItems(mixed)).toEqual([openTask, reminder, checklist])
+    test('getInteractiveProcessingItems keeps tasks, reminders, and projects; drops message rows', () => {
+      const mixed = [openTask, reminder, checklist, project, congrats, filterMsg]
+      expect(sh.getInteractiveProcessingItems(mixed)).toEqual([openTask, reminder, checklist, project])
+    })
+
+    test('getInteractiveProcessingItems for PROJ* keeps project rows only (not next-action tasks)', () => {
+      const mixed = [project, openTask, checklist, congrats]
+      expect(sh.getInteractiveProcessingItems(mixed, 'PROJACT')).toEqual([project])
+      expect(sh.getInteractiveProcessingItems(mixed, 'PROJREVIEW')).toEqual([project])
+      expect(sh.countInteractiveProcessingItems(mixed, 'PROJACT')).toBe(1)
     })
 
     test('countInteractiveProcessingItems matches filtered length (IP button N)', () => {
-      const mixed = [openTask, reminder, reminder, checklist]
-      expect(sh.countInteractiveProcessingItems(mixed)).toBe(4)
+      const mixed = [openTask, reminder, reminder, checklist, project]
+      expect(sh.countInteractiveProcessingItems(mixed)).toBe(5)
       expect(sh.countInteractiveProcessingItems([])).toBe(0)
       expect(sh.countInteractiveProcessingItems(null)).toBe(0)
       expect(sh.countInteractiveProcessingItems([congrats, filterMsg])).toBe(0)