@@ -14,7 +14,7 @@ import { displayTitle, rangeToString } from '@helpers/general'
 import { getNoteType } from '@helpers/note'
 import { getFirstDateInPeriod, getNPWeekData, getMonthData, getQuarterData, getYearData, nowDoneDateTimeString, toLocaleDateTimeString } from '@helpers/NPdateTime'
 import { endOfFrontmatterLineIndex, noteHasFrontMatter } from '@helpers/NPFrontMatter'
-import { findStartOfActivePartOfNote, isTermInMarkdownPath, isTermInURL } from '@helpers/paragraph'
+import { convertRawContentToContent, findStartOfActivePartOfNote, isTermInMarkdownPath, isTermInURL } from '@helpers/paragraph'
 import { RE_FIRST_SCHEDULED_DATE_CAPTURE } from '@helpers/regex'
 import { caseInsensitiveMatch, caseInsensitiveSubstringMatch, caseInsensitiveStartsWith, getLineMainContentPos } from '@helpers/search'
 import { stripTodaysDateRefsFromString } from '@helpers/stringTransforms'
@@ -1196,10 +1196,25 @@ export function createStaticParagraphsArray(arrayOfObjects: Array<any>, fields:
   return staticArray
 }
 
+/**
+ * Compare two rawContent strings, allowing for leading-indent differences.
+ * Needed because NotePlan backlinks return indented paras with indent stripped from .rawContent (indent always 0).
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+export function rawContentMatchesIgnoringLeadingIndent(a: string, b: string): boolean {
+  if (a === b) return true
+  // trimStart is ES2019; use replace for broader compatibility in NP's JSContext
+  const stripLeading = (s: string): string => s.replace(/^\s+/, '')
+  return stripLeading(a) === stripLeading(b)
+}
+
 /**
  * Check a paragraph object against a plain object of fields to see if they match.
  * Does an explicit match for specified fields but if the content is truncated with "..." it will match if the truncated version is the same
  * (this works around a bug in DataStore.listOverdueTasks where it was truncating the paragraph content at 300 chars)
+ * For rawContent, also allows leading-indent differences (as backlinks API unhelpfully returns indent-stripped rawContent).
  * @param {TParagraph} paragraph object to check
  * @param {any} fieldsObject object with some fields
  * @param {Array<string>} fields list of field names to check in fieldsObject
@@ -1216,12 +1231,26 @@ export function paragraphMatches(paragraph: TParagraph, fieldsObject: any, field
 
   fields.forEach((field) => {
     if (field === 'rawContent' && rawWasEdited) {
-      if (paragraph[field] !== fieldsObject['originalRawContent']) {
+      if (!rawContentMatchesIgnoringLeadingIndent(paragraph[field], fieldsObject['originalRawContent'])) {
         match = false
       }
     } else if (field === 'rawContent' && isTruncated) {
-      // Use startsWith for truncated rawContent
-      if (!paragraph[field].startsWith(truncatedContent)) {
+      // Use startsWith for truncated rawContent (also try after stripping leading indent on the note para)
+      const paraRaw = paragraph[field]
+      const paraRawStripped = paraRaw.replace(/^\s+/, '')
+      if (!paraRaw.startsWith(truncatedContent) && !paraRawStripped.startsWith(truncatedContent.replace(/^\s+/, ''))) {
+        match = false
+      }
+    } else if (field === 'rawContent') {
+      // $FlowIgnore[prop-missing]
+      if (typeof paragraph[field] === 'undefined') {
+        throw `paragraphMatches: paragraph.${field} is undefined. You must pass in the correct fields to match. 'fields' is set to ${JSP(fields)}, but paragraph=${JSP(
+          paragraph,
+        )}, which does not have all the fields`
+      }
+      // Exact match, or match ignoring leading indent (backlinks strip indent from rawContent)
+      // $FlowIgnore[prop-missing]
+      if (!rawContentMatchesIgnoringLeadingIndent(paragraph[field], fieldsObject[field])) {
         match = false
       }
     } else {
@@ -1303,13 +1332,12 @@ export function findParagraph(
 
 /**
  * Take a static object with a subset of Paragraph fields from HTML or wherever and return the actual paragraph in the note
+ * Note: rawContent matching allows leading-indent differences (as backlinks API unhelpfully returns indent-stripped rawContent for indented paras).
  * @param {any} staticObject - the static object from the HTML must have fields:
  *    filename, lineIndex, noteType
  * @param {Array<string>} fieldsToMatch - (optional) array of fields to match (e.g. filename, lineIndex) -- these two fields are required. default is ['filename', 'rawContent']
  * @returns {TParagraph|null} - the paragraph or null if not found
  * @author @dwertheimer
- * TODO(@dwertheimer): is the fieldsToMatch default and passing down to findParagraph correct?
- * FIXME: fails because indents is 0 not 1
  */
 export function getParagraphFromStaticObject(staticObject: any, fieldsToMatch: Array<string> = ['filename', 'rawContent']): TParagraph | null {
   const { filename } = staticObject
@@ -1385,6 +1413,7 @@ export function findParaFromStringAndFilename(filenameIn: string, content: strin
  * Return a TParagraph object by an exact match to 'rawContent' in file 'filenameIn'. If it fails to find a match, it returns false.
  * If the rawContent is truncated with "..." it will match if the truncated version is the same as the start of the rawContent in a line in the note
  * (this works around a bug in DataStore.listOverdueTasks where it was truncating the paragraph rawContent at 300 chars).
+ * Also falls back to matching ignoring leading indent (as backlinks API unhelpfully strips indent from .rawContent), then to .content match.
  * Designed to be called when you're not in an Editor (e.g. an HTML Window).
  * Works on both Regular ('Project') and Calendar notes.
  * Note: updated in Nov 2025 to work for Teamspace notes as well.
@@ -1410,16 +1439,40 @@ export function findParaFromRawContentAndFilename(filenameIn: string, rawContent
       if (thisNote.paragraphs.length > 0) {
         const isTruncated = rawContentIn.endsWith('...')
         const truncatedContent = isTruncated ? rawContentIn.slice(0, -3) : rawContentIn // only slice if truncated
+        const searchRawStripped = rawContentIn.replace(/^\s+/, '')
+        const contentFallback = convertRawContentToContent(rawContentIn)
 
-        // let c = 0
+        // Pass 1: exact (or truncated prefix) match
         for (const para of thisNote.paragraphs) {
           if (isTruncated ? para.rawContent.startsWith(truncatedContent) : para.rawContent === rawContentIn) {
-            // logDebug('NPP/findParaFromRawContentAndFilename', `found matching para #${c} of type ${para.type}: {${rawContentIn}}`)
             return para
           }
-          // c++
         }
-        logWarn('NPP/findParaFromRawContentAndFilename', `Couldn't find paragraph {${rawContentIn}} in note '${filename}'`)
+        // Pass 2: match ignoring leading indent (backlinks API strips indent from .rawContent)
+        for (const para of thisNote.paragraphs) {
+          if (rawContentMatchesIgnoringLeadingIndent(para.rawContent, rawContentIn)) {
+            logDebug('NPP/findParaFromRawContentAndFilename', `matched via leading-indent-insensitive rawContent for {${rawContentIn}}`)
+            return para
+          }
+          if (isTruncated) {
+            const paraStripped = para.rawContent.replace(/^\s+/, '')
+            const truncatedStripped = truncatedContent.replace(/^\s+/, '')
+            if (paraStripped.startsWith(truncatedStripped) || para.rawContent.startsWith(truncatedStripped)) {
+              logDebug('NPP/findParaFromRawContentAndFilename', `matched truncated rawContent ignoring leading indent for {${rawContentIn}}`)
+              return para
+            }
+          }
+        }
+        // Pass 3: fall back to .content match (derived from rawContent)
+        if (contentFallback && contentFallback !== '<error>') {
+          for (const para of thisNote.paragraphs) {
+            if (para.content === contentFallback) {
+              logDebug('NPP/findParaFromRawContentAndFilename', `matched via content fallback {${contentFallback}} for rawContent {${rawContentIn}}`)
+              return para
+            }
+          }
+        }
+        logWarn('NPP/findParaFromRawContentAndFilename', `Couldn't find paragraph {${rawContentIn}} (stripped:{${searchRawStripped}}) in note '${filename}'`)
         return false
       } else {
         logInfo('NPP/findParaFromRawContentAndFilename', `Note '${filename}' appears to be empty?`)
@@ -1831,13 +1884,6 @@ export function getSelectedParagraphsWithCorrectLineIndex(): Array<TParagraph> {
     const selectedParagraphs = Editor.selectedParagraphs.map((p: TParagraph) => note.paragraphs[p.lineIndex + numberOfFrontmatterLines]) ?? []
     logDebug('getSelectedParagraphsWithCorrectLineIndex', `Editor.selectedParagraphs:\n${String(Editor.selectedParagraphs.map((p) => `- #${p.lineIndex}: ${p.content}`).join('\n'))}`)
 
-    // TEST: removing this, as the necessary change has been made above
-    // const correctedSelectedParagraphs: Array<TParagraph> = selectedParagraphs.slice()
-    // correctedSelectedParagraphs.forEach((p: TParagraph) => {
-    //   p.lineIndex += numberOfFrontmatterLines
-    // })
-    // logDebug('getSelectedParagraphsWithCorrectLineIndex', `${correctedSelectedParagraphs.length} Corrected selected paragraph(s) with lineIndex taking into account frontmatter lines:\n${String(correctedSelectedParagraphs.map((p) => `- ${p.lineIndex}: ${p.content}`).join('\n'))}`)
-
     return selectedParagraphs
   } catch (error) {
     logError('getSelectedParagraphsWithCorrectLineIndex', error.message)
 
@@ -750,6 +750,42 @@ export function getFlatListOfBacklinks(note: TNote): Array<TParagraph> {
   }
 }
 
+/**
+ * Resolve a backlink paragraph to the real paragraph in its source note.
+ * NotePlan's backlinks API deliberately, but unhelpfully, returns indented paras with indent stripped from .rawContent / .indents always 0.
+ * Looking up by lineIndex (preferring content match) or by content alone restores correct rawContent/indents.
+ * @author @jgclark + @Cursor
+ * @param {TParagraph} backlinkPara
+ * @returns {TParagraph} real note paragraph when found, otherwise the original backlink para
+ */
+export function resolveBacklinkParaToRealPara(backlinkPara: TParagraph): TParagraph {
+  try {
+    if (!backlinkPara) return backlinkPara
+    const note: ?TNote = backlinkPara.note
+      || (backlinkPara.filename
+        ? DataStore.noteByFilename(backlinkPara.filename, backlinkPara.noteType || 'Notes')
+        || DataStore.noteByFilename(backlinkPara.filename, 'Calendar')
+        : null)
+    if (!note || !note.paragraphs?.length) return backlinkPara
+
+    // Prefer lineIndex when content still matches (line may have moved)
+    if (typeof backlinkPara.lineIndex === 'number' && note.paragraphs[backlinkPara.lineIndex]) {
+      const candidate = note.paragraphs[backlinkPara.lineIndex]
+      if (candidate.content === backlinkPara.content) {
+        return candidate
+      }
+    }
+    // Fall back to exact content match
+    const byContent = note.paragraphs.find((p) => p.content === backlinkPara.content)
+    if (byContent) return byContent
+
+    return backlinkPara
+  } catch (err) {
+    logWarn('resolveBacklinkParaToRealPara', `falling back to backlink para: ${err.message}`)
+    return backlinkPara
+  }
+}
+
 /**
  * Get the paragraphs in 'note' which are scheduled for date of the *private* calendar note 'calNote'
  * TEST: Is this working in or from Teamspace notes? Initial testing on 20.8.25 by @jgclark implies not.
@@ -765,7 +801,7 @@ export function getReferencedParagraphs(calNote: Note, includeHeadings: boolean
 
     // Use .backlinks, which is described as "Get all backlinks pointing to the current note as Paragraph objects. In this array, the toplevel items are all notes linking to the current note and the 'subItems' attributes (of the paragraph objects) contain the paragraphs with a link to the current note. The headings of the linked paragraphs are also listed here, although they don't have to contain a link."
     // Note: @jgclark reckons that the subItem.headingLevel data returned by this might be wrong.
-    // Note: @EM confirms that this returns backlinks only with indent 0, by design. @jgclark has added a helper to help with this issue.
+    // Note: @EM confirms that this returns backlinks only with indent 0, by design. resolveBacklinkParaToRealPara() restores correct rawContent/indents.
     const backlinkParas: Array<TParagraph> = getFlatListOfBacklinks(calNote) // an array of notes which link to this note
     logDebug(`getReferencedParagraphs`, `found ${String(backlinkParas.length)} backlinked paras for ${displayTitle(calNote)}:`)
 
@@ -776,21 +812,24 @@ export function getReferencedParagraphs(calNote: Note, includeHeadings: boolean
           'getReferencedParagraphs',
           `  - referenced para is null. Found in one of ${backlinkParas.length} backlink paras for note '${displayTitle(calNote)}' at ${calNote.filename}.`,
         )
+        return
       }
       if (includeHeadings) {
         // logDebug(`getReferencedParagraphs`, `- adding  "${para.content}" as we want headings`)
+        wantedParas.push(resolveBacklinkParaToRealPara(para))
       } else if (para.content.includes(`>${thisDateStr}`) || para.content.includes(`>today`)) {
-        logDebug(`getReferencedParagraphs`, `- adding #${para.lineIndex}: '${para.content}' as it includes >${thisDateStr} or >today from ${para.note?.filename ?? '<no note>'}`)
-        if (!para.note) {
+        const resolved = resolveBacklinkParaToRealPara(para)
+        logDebug(`getReferencedParagraphs`, `- adding #${resolved.lineIndex}: '${resolved.content}' as it includes >${thisDateStr} or >today from ${resolved.note?.filename ?? '<no note>'}`)
+        if (!resolved.note) {
           logWarn(`getReferencedParagraphs`, `  - this backlink para.note is null. Para:\n${JSON.stringify(para, null, 2)}`)
         }
 
         // Log if content contains TEST. TODO(later): remove after testing backlinks workaround
-        if (para.content.includes('TEST')) {
-          logInfo(`getReferencedParagraphs`, `FYI 👉 found TEST in #${para.lineIndex}: '${calNote.filename}' [${para.type}] {${para.rawContent}}`)
+        if (resolved.content.includes('TEST')) {
+          logInfo(`getReferencedParagraphs`, `FYI 👉 found TEST in #${resolved.lineIndex}: '${calNote.filename}' [${resolved.type}] {${resolved.rawContent}}`)
         }
 
-        wantedParas.push(para)
+        wantedParas.push(resolved)
       } else {
         // logDebug(`getReferencedParagraphs`, `- skipping "${para.content}" as it doesn't include >${thisDateStr}`)
       }
 
@@ -1002,6 +1002,27 @@ describe('NPParagraphs()', () => {
       expect(p.paragraphMatches(paragraph, fieldsObject, fields)).toBe(true)
     })
 
+    test('should return true when rawContent differs only by leading indent (as backlinks strip indent)', () => {
+      const paragraph = { rawContent: '\t* Watch something', filename: 'test.md' }
+      const fieldsObject = { rawContent: '* Watch something', filename: 'test.md' }
+      const fields = ['rawContent', 'filename']
+      expect(p.paragraphMatches(paragraph, fieldsObject, fields)).toBe(true)
+    })
+
+    test('should return true when search rawContent has indent and note does not', () => {
+      const paragraph = { rawContent: '* Watch something', filename: 'test.md' }
+      const fieldsObject = { rawContent: '\t* Watch something', filename: 'test.md' }
+      const fields = ['rawContent', 'filename']
+      expect(p.paragraphMatches(paragraph, fieldsObject, fields)).toBe(true)
+    })
+
+    test('should return false when rawContent differs beyond leading indent', () => {
+      const paragraph = { rawContent: '\t* Watch something', filename: 'test.md' }
+      const fieldsObject = { rawContent: '* Different task', filename: 'test.md' }
+      const fields = ['rawContent', 'filename']
+      expect(p.paragraphMatches(paragraph, fieldsObject, fields)).toBe(false)
+    })
+
     test('should throw an error if a field in fields is not present in paragraph', () => {
       const paragraph = { rawContent: 'Test content', filename: 'test.md' }
       const fieldsObject = { rawContent: 'Test content', filename: 'test.md' }
@@ -1029,6 +1050,24 @@ describe('NPParagraphs()', () => {
       expect(p.paragraphMatches(paragraph, fieldsObject, fields)).toBe(true)
     })
   })
+
+  describe('rawContentMatchesIgnoringLeadingIndent()', () => {
+    test('should match identical strings', () => {
+      expect(p.rawContentMatchesIgnoringLeadingIndent('* Task', '* Task')).toBe(true)
+    })
+
+    test('should match when one side has leading tab', () => {
+      expect(p.rawContentMatchesIgnoringLeadingIndent('\t* Watch something', '* Watch something')).toBe(true)
+    })
+
+    test('should match when one side has leading spaces', () => {
+      expect(p.rawContentMatchesIgnoringLeadingIndent('  * Watch something', '* Watch something')).toBe(true)
+    })
+
+    test('should not match different content', () => {
+      expect(p.rawContentMatchesIgnoringLeadingIndent('\t* Watch something', '* Other')).toBe(false)
+    })
+  })
 })
 
 // ----------------------------------------------------------------------------
 
@@ -8,6 +8,10 @@ For more details see the [plugin's documentation](https://github.com/NotePlan/pl
 - TODO: fix long-standing layout bug where some tooltips were getting clipped
 - TODO: fix isNoteFromAllowedFolder() for teamspace or possibly 2025-W21.md
 -->
+## [2.4.0.b54] 2026-07-22
+- Fix: moving / rescheduling **indented** tasks and checklists no longer fails to find the paragraph. Matching now allows leading-indent differences (NotePlan backlinks return indent-stripped rawContent), and referenced paras are resolved back to the real note paragraph so "Move All → ..." and dialog actions keep correct indent.
+- Fix: saying **No** to the bulk-move confirmation (e.g. Move All This Week → Next Week) no longer shows a "something's gone wrong" banner; it only logs that the user cancelled.
+
 ## [2.4.0.b53] 2026-07-21
 - Fix to layout that was pushing the notelinks down to a third line in some cases
 - Change: mid-task and source note links now show a shorter label -- use NotePlan `[alias]([[title]])` when present, drop `#heading`, and truncate titles over 50 characters with `…`