@im-nobsidian/core 0.19.1 → 0.21.0

package/dist/index.js

@@ -13397,6 +13397,29 @@ var ImageHandler = class {
   get fetchFn() {
     return this.customFetch ?? globalThis.fetch;
   }
+  /** {@link preview} 안에서 도는 중인 렌더 수 — 0 보다 크면 받은 미디어를 볼트에 쓰지 않고 상태 DB 에 적지 않는다. */
+  previewDepth = 0;
+  /**
+   * 받기를 미리 본다(dry-run) — 미디어를 실제 pull 처럼 받아 이름(내용 해시)과 임베드를 정하되 볼트에 쓰지 않고 상태 DB 에
+   * 적지 않는다. 받지 않고 렌더하면 미디어가 원격 주소로 남아, 받은 글을 볼트의 노트와 견줄 수 없다.
+   */
+  async preview(run) {
+    this.previewDepth++;
+    try {
+      return await run();
+    } finally {
+      this.previewDepth--;
+    }
+  }
+  get previewing() {
+    return this.previewDepth > 0;
+  }
+  /** 받은 파일을 볼트에 쓴다 — 미리 보기에서는 쓰지 않는다({@link preview}). */
+  async writeDownload(localPath, buffer) {
+    if (this.previewing) return;
+    await this.vaultFs.ensureFolder(this.attachmentFolder);
+    await this.vaultFs.writeBinary(localPath, buffer);
+  }
   /** 상한 로직은 첨부 경로와 공유한다 — 한쪽만 빠뜨리지 않도록(utils/download-fetch). */
   fetchForDownload(url) {
     return fetchForDownload(this.fetchFn, url, this.downloadTimeoutMs);
@@ -13460,8 +13483,7 @@ var ImageHandler = class {
     return null;
   }
   async persistImage(fetched) {
-    await this.vaultFs.ensureFolder(this.attachmentFolder);
-    await this.vaultFs.writeBinary(fetched.localPath, fetched.buffer);
+    await this.writeDownload(fetched.localPath, fetched.buffer);
     return {
       originalUrl: fetched.originalUrl,
       localPath: fetched.localPath,
@@ -13530,7 +13552,7 @@ var ImageHandler = class {
         }
         if (localHash !== remoteHash) continue;
         const fileId = notionFileIdOf(span.url);
-        if (fileId && this.stateDb) {
+        if (fileId && this.stateDb && !this.previewing) {
           rememberReceivedMedia(this.stateDb, pageId, [
             { fileId, target, localPath: candidate, fileHash: remoteHash }
           ]);
@@ -14001,7 +14023,7 @@ var ImageHandler = class {
    */
   rememberReceived(pageId, received) {
     const media = received.filter((item) => item !== null);
-    if (!pageId || !this.stateDb || media.length === 0) return;
+    if (!pageId || !this.stateDb || media.length === 0 || this.previewing) return;
     try {
       rememberReceivedMedia(this.stateDb, pageId, media);
     } catch (error) {
@@ -14250,8 +14272,7 @@ var ImageHandler = class {
             name
           };
         }
-        await this.vaultFs.ensureFolder(this.attachmentFolder);
-        await this.vaultFs.writeBinary(localPath, buffer);
+        await this.writeDownload(localPath, buffer);
         return { originalUrl: url, localPath, hash, size: buffer.length, fileHash, name };
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
@@ -15163,12 +15184,56 @@ function folderFilesOf(markdown, namedOnly) {
   for (const span of notionMediaSpans(rest)) {
     if (!/^https?:\/\//.test(span.url)) return null;
     const name = uploadedFileNameFromUrl(span.url);
-    if (!name || namedOnly && unescapeCaption(span.label) !== name) return null;
+    if (!name) return null;
+    if (namedOnly && unescapeCaption(span.label) !== name && !isMarkedCaption(span.label, name)) {
+      return null;
+    }
     rest = rest.replace(span.full, "");
     files.push({ url: span.url, name });
   }
   return files.length > 0 && rest.trim() === "" ? files : null;
 }
+var FOLDER_FILE_MARK = "\u{1F4C1}";
+function folderFileCaption(name) {
+  return `${FOLDER_FILE_MARK} ${name}`;
+}
+function isMarkedCaption(label, name) {
+  return unescapeCaption(label) === folderFileCaption(name);
+}
+var FENCE_RE = /^(`{3,}|~{3,})/;
+function folderFilesInNote(markdown, options = {}) {
+  const all = markdown.split("\n");
+  const drop = /* @__PURE__ */ new Set();
+  const files = [];
+  const lines = [];
+  let fence = null;
+  all.forEach((line, i) => {
+    const opener = FENCE_RE.exec(line)?.[1];
+    if (opener !== void 0 && (fence === null || opener.startsWith(fence))) {
+      fence = fence === null ? opener : null;
+      return;
+    }
+    if (fence !== null) return;
+    const full = line.trimEnd();
+    const [span, ...more] = notionMediaSpans(full);
+    if (!span || more.length > 0 || span.full !== full || !/^https?:\/\//.test(span.url)) return;
+    const name = uploadedFileNameFromUrl(span.url);
+    if (!name) return;
+    const fileId = notionFileIdOf(span.url);
+    const marked = isMarkedCaption(span.label, name) || fileId !== null && options.knownIds?.has(fileId) === true;
+    const file = { url: span.url, name };
+    if (!marked || options.exclude?.(file)) return;
+    drop.add(i);
+    files.push(file);
+    lines.push(full);
+  });
+  if (files.length === 0) return null;
+  return {
+    markdown: all.filter((_, i) => !drop.has(i)).join("\n"),
+    files,
+    lines
+  };
+}
 var WIKI_EMBED_RE = /!\[\[([^\]|#^\n]+)/g;
 var MD_EMBED_RE = /!\[[^\]\n]*\]\(<?([^)>\s]+)/g;
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -15196,8 +15261,8 @@ function embeddedNamesOf(notes) {
 function keyOf3(pageId) {
   return `folder_files:${compactNotionId(pageId)}`;
 }
-function folderFileIdsOf(stateDb, pageId) {
-  const raw = stateDb.getMeta(keyOf3(pageId));
+function readPathMap(stateDb, key) {
+  const raw = stateDb.getMeta(key);
   if (!raw) return /* @__PURE__ */ new Map();
   try {
     return new Map(Object.entries(JSON.parse(raw)));
@@ -15205,16 +15270,39 @@ function folderFileIdsOf(stateDb, pageId) {
     return /* @__PURE__ */ new Map();
   }
 }
+function writePathMap(stateDb, key, map) {
+  stateDb.setMeta(key, JSON.stringify(Object.fromEntries(map)));
+}
+function folderFileIdsOf(stateDb, pageId) {
+  return readPathMap(stateDb, keyOf3(pageId));
+}
 function forgetFolderFileId(stateDb, pageId, localPath) {
+  rememberFolderFileStamp(stateDb, pageId, localPath, null);
   const ids = folderFileIdsOf(stateDb, pageId);
   if (!ids.delete(localPath)) return;
-  stateDb.setMeta(keyOf3(pageId), JSON.stringify(Object.fromEntries(ids)));
+  writePathMap(stateDb, keyOf3(pageId), ids);
 }
 function rememberFolderFileId(stateDb, pageId, localPath, fileId) {
   const ids = folderFileIdsOf(stateDb, pageId);
   if (ids.get(localPath) === fileId) return;
   ids.set(localPath, fileId);
-  stateDb.setMeta(keyOf3(pageId), JSON.stringify(Object.fromEntries(ids)));
+  writePathMap(stateDb, keyOf3(pageId), ids);
+}
+function fileStampOf(file) {
+  return `${file.size}:${file.mtime}`;
+}
+function stampKeyOf(pageId) {
+  return `folder_file_stamps:${compactNotionId(pageId)}`;
+}
+function folderFileStampsOf(stateDb, pageId) {
+  return readPathMap(stateDb, stampKeyOf(pageId));
+}
+function rememberFolderFileStamp(stateDb, pageId, localPath, stamp) {
+  const stamps = folderFileStampsOf(stateDb, pageId);
+  if ((stamps.get(localPath) ?? null) === stamp) return;
+  if (stamp === null) stamps.delete(localPath);
+  else stamps.set(localPath, stamp);
+  writePathMap(stateDb, stampKeyOf(pageId), stamps);
 }
 
 // src/sync/file-handler.ts
@@ -15225,6 +15313,12 @@ function getFolderPath(filePath) {
   const parts = filePath.split("/");
   return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
 }
+function filesFolderOfNote(record) {
+  if (record.fileType === "folder-note" && isFolderNotePath(record.obsidianPath)) {
+    return getFolderPath(record.obsidianPath);
+  }
+  return record.fileType === "file" ? stripMarkdownExtension(record.obsidianPath) : null;
+}
 var LOGGED_NAMES = 5;
 var FileHandler = class {
   constructor(vaultFs, notionClient, stateDb, concurrency = DEFAULT_CONFIG.advanced.fileConcurrency, options) {
@@ -15304,21 +15398,55 @@ var FileHandler = class {
       this.sema.release();
     }
   }
-  /** 올린 뒤 바뀌지 않았나 — 크기가 같으면 읽지 않는다. */
+  /**
+   * 올리거나 받은 뒤 바뀌지 않았나 — 그때의 표(크기 · 수정 시각, {@link fileStampOf})와 같으면 읽지 않는다. 크기가 다르면 바뀌었다.
+   * 크기만 같으면 내용으로 견주고, 같으면 지금 표를 적어 다음에는 읽지 않는다. 예전에는 크기가 같으면 바뀌지 않았다고 봐, 같은
+   * 크기로 고친 파일을 올리지 않았다.
+   */
   async isUnchanged(existing, file) {
-    if (existing.fileSize === file.size) return true;
+    const stamp = fileStampOf(file);
+    if (folderFileStampsOf(this.stateDb, existing.notionPageId).get(file.path) === stamp) {
+      return true;
+    }
+    if (existing.fileSize !== file.size) return false;
     const buffer = await this.vaultFs.readBinary(file.path);
-    return existing.fileHash === createHash("sha256").update(buffer).digest("hex");
+    const same = existing.fileHash === createHash("sha256").update(buffer).digest("hex");
+    if (same) rememberFolderFileStamp(this.stateDb, existing.notionPageId, file.path, stamp);
+    return same;
   }
   /** pull 이 받은 것을 두는 폴더 안인가. */
   inAttachmentsFolder(path) {
     return this.attachmentsFolder !== "" && path.startsWith(`${this.attachmentsFolder}/`);
   }
-  /** 폴더 첨부를 둘 Notion 페이지 — 폴더 노트 없는 폴더의 페이지(폴더 레코드)만. 맨 위는 루트 기록이 있을 때만. */
+  /**
+   * 폴더 첨부를 둘 Notion 페이지 — 그 폴더의 Notion 자리({@link folderContainer} 와 같은 차례). 폴더 노트(`X/X.md`)나 노트
+   * 이름의 폴더(`X.md` 옆 `X/`)면 그 노트의 페이지 끝(ADR-056), 아니면 push 가 만든 폴더 페이지. 맨 위는 루트 기록이 있을 때만.
+   * 행 · DB 폴더는 둘 곳이 없다 — 행의 본문은 행의 것이다.
+   */
   folderPageOf(folder) {
-    const record = this.stateDb.getByPath(folder || "__root__");
-    if (!record?.notionPageId) return null;
-    return folder === "" || isFolderRecord(record) ? record.notionPageId : null;
+    if (folder === "") return this.stateDb.getByPath("__root__")?.notionPageId ?? null;
+    return this.notePageOf(folder) ?? this.folderRecordPageOf(folder);
+  }
+  /** 이 폴더를 품은 노트의 페이지 — 폴더 노트 · 노트 이름의 폴더. 없거나 행이면 null. */
+  notePageOf(folder) {
+    const note = this.stateDb.getByPath(folderNoteOf(folder));
+    if (note?.notionPageId && note.fileType === "folder-note") return note.notionPageId;
+    const named = this.stateDb.getByPath(`${folder}.md`);
+    return named?.notionPageId && named.fileType === "file" ? named.notionPageId : null;
+  }
+  folderRecordPageOf(folder) {
+    const record = this.stateDb.getByPath(folder);
+    return record?.notionPageId && isFolderRecord(record) ? record.notionPageId : null;
+  }
+  /**
+   * 이 기록이 그 폴더의 폴더 첨부인가. 노트의 페이지에는 그 노트가 임베드해 올린 파일도 같은 페이지로 적혀 있다 — 폴더
+   * 첨부로 적어 둔 것({@link folderFileIdsOf})만이다.
+   */
+  isFolderFileEntry(entry, folder) {
+    const pageId = this.folderPageOf(folder);
+    if (!pageId || entry.notionPageId !== pageId) return false;
+    if (pageId !== this.notePageOf(folder)) return true;
+    return folderFileIdsOf(this.stateDb, pageId).has(entry.localPath);
   }
   /**
    * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 아예 빼고, Notion 이 받지 않는
@@ -15346,7 +15474,7 @@ var FileHandler = class {
    * @param failed 올리지 못한 첨부를 담을 곳 — push 결과의 `failed` 를 넘기면 CLI · 플러그인이 처리하지 못한 것으로
    *   보인다. 예전엔 경고 로그로만 남아 push 가 「실패 0」 으로 끝났다.
    */
-  async pushAllFiles(failed, folders) {
+  async pushAllFiles(failed, folders, noteWrites) {
     const { uploadable: allFiles, unsupported: unsupported2 } = await this.listUploadableFiles();
     if (unsupported2.length > 0) {
       const names = unsupported2.slice(0, LOGGED_NAMES).map((f) => f.path);
@@ -15355,13 +15483,13 @@ var FileHandler = class {
         `[Im-Nobsidian] Notion \uC774 \uBC1B\uC9C0 \uC54A\uB294 \uD615\uC2DD\uC774\uB77C \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uCCA8\uBD80 ${unsupported2.length}\uAC1C: ${names.join(", ")}${rest > 0 ? ` \uC678 ${rest}\uAC1C` : ""}`
       );
     }
-    if (this.deleteSync) await this.removeDeletedFolderFiles();
+    if (this.deleteSync) await this.removeDeletedFolderFiles(noteWrites);
     const pending = [];
     for (const file of allFiles) {
       if (this.inAttachmentsFolder(file.path) || isHiddenPath(file.path)) continue;
       const existing = this.stateDb.getFileRegistry(file.path);
       if (existing) {
-        if (existing.notionPageId !== this.folderPageOf(getFolderPath(file.path))) continue;
+        if (!this.isFolderFileEntry(existing, getFolderPath(file.path))) continue;
         if (await this.isUnchanged(existing, file)) continue;
       }
       pending.push({ file, existing });
@@ -15383,10 +15511,23 @@ var FileHandler = class {
     for (const [folder, items] of byFolder) {
       const pageId = await this.provideFolderPage(folder, folders, items, stranded);
       if (!pageId) continue;
-      for (const { file, existing } of items) {
-        const result = await this.pushSingleFile(file, pageId, existing, failed);
-        if (result) results.push(result);
-      }
+      await this.writingNotePage(
+        pageId === this.notePageOf(folder),
+        pageId,
+        noteWrites,
+        async () => {
+          for (const { file, existing } of items) {
+            let previous = existing;
+            if (!previous) {
+              const moved = await this.movedHere(file, pageId);
+              if (moved?.same) continue;
+              previous = moved?.entry ?? null;
+            }
+            const result = await this.pushSingleFile(file, pageId, previous, failed);
+            if (result) results.push(result);
+          }
+        }
+      );
     }
     this.reportStranded(stranded);
     return results;
@@ -15395,25 +15536,37 @@ var FileHandler = class {
    * 볼트에서 지운 폴더 첨부를 Notion 에서도 지운다(deleteSync) — 폴더 페이지에 적힌 파일 가운데 볼트에 없는 것의 블록과 기록.
    * 포함 · 제외 패턴으로 빠진 파일은 볼트에 있어 지우지 않는다.
    */
-  async removeDeletedFolderFiles() {
+  async removeDeletedFolderFiles(noteWrites) {
     const removed = [];
     for (const record of this.stateDb.getAll()) {
-      if (!record.notionPageId || !isFolderRecord(record)) continue;
+      if (!record.notionPageId) continue;
+      const folder = isFolderRecord(record) ? record.obsidianPath : filesFolderOfNote(record);
+      if (folder === null) continue;
+      const ids = folderFileIdsOf(this.stateDb, record.notionPageId);
+      if (!isFolderRecord(record) && ids.size === 0) continue;
+      const gone = [];
       for (const entry of this.stateDb.getFilesByPageId(record.notionPageId)) {
-        if (getFolderPath(entry.localPath) !== record.obsidianPath) continue;
-        if (await this.vaultFs.exists(entry.localPath)) continue;
-        try {
-          const name = entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1);
-          await this.removeOlderBlocks(record.notionPageId, name, void 0);
-          this.stateDb.deleteFileRegistry(entry.localPath);
-          forgetFolderFileId(this.stateDb, record.notionPageId, entry.localPath);
-          removed.push(entry.localPath);
-        } catch (error) {
-          getLogger().warn(
-            `[Im-Nobsidian] \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C Notion \uC5D0\uC11C \uC9C0\uC6B0\uC9C0 \uBABB\uD568 (${entry.localPath}): ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+        if (getFolderPath(entry.localPath) !== folder) continue;
+        if (!isFolderRecord(record) && !ids.has(entry.localPath)) continue;
+        if (!await this.vaultFs.exists(entry.localPath)) gone.push(entry);
       }
+      if (gone.length === 0) continue;
+      const pageId = record.notionPageId;
+      await this.writingNotePage(!isFolderRecord(record), pageId, noteWrites, async () => {
+        for (const entry of gone) {
+          try {
+            const name = entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1);
+            await this.removeOlderBlocks(pageId, entry.localPath, name, void 0);
+            this.stateDb.deleteFileRegistry(entry.localPath);
+            forgetFolderFileId(this.stateDb, pageId, entry.localPath);
+            removed.push(entry.localPath);
+          } catch (error) {
+            getLogger().warn(
+              `[Im-Nobsidian] \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C Notion \uC5D0\uC11C \uC9C0\uC6B0\uC9C0 \uBABB\uD568 (${entry.localPath}): ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      });
     }
     if (removed.length > 0) {
       getLogger().info(
@@ -15421,10 +15574,20 @@ var FileHandler = class {
       );
     }
   }
+  /** 노트의 페이지에 쓰는 동안을 알린다({@link NotePageWrites}) — 폴더 페이지는 노트가 없어 알릴 것이 없다. */
+  async writingNotePage(isNotePage, pageId, noteWrites, write) {
+    if (!isNotePage || !noteWrites) return write();
+    await noteWrites.begin(pageId);
+    try {
+      await write();
+    } finally {
+      await noteWrites.end(pageId);
+    }
+  }
   /** 폴더 첨부를 둘 페이지 — 노트 없는 폴더면 마련한다. 둘 곳이 없으면 그 파일들을 `stranded` 에 담고 null. */
   async provideFolderPage(folder, folders, items, stranded) {
     let pageId = this.folderPageOf(folder);
-    let reason = folder === "" ? "\uBCFC\uD2B8 \uB9E8 \uC704" : "\uD3F4\uB354 \uB178\uD2B8\uAC00 \uC788\uB294 \uD3F4\uB354 \xB7 DB \uD3F4\uB354";
+    let reason = folder === "" ? "\uBCFC\uD2B8 \uB9E8 \uC704" : "DB \uD3F4\uB354 \xB7 \uC544\uC9C1 \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uD3F4\uB354 \uB178\uD2B8";
     if (!pageId && folder !== "" && folders && !this.stateDb.getByPath(folder)) {
       try {
         await folders.ensureFolderPage(folder);
@@ -15573,6 +15736,8 @@ var FileHandler = class {
       fileHash: hash,
       fileSize: buffer.length
     });
+    const stat2 = await this.vaultFs.getFileStat(localPath);
+    if (stat2) rememberFolderFileStamp(this.stateDb, pageId, localPath, fileStampOf(stat2));
     return wrote;
   }
   async downloadFileBlock(url, filename, targetFolder) {
@@ -15614,7 +15779,9 @@ var FileHandler = class {
     const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
     const block = this.createFileBlock(blockType, fileUploadId, filename);
     const [created] = await this.notionClient.appendChildBlocks(parentPageId, [block]);
-    if (previous) await this.removeOlderBlocks(parentPageId, filename, created?.id);
+    if (previous) {
+      await this.removeOlderBlocks(parentPageId, file.path, filename, created?.id);
+    }
     const url = created ? fileUrlOfBlock(created) : null;
     const fileId = url ? notionFileIdOf(url) : null;
     if (fileId) rememberFolderFileId(this.stateDb, parentPageId, file.path, fileId);
@@ -15626,28 +15793,78 @@ var FileHandler = class {
       fileHash: hash,
       fileSize: file.size
     });
+    rememberFolderFileStamp(this.stateDb, parentPageId, file.path, fileStampOf(file));
     getLogger().info(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC: ${file.path} \u2192 ${blockType} \uBE14\uB85D`);
     return { localPath: file.path, fileUploadId, blockType };
   }
-  /** 이 페이지에서 같은 이름의 파일 블록 중 방금 붙인 것 말고를 지운다. */
-  async removeOlderBlocks(pageId, name, keep) {
+  /**
+   * 처음 보는 파일이 이 페이지에 적어 둔 같은 이름의 폴더 첨부를 옮긴 것인가 — 그 기록의 경로가 볼트에서 사라졌으면 옮겼다(폴더 ·
+   * 폴더 노트 · 노트의 이름 바꾸기). 기록 · 파일 id · 표를 새 경로로 옮긴다. `same` 이면 내용이 같아 올리지 않는다. 다르면 옮긴
+   * 기록을 옛 것으로 올려 옛 블록을 지운다. 예전에는 새 파일로 올려 노트 페이지에 같은 파일의 블록이 둘 남았다.
+   */
+  async movedHere(file, pageId) {
+    const name = file.path.slice(file.path.lastIndexOf("/") + 1);
+    const record = this.stateDb.getByNotionId(pageId);
+    const ids = folderFileIdsOf(this.stateDb, pageId);
+    for (const entry of this.stateDb.getFilesByPageId(pageId)) {
+      if (entry.localPath === file.path) continue;
+      if (entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1) !== name) continue;
+      if (record && !isFolderRecord(record) && !ids.has(entry.localPath)) continue;
+      if (await this.vaultFs.exists(entry.localPath)) continue;
+      const buffer = await this.vaultFs.readBinary(file.path);
+      const same = entry.fileSize === file.size && entry.fileHash === createHash("sha256").update(buffer).digest("hex");
+      const fileId = ids.get(entry.localPath);
+      this.stateDb.deleteFileRegistry(entry.localPath);
+      forgetFolderFileId(this.stateDb, pageId, entry.localPath);
+      this.stateDb.registerFile({
+        localPath: file.path,
+        notionPageId: pageId,
+        fileUploadId: entry.fileUploadId,
+        fileType: entry.fileType,
+        fileHash: entry.fileHash,
+        fileSize: entry.fileSize
+      });
+      if (fileId) rememberFolderFileId(this.stateDb, pageId, file.path, fileId);
+      if (same) rememberFolderFileStamp(this.stateDb, pageId, file.path, fileStampOf(file));
+      return { entry: { ...entry, localPath: file.path }, same };
+    }
+    return null;
+  }
+  /**
+   * 이 페이지에서 그 폴더 첨부의 블록 중 방금 붙인 것(`keep`) 말고를 지운다. 폴더 페이지는 같은 이름의 파일 블록 모두(id 를
+   * 적기 전에 올린 블록도). 노트의 페이지는 노트가 임베드한 같은 이름의 파일이 있을 수 있어, 적어 둔 Notion 파일 id 의 블록과
+   * 표시를 단 캡션({@link folderFileCaption})의 블록만 — 다른 볼트가 같은 파일을 먼저 고쳐 올린 블록은 id 를 모르지만 표시가 있다.
+   * 예전에는 id 로만 지워, 두 볼트가 따로 고쳐 올리면 블록이 둘 남았다.
+   */
+  async removeOlderBlocks(pageId, localPath, name, keep) {
+    const record = this.stateDb.getByNotionId(pageId);
+    const onNote = record !== null && !isFolderRecord(record);
+    const fileId = folderFileIdsOf(this.stateDb, pageId).get(localPath);
     for (const block of await this.notionClient.fetchAllChildren(pageId)) {
       if (block.id === keep) continue;
       const media = block[block.type];
       const url = media?.type === "file" ? media.file?.url : void 0;
       if (!url || uploadedFileNameFromUrl(url) !== name) continue;
+      if (keep === void 0 && fileId !== void 0) {
+        if (notionFileIdOf(url) !== fileId) continue;
+      } else if (onNote) {
+        const caption = (media?.caption ?? []).map((part) => part.plain_text ?? "").join("");
+        const ours = fileId !== void 0 && notionFileIdOf(url) === fileId || caption === folderFileCaption(name);
+        if (!ours) continue;
+      }
       await this.notionClient.deleteBlock(block.id);
     }
   }
   /**
-   * 폴더 첨부의 파일 블록 — 캡션에 파일 이름을 적는다. 받는 쪽이 그 표시로 폴더 첨부를 알아본다({@link folderFilesOf}) —
-   * 자식 페이지가 없는 폴더 페이지는 PDF 하나만 붙인 노트와 모양이 같다.
+   * 폴더 첨부의 파일 블록 — 캡션에 표시를 단 파일 이름을 적는다({@link folderFileCaption}). 받는 쪽이 그 표시로 폴더 첨부를
+   * 알아본다 — 자식 페이지가 없는 폴더 페이지는 PDF 하나만 붙인 노트와 모양이 같고, 노트 페이지의 폴더 첨부는 그 노트의
+   * 임베드와 같은 블록이다.
    */
   createFileBlock(blockType, fileUploadId, name) {
     const fileRef = {
       type: "file_upload",
       file_upload: { id: fileUploadId },
-      caption: [{ type: "text", text: { content: name } }]
+      caption: [{ type: "text", text: { content: folderFileCaption(name) } }]
     };
     switch (blockType) {
       case "image":
@@ -15760,8 +15977,59 @@ async function findUntrackedNote(stateDb, vaultFs, dir, safeName, pageId, taken)
   }
   return null;
 }
-function relinksWithoutContent(note, unlinkedVault) {
-  return note.existing === "own" || unlinkedVault;
+function relinkOutcome(existing, same, unlinkedVault, strategy) {
+  if (same) return "relink";
+  if (existing === "name" && !unlinkedVault) return null;
+  const chosen = existing === "own" ? strategy : "manual";
+  if (chosen === "local-first") return "relink";
+  if (chosen === "remote-first") return "overwrite";
+  return "conflict";
+}
+function relinkConflict(input) {
+  return {
+    syncRecord: input.record,
+    localChange: {
+      path: input.path,
+      type: "modified",
+      currentHash: computeHash(input.local),
+      previousHash: input.record.contentHash
+    },
+    remoteChange: {
+      pageId: input.pageId,
+      type: "modified",
+      lastEdited: input.lastEdited,
+      previousEdited: null,
+      path: input.path,
+      title: input.title
+    },
+    baseContent: null,
+    localContent: input.local,
+    remoteContent: input.remote
+  };
+}
+function plannedRelinkRecord(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: `planned:${input.pageId}`,
+    obsidianPath: input.path,
+    notionPageId: input.pageId,
+    notionParentId: input.parentId,
+    contentHash: computeHash(input.remote),
+    notionLastEdited: input.lastEdited,
+    notionLastEditedBy: null,
+    notionSeenAt: null,
+    notionBodyFingerprint: null,
+    localLastModified: now,
+    syncDirection: "both",
+    fileType: input.fileType,
+    status: "conflict",
+    baseSnapshot: null,
+    localMtime: null,
+    localFileSize: null,
+    version: 0,
+    createdAt: now,
+    updatedAt: now
+  };
 }
 
 // src/conflict/merger.ts
@@ -15949,20 +16217,27 @@ var PENDING_LINK_RE = new RegExp(
   "g"
 );
 function sameAsPendingLinks(local, remote) {
-  if (!PENDING_LINK_RE.test(remote)) return false;
-  PENDING_LINK_RE.lastIndex = 0;
+  const pending = new RegExp(`${NOTION_BLOCK_LINK_RE.source}|${PENDING_LINK_RE.source}`, "g");
+  if (!pending.test(remote)) return false;
+  pending.lastIndex = 0;
   const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   let pattern = "";
   let last = 0;
-  for (const match of remote.matchAll(PENDING_LINK_RE)) {
+  for (const match of remote.matchAll(pending)) {
     pattern += escape(remote.slice(last, match.index));
-    const alias = match[3];
-    pattern += match[4] ? `"?\\[\\[[^\\]\\n]+\\]\\]"?` : alias ? `(?:\\[\\[(?:[^\\]\\n|]*/)?${escape(alias)}(?:\\\\?\\|[^\\]\\n]*)?\\]\\]|\\[\\[[^\\]\\n|]+\\\\?\\|${escape(alias)}\\]\\]|\\[${escape(alias)}\\]\\([^)\\n]+\\))` : `(?:\\[\\[[^\\]\\n]+\\]\\]|\\[[^\\]\\n]+\\]\\([^)\\n]+\\))`;
+    const blockLabel = match[1];
+    const alias = match[6];
+    pattern += blockLabel ? pendingBlockLinkPattern(blockLabel, escape) : match[7] ? `"?\\[\\[[^\\]\\n]+\\]\\]"?` : alias ? `(?:\\[\\[(?:[^\\]\\n|]*/)?${escape(alias)}(?:\\\\?\\|[^\\]\\n]*)?\\]\\]|\\[\\[[^\\]\\n|]+\\\\?\\|${escape(alias)}\\]\\]|\\[${escape(alias)}\\]\\([^)\\n]+\\))` : `(?:\\[\\[[^\\]\\n]+\\]\\]|\\[[^\\]\\n]+\\]\\([^)\\n]+\\))`;
     last = match.index + match[0].length;
   }
   pattern += escape(remote.slice(last).replace(/\n+$/, ""));
   return new RegExp(`^${pattern}\\n*$`).test(local.replace(/\n+$/, ""));
 }
+function pendingBlockLinkPattern(label, escape) {
+  const text = label.replace(/\\([>^])/g, "$1");
+  const written = escape(text.split(" > ").join("#"));
+  return `(?:\\[\\[[^\\]\\n|]*#[^\\]\\n|]*\\\\?\\|${escape(text)}\\]\\]|\\[\\[(?:[^\\]\\n|#]*/)?${written}\\]\\]|\\[\\[#${written}\\]\\]|\\[(?:${escape(text)}|${escape(label)})\\]\\([^)\\n]+\\))`;
+}
 function resolveNotionIdWikilinks(markdown, lookup) {
   let resolved = 0;
   const out = markdown.replace(
@@ -19088,7 +19363,9 @@ var NoteRelocator = class {
     if (isFolderRecord(record)) return [record.obsidianPath];
     if (record.fileType === "folder-note") return [parentFolderOf(record.obsidianPath)];
     const children = stripMarkdownExtension(record.obsidianPath);
-    const hasChildren = this.stateDb.getAll().some((r) => within(r.obsidianPath, children));
+    const hasChildren = this.stateDb.getAll().some((r) => within(r.obsidianPath, children)) || record.notionPageId !== null && [...folderFileIdsOf(this.stateDb, record.notionPageId).keys()].some(
+      (path) => within(path, children)
+    );
     return hasChildren ? [record.obsidianPath, children] : [record.obsidianPath];
   }
   /** 옮기지 못할 까닭 — 없으면 null. */
@@ -19321,7 +19598,7 @@ async function notionBodyToObsidian(client, markdown, pageId) {
   const bookmarks = bookmarkIds.length > 0 ? await client.getBookmarks(bookmarkIds) : void 0;
   return notionEnhancedToObsidian(markdown, { userNames, codeTexts, bookmarks });
 }
-async function pageBlocksToObsidian(client, pageId) {
+async function pageBlocksToObsidian(client, pageId, bodyOf5 = (markdown) => markdown) {
   const tree = await client.getBlockTree(pageId);
   const markdown = blocksToNfm(tree, { pageId });
   const content = await notionBodyToObsidian(
@@ -19330,7 +19607,7 @@ async function pageBlocksToObsidian(client, pageId) {
       getCodeBlockTexts: () => Promise.resolve(blocksOfType(tree, "code").map(plainTextOf)),
       getBookmarks: () => Promise.resolve(bookmarksOf(tree))
     },
-    markdown,
+    bodyOf5(markdown),
     pageId
   );
   return { markdown, content };
@@ -19989,13 +20266,15 @@ var DatabaseSyncer = class {
           page.id,
           (key) => relinkTaken.has(key) || claimed.has(key)
         );
-        if (untracked && relinksWithoutContent(untracked, this.unlinkedVault)) {
+        const relink = untracked && await this.plannedRowRelink(page, dbConfig, untracked);
+        if (untracked && relink) {
           relinkTaken.add(pathKey(untracked.path));
           planned.push({
             pageId: page.id,
             path: untracked.path,
             operation: "create",
-            relink: true
+            relink: true,
+            ...relink.conflict ? { relinkConflict: relink.conflict } : {}
           });
           continue;
         }
@@ -20826,16 +21105,20 @@ var DatabaseSyncer = class {
     return found2;
   }
   /**
-   * 상태 기록에 없던 행 노트를 이 행과 다시 잇는다(P7) — 페이지의 `relinkExistingNote` 와 같은 규칙. 글이 같으면 잇고, 다르면
-   * 이 행 id 를 단 이름은 충돌 전략을 따르고 · 자연 이름은 이은 노트가 없는 볼트에서만 충돌로 잇는다. 잇지 않으면 null.
-   * remote-first 는 `"write"` — 호출측이 받은 행으로 덮는다.
+   * 상태 기록에 없던 행 노트를 이 행과 다시 잇는다(P7) — 받은 글과 견줘 {@link relinkOutcome} 대로. 잇지 않으면 null.
+   * 원격으로 덮을 것은 `"write"` — 호출측이 받은 행으로 덮는다.
    */
   async relinkExistingRow(filePath, existing, local, finalContent, page, dbConfig, rendered, bodyFingerprint) {
     const same = sameNoteContent(local, finalContent) || sameAsPendingLinks(local, finalContent);
-    if (!same && existing === "name" && !this.unlinkedVault) return null;
-    const strategy = existing === "own" ? this.config.sync.conflictStrategy : "manual";
-    if (!same && strategy === "remote-first") return "write";
-    const conflicted = !same && strategy !== "local-first";
+    const outcome = relinkOutcome(
+      existing,
+      same,
+      this.unlinkedVault,
+      this.config.sync.conflictStrategy
+    );
+    if (outcome === null) return null;
+    if (outcome === "overwrite") return "write";
+    const conflicted = outcome === "conflict";
     const stat2 = same ? await this.vaultFs.getFileStat(filePath) : null;
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
@@ -20862,31 +21145,57 @@ var DatabaseSyncer = class {
       });
     });
     if (!conflicted) return { action: "unchanged", path: filePath, relinked: true };
-    const record = this.stateDb.getByPath(filePath);
     return {
       action: "conflict",
       path: filePath,
       relinked: true,
-      conflict: {
-        syncRecord: record,
-        localChange: {
-          path: filePath,
-          type: "modified",
-          currentHash: computeHash(local),
-          previousHash: record.contentHash
-        },
-        remoteChange: {
+      conflict: relinkConflict({
+        record: this.stateDb.getByPath(filePath),
+        path: filePath,
+        local,
+        remote: finalContent,
+        pageId: page.id,
+        lastEdited: page.last_edited_time,
+        title: rendered.title
+      })
+    };
+  }
+  /**
+   * dry-run — 실제 pull 이 상태 기록에 없던 이 행 노트를 다시 잇나(P7). 받은 행을 실제 pull 처럼 렌더하되 볼트 · 상태 DB 는
+   * 바꾸지 않고({@link ImageHandler.preview}) 견준다. 잇지 않으면 null(새 이름으로 받는다), 충돌로 남길 것이면 그 충돌.
+   */
+  async plannedRowRelink(page, dbConfig, untracked) {
+    const local = await readLocalNote(this.vaultFs, untracked.path);
+    if (local === void 0) return null;
+    const rendered = await this.imageHandler.preview(
+      () => this.renderRow(page, untracked.path, { localPath: untracked.path, adoptFrom: local })
+    );
+    const same = sameNoteContent(local, rendered.content) || sameAsPendingLinks(local, rendered.content);
+    const outcome = relinkOutcome(
+      untracked.existing,
+      same,
+      this.unlinkedVault,
+      this.config.sync.conflictStrategy
+    );
+    if (outcome === null) return null;
+    if (outcome !== "conflict") return {};
+    return {
+      conflict: relinkConflict({
+        record: plannedRelinkRecord({
+          path: untracked.path,
           pageId: page.id,
-          type: "modified",
+          parentId: dbConfig.databaseId,
+          remote: rendered.content,
           lastEdited: page.last_edited_time,
-          previousEdited: null,
-          path: filePath,
-          title: rendered.title
-        },
-        baseContent: null,
-        localContent: local,
-        remoteContent: finalContent
-      }
+          fileType: "db-row"
+        }),
+        path: untracked.path,
+        local,
+        remote: rendered.content,
+        pageId: page.id,
+        lastEdited: page.last_edited_time,
+        title: rendered.title
+      })
     };
   }
   /** 이번 받기에서 로컬 편집을 합친 행의 경로를 가져가고 비운다. */
@@ -23381,6 +23690,7 @@ function dropEmbeddedBaseMarkers(content, basePaths) {
 
 // src/sync/database-discovery.ts
 var DISCOVERY_RETRY_META_KEY = "discovery_retry";
+var PREVIEW_BODY_READ_BUDGET = 100;
 function parseDiscoveryRetry(raw) {
   if (!raw) return { parents: [], dbs: [] };
   try {
@@ -23446,144 +23756,25 @@ var DatabaseDiscovery = class {
     let deleted = 0;
     let restored = 0;
     try {
-      const dbConfigs = parseDiscoveredDbs(this.stateDb.getMeta(DISCOVERED_DBS_META_KEY));
-      const configuredIds = new Set(
-        (this.config.notion.databases ?? []).map((d) => d.databaseId.replace(/-/g, ""))
-      );
-      const knownIds = /* @__PURE__ */ new Set([
-        ...configuredIds,
-        ...dbConfigs.map((c) => c.databaseId.replace(/-/g, ""))
-      ]);
-      let changed = false;
-      const registeredNow = /* @__PURE__ */ new Set();
-      const folderOwner = new Map(
-        (this.config.notion.databases ?? []).map((d) => [d.localFolder, d.databaseId])
-      );
-      const repairedCount = repairDbFolderCollisions(dbConfigs, folderOwner);
-      for (const c of dbConfigs) folderOwner.set(c.localFolder, c.databaseId);
-      if (repairedCount > 0) {
-        changed = true;
-        getLogger().info(`[Im-Nobsidian] \uB3D9\uBA85 DB \uD3F4\uB354 \uCDA9\uB3CC ${repairedCount}\uAC74 \uBD84\uB9AC(F24)`);
-      }
-      const folderKeys = new Map([...folderOwner].map(([folder, id]) => [pathKey(folder), id]));
-      const claimFolder = (config) => {
-        config.localFolder = resolveDbFolderPath(
-          config.localFolder,
-          config.databaseId,
-          (f) => folderOwner.get(f) ?? folderKeys.get(pathKey(f)) ?? null
-        );
-        folderOwner.set(config.localFolder, config.databaseId);
-        folderKeys.set(pathKey(config.localFolder), config.databaseId);
-      };
-      const inaccessibleIds = loadInaccessibleDbIds(this.stateDb);
-      let inaccessibleChanged = false;
-      const degrade = (rawId) => {
-        const nohyph = rawId.replace(/-/g, "");
-        if (!inaccessibleIds.has(nohyph)) {
-          inaccessibleIds.add(nohyph);
-          inaccessibleChanged = true;
-        }
-        getLogger().warn(
-          `[Im-Nobsidian] DB ${rawId}: \uC811\uADFC \uAC00\uB2A5\uD55C data source \uC5C6\uC74C(\uB9C1\uD06C\uB4DC/\uBBF8\uACF5\uC720/\uC0AD\uC81C \uCD94\uC815) \u2014 \uB3D9\uAE30\uD654 \uB300\uC0C1\uC5D0\uC11C \uC81C\uC678(\uC81C\uBAA9\uC740 \uBD80\uBAA8 \uD398\uC774\uC9C0\uC5D0 \uBCF4\uC874)`
-        );
-      };
-      if (forceRediscovery && inaccessibleIds.size > 0) {
-        getLogger().info(
-          `[Im-Nobsidian] --force: \uC811\uADFC \uBD88\uAC00 DB ${inaccessibleIds.size}\uAC1C denylist \uC7AC\uAC80\uC99D`
-        );
-        inaccessibleIds.clear();
-        inaccessibleChanged = true;
-      }
-      const linkedMap = loadLinkedDbMap(this.stateDb);
-      let linkedChanged = false;
-      const linkedNow = /* @__PURE__ */ new Set();
-      const retry = parseDiscoveryRetry(this.stateDb.getMeta(DISCOVERY_RETRY_META_KEY));
-      const nextRetry = { parents: [], dbs: [] };
-      const pathOf = (pageId) => notionIdsEqual(pageId, this.config.notion.rootPageId) ? "" : this.stateDb.getByNotionId(pageId)?.obsidianPath ?? pageId;
-      const unreadParent = (pageId, error) => {
-        nextRetry.parents.push(pageId);
-        failed.push({
-          path: pathOf(pageId),
-          operation: "update",
-          error: `\uD558\uC704 DB \uB97C \uD655\uC778\uD558\uC9C0 \uBABB\uD568 \u2014 \uB2E4\uC74C pull \uC774 \uB2E4\uC2DC \uD655\uC778\uD55C\uB2E4: ${error}`
-        });
-      };
-      const retryLater = (dbId, parentPageId, error) => {
-        nextRetry.dbs.push({ dbId, parentPageId });
-        failed.push({
-          path: pathOf(parentPageId),
-          operation: "create",
-          error: `DB ${shortNotionId(dbId)} \uB97C \uC77D\uC9C0 \uBABB\uD568 \u2014 \uB2E4\uC74C pull \uC774 \uB2E4\uC2DC \uBCF8\uB2E4: ${error}`
-        });
-      };
-      const register = async (dbId, parentPageId) => {
-        const nohyph = dbId.replace(/-/g, "");
-        if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) return;
-        const registerOriginal = async (origNohyph) => {
-          if (knownIds.has(origNohyph) || inaccessibleIds.has(origNohyph)) return;
-          const origId = normalizeNotionId(origNohyph);
-          const outcome2 = await this.buildDiscoveredDbConfig(origId, parentPageId);
-          knownIds.add(origNohyph);
-          if (outcome2.kind === "ok") {
-            claimFolder(outcome2.config);
-            dbConfigs.push(outcome2.config);
-            registeredNow.add(origNohyph);
-            changed = true;
-          } else if (outcome2.kind === "error") {
-            retryLater(origId, parentPageId, outcome2.error);
-          } else {
-            degrade(origId);
-          }
-        };
-        const knownOriginal = linkedMap.get(nohyph);
-        if (knownOriginal) {
-          await registerOriginal(knownOriginal);
-          return;
-        }
-        const outcome = await this.buildDiscoveredDbConfig(dbId, parentPageId);
-        knownIds.add(nohyph);
-        if (outcome.kind === "ok") {
-          claimFolder(outcome.config);
-          dbConfigs.push(outcome.config);
-          registeredNow.add(nohyph);
-          changed = true;
-        } else if (outcome.kind === "linked") {
-          const origNohyph = outcome.originalDbId.replace(/-/g, "");
-          linkedMap.set(nohyph, origNohyph);
-          linkedNow.add(nohyph);
-          linkedChanged = true;
-          await registerOriginal(origNohyph);
-        } else if (outcome.kind === "inaccessible") {
-          degrade(dbId);
-        } else if (outcome.kind === "error") {
-          retryLater(dbId, parentPageId, outcome.error);
-        }
-      };
-      const scanAll = forceRediscovery || discoveryScanPending(this.stateDb);
-      if (signal?.aborted) {
-        nextRetry.parents.push(...retry.parents);
-        nextRetry.dbs.push(...retry.dbs);
-      } else {
-        const root = this.config.notion.rootPageId;
-        const scanIds = scanAll ? [
-          root,
-          ...this.stateDb.getAll().filter((r) => r.notionPageId).map((r) => r.notionPageId)
-        ].filter((id) => !this._bodyReadPages.has(normalizeNotionId(id))) : options.rescanRoot && !retry.parents.some((id) => notionIdsEqual(id, root)) ? [root, ...retry.parents] : retry.parents;
-        if (scanIds.length > 0) {
-          const { found: found2, unread } = await this.discoverChildDatabases(scanIds);
-          for (const { dbId, parentPageId } of found2) {
-            await register(dbId, parentPageId);
-          }
-          for (const { pageId, error } of unread) unreadParent(pageId, error);
-        }
-        for (const { dbId, parentPageId } of retry.dbs) {
-          await register(dbId, parentPageId);
-        }
-        if (scanAll) this.stateDb.setMeta(DISCOVERY_SCANNED_META_KEY, (/* @__PURE__ */ new Date()).toISOString());
-      }
-      for (const [nohyph, parentPageId] of this._inlineDbRefs) {
-        await register(normalizeNotionId(nohyph), parentPageId);
-      }
+      const registry = await this.openRegistry(failed, {
+        forceRediscovery,
+        ...options.rescanRoot !== void 0 ? { rescanRoot: options.rescanRoot } : {},
+        ...signal ? { signal } : {},
+        markScanned: true
+      });
+      const {
+        dbConfigs,
+        configuredIds,
+        registeredNow,
+        inaccessibleIds,
+        linkedMap,
+        linkedNow,
+        retry,
+        nextRetry,
+        dirty,
+        register,
+        degrade
+      } = registry;
       const stillSyncable = [];
       const pulledWhole = /* @__PURE__ */ new Set();
       let queue = [...dbConfigs];
@@ -23621,14 +23812,14 @@ var DatabaseDiscovery = class {
                     config.localFolder = move.to + config.localFolder.slice(move.from.length);
                   }
                 }
-                changed = true;
+                dirty.list = true;
               }
             });
             if (dbResult.linkedOriginalDbId) {
               linkedMap.set(nohyph, dbResult.linkedOriginalDbId.replace(/-/g, ""));
               linkedNow.add(nohyph);
-              linkedChanged = true;
-              changed = true;
+              dirty.linked = true;
+              dirty.list = true;
               ledger?.settle(dbConfig.databaseId);
               getLogger().info(
                 `[Im-Nobsidian] DB ${dbConfig.databaseId}: linked view \uCEE8\uD14C\uC774\uB108 \uAC10\uC9C0 \u2192 \uD589\uC740 \uC6D0\uBCF8 ${dbResult.linkedOriginalDbId} \uD3F4\uB354\uAC00 \uB2E8\uC77C \uC18C\uC720(F25)`
@@ -23683,18 +23874,18 @@ var DatabaseDiscovery = class {
         }
       }
       if (!signal?.aborted) {
-        linkedChanged = await this.pullLinkedViews(linkedMap, stillSyncable, {
+        dirty.linked = await this.pullLinkedViews(linkedMap, stillSyncable, {
           pulled: (container, original) => forceRediscovery || linkedNow.has(container) || pulledWhole.has(original)
-        }) || linkedChanged;
+        }) || dirty.linked;
       }
       ledger?.keepOnly([...configuredIds, ...stillSyncable.map((c) => c.databaseId)]);
-      if (changed || inaccessibleChanged || stillSyncable.length !== dbConfigs.length) {
+      if (dirty.list || dirty.inaccessible || stillSyncable.length !== dbConfigs.length) {
         this.stateDb.setMeta(DISCOVERED_DBS_META_KEY, JSON.stringify(stillSyncable));
       }
-      if (inaccessibleChanged) {
+      if (dirty.inaccessible) {
         this.stateDb.setMeta(INACCESSIBLE_DBS_META_KEY, JSON.stringify([...inaccessibleIds]));
       }
-      if (linkedChanged) {
+      if (dirty.linked) {
         this.stateDb.setMeta(LINKED_DBS_META_KEY, JSON.stringify(Object.fromEntries(linkedMap)));
       }
       if (retry.parents.length + retry.dbs.length + nextRetry.parents.length + nextRetry.dbs.length > 0) {
@@ -23711,6 +23902,217 @@ var DatabaseDiscovery = class {
     }
     return { created, updated, deleted, restored };
   }
+  /**
+   * 이번 pull 이 찾을 DB 를 등록부에 올린다 — 블록을 훑고({@link discoverChildDatabases}) 받은 본문의 `<database>` 를
+   * 더한다. 상태 DB 에는 쓰지 않는다 — 등록부를 적는 것은 실제 pull 의 마감이고 dry-run 은 버린다. 다 훑은 표시만
+   * `markScanned` 일 때 적는다.
+   *
+   * @param failed 읽지 못한 페이지 · DB — 이유와 함께 싣는다.
+   * @param options.notePathOf 페이지 → 볼트 경로. 새 DB 폴더를 부모 노트 옆에 둔다 — dry-run 은 다시 이을 노트의 자리를 준다.
+   */
+  async openRegistry(failed, options) {
+    const { forceRediscovery, signal } = options;
+    const { notePathOf } = options;
+    const dbConfigs = parseDiscoveredDbs(this.stateDb.getMeta(DISCOVERED_DBS_META_KEY));
+    const configuredIds = new Set(
+      (this.config.notion.databases ?? []).map((d) => d.databaseId.replace(/-/g, ""))
+    );
+    const knownIds = /* @__PURE__ */ new Set([
+      ...configuredIds,
+      ...dbConfigs.map((c) => c.databaseId.replace(/-/g, ""))
+    ]);
+    const dirty = { list: false, inaccessible: false, linked: false };
+    const registeredNow = /* @__PURE__ */ new Set();
+    const folderOwner = new Map(
+      (this.config.notion.databases ?? []).map((d) => [d.localFolder, d.databaseId])
+    );
+    const repairedCount = repairDbFolderCollisions(dbConfigs, folderOwner);
+    for (const c of dbConfigs) folderOwner.set(c.localFolder, c.databaseId);
+    if (repairedCount > 0) {
+      dirty.list = true;
+      getLogger().info(`[Im-Nobsidian] \uB3D9\uBA85 DB \uD3F4\uB354 \uCDA9\uB3CC ${repairedCount}\uAC74 \uBD84\uB9AC(F24)`);
+    }
+    const folderKeys = new Map([...folderOwner].map(([folder, id]) => [pathKey(folder), id]));
+    const claimFolder = (config) => {
+      config.localFolder = resolveDbFolderPath(
+        config.localFolder,
+        config.databaseId,
+        (f) => folderOwner.get(f) ?? folderKeys.get(pathKey(f)) ?? null
+      );
+      folderOwner.set(config.localFolder, config.databaseId);
+      folderKeys.set(pathKey(config.localFolder), config.databaseId);
+    };
+    const inaccessibleIds = loadInaccessibleDbIds(this.stateDb);
+    const degrade = (rawId) => {
+      const nohyph = rawId.replace(/-/g, "");
+      if (!inaccessibleIds.has(nohyph)) {
+        inaccessibleIds.add(nohyph);
+        dirty.inaccessible = true;
+      }
+      getLogger().warn(
+        `[Im-Nobsidian] DB ${rawId}: \uC811\uADFC \uAC00\uB2A5\uD55C data source \uC5C6\uC74C(\uB9C1\uD06C\uB4DC/\uBBF8\uACF5\uC720/\uC0AD\uC81C \uCD94\uC815) \u2014 \uB3D9\uAE30\uD654 \uB300\uC0C1\uC5D0\uC11C \uC81C\uC678(\uC81C\uBAA9\uC740 \uBD80\uBAA8 \uD398\uC774\uC9C0\uC5D0 \uBCF4\uC874)`
+      );
+    };
+    if (forceRediscovery && inaccessibleIds.size > 0) {
+      getLogger().info(
+        `[Im-Nobsidian] --force: \uC811\uADFC \uBD88\uAC00 DB ${inaccessibleIds.size}\uAC1C denylist \uC7AC\uAC80\uC99D`
+      );
+      inaccessibleIds.clear();
+      dirty.inaccessible = true;
+    }
+    const linkedMap = loadLinkedDbMap(this.stateDb);
+    const linkedNow = /* @__PURE__ */ new Set();
+    const retry = parseDiscoveryRetry(this.stateDb.getMeta(DISCOVERY_RETRY_META_KEY));
+    const nextRetry = { parents: [], dbs: [] };
+    const pathOf = (pageId) => notionIdsEqual(pageId, this.config.notion.rootPageId) ? "" : this.stateDb.getByNotionId(pageId)?.obsidianPath ?? pageId;
+    const unreadParent = (pageId, error) => {
+      nextRetry.parents.push(pageId);
+      failed.push({
+        path: pathOf(pageId),
+        operation: "update",
+        error: `\uD558\uC704 DB \uB97C \uD655\uC778\uD558\uC9C0 \uBABB\uD568 \u2014 \uB2E4\uC74C pull \uC774 \uB2E4\uC2DC \uD655\uC778\uD55C\uB2E4: ${error}`
+      });
+    };
+    const retryLater = (dbId, parentPageId, error) => {
+      nextRetry.dbs.push({ dbId, parentPageId });
+      failed.push({
+        path: pathOf(parentPageId),
+        operation: "create",
+        error: `DB ${shortNotionId(dbId)} \uB97C \uC77D\uC9C0 \uBABB\uD568 \u2014 \uB2E4\uC74C pull \uC774 \uB2E4\uC2DC \uBCF8\uB2E4: ${error}`
+      });
+    };
+    const register = async (dbId, parentPageId) => {
+      const nohyph = dbId.replace(/-/g, "");
+      if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) return;
+      const registerOriginal = async (origNohyph) => {
+        if (knownIds.has(origNohyph) || inaccessibleIds.has(origNohyph)) return;
+        const origId = normalizeNotionId(origNohyph);
+        const outcome2 = await this.buildDiscoveredDbConfig(origId, parentPageId, notePathOf);
+        knownIds.add(origNohyph);
+        if (outcome2.kind === "ok") {
+          claimFolder(outcome2.config);
+          dbConfigs.push(outcome2.config);
+          registeredNow.add(origNohyph);
+          dirty.list = true;
+        } else if (outcome2.kind === "error") {
+          retryLater(origId, parentPageId, outcome2.error);
+        } else {
+          degrade(origId);
+        }
+      };
+      const knownOriginal = linkedMap.get(nohyph);
+      if (knownOriginal) {
+        await registerOriginal(knownOriginal);
+        return;
+      }
+      const outcome = await this.buildDiscoveredDbConfig(dbId, parentPageId, notePathOf);
+      knownIds.add(nohyph);
+      if (outcome.kind === "ok") {
+        claimFolder(outcome.config);
+        dbConfigs.push(outcome.config);
+        registeredNow.add(nohyph);
+        dirty.list = true;
+      } else if (outcome.kind === "linked") {
+        const origNohyph = outcome.originalDbId.replace(/-/g, "");
+        linkedMap.set(nohyph, origNohyph);
+        linkedNow.add(nohyph);
+        dirty.linked = true;
+        await registerOriginal(origNohyph);
+      } else if (outcome.kind === "inaccessible") {
+        degrade(dbId);
+      } else if (outcome.kind === "error") {
+        retryLater(dbId, parentPageId, outcome.error);
+      }
+    };
+    const scanAll = forceRediscovery || discoveryScanPending(this.stateDb);
+    if (signal?.aborted) {
+      nextRetry.parents.push(...retry.parents);
+      nextRetry.dbs.push(...retry.dbs);
+    } else {
+      const root = this.config.notion.rootPageId;
+      const scanIds = scanAll ? [
+        root,
+        ...this.stateDb.getAll().filter((r) => r.notionPageId).map((r) => r.notionPageId)
+      ].filter((id) => !this._bodyReadPages.has(normalizeNotionId(id))) : options.rescanRoot && !retry.parents.some((id) => notionIdsEqual(id, root)) ? [root, ...retry.parents] : retry.parents;
+      if (scanIds.length > 0) {
+        const { found: found2, unread } = await this.discoverChildDatabases(scanIds);
+        for (const { dbId, parentPageId } of found2) {
+          await register(dbId, parentPageId);
+        }
+        for (const { pageId, error } of unread) unreadParent(pageId, error);
+      }
+      for (const { dbId, parentPageId } of retry.dbs) {
+        await register(dbId, parentPageId);
+      }
+      if (scanAll && options.markScanned) {
+        this.stateDb.setMeta(DISCOVERY_SCANNED_META_KEY, (/* @__PURE__ */ new Date()).toISOString());
+      }
+    }
+    for (const [nohyph, parentPageId] of this._inlineDbRefs) {
+      await register(normalizeNotionId(nohyph), parentPageId);
+    }
+    return {
+      dbConfigs,
+      configuredIds,
+      registeredNow,
+      inaccessibleIds,
+      linkedMap,
+      linkedNow,
+      retry,
+      nextRetry,
+      dirty,
+      register,
+      degrade
+    };
+  }
+  /**
+   * dry-run — 이번 pull 이 새로 찾을 DB(실제 pull 의 {@link openRegistry} 와 같은 규칙). 볼트 · 상태 DB 를 바꾸지 않는다. 받은
+   * 본문은 dry-run 이 이미 읽은 것(다시 이을 노트 · 로컬도 고친 노트)만 본다 — {@link bodyRead}.
+   *
+   * @returns 새로 찾을 DB 와 그 폴더를 가를 전체 목록(발견해 둔 DB 포함).
+   */
+  async plannedNewDatabases(failed, options) {
+    if (isDatabaseMode(this.config)) return { found: [], all: [] };
+    const registry = await this.openRegistry(failed, {
+      forceRediscovery: false,
+      rescanRoot: options.rescanRoot,
+      markScanned: false,
+      notePathOf: options.notePathOf
+    });
+    return {
+      found: registry.dbConfigs.filter(
+        (config) => registry.registeredNow.has(config.databaseId.replace(/-/g, ""))
+      ),
+      all: registry.dbConfigs.filter(
+        (config) => !registry.inaccessibleIds.has(config.databaseId.replace(/-/g, ""))
+      )
+    };
+  }
+  /**
+   * dry-run — 새로 받을 페이지의 본문을 읽어 그 안의 DB 를 찾는다({@link plannedNewDatabases} 가 그 행을 센다). 실제 pull 은
+   * 받으며 찾는다. 예전에는 읽지 않고 «미리 세지 않았습니다» 만 알렸다. {@link PREVIEW_BODY_READ_BUDGET} 개까지만 읽는다 —
+   * 넘거나 읽지 못한(다 받지 못한) 페이지는 {@link bodyRead} 가 아니어서 알림으로 남는다.
+   */
+  async readNewPageBodies(pageIds, signal) {
+    if (isDatabaseMode(this.config)) return;
+    const unread = pageIds.filter((pageId) => !this.bodyRead(pageId));
+    for (const pageId of unread.slice(0, PREVIEW_BODY_READ_BUDGET)) {
+      if (signal?.aborted) return;
+      try {
+        const result = await this.notionClient.getPageMarkdown(pageId);
+        if (result.truncated || (result.unknown_block_ids ?? []).length > 0) continue;
+        this.collectInlineDbRefs(pageId, result.markdown);
+      } catch (error) {
+        getLogger().debug(
+          `[Im-Nobsidian] \uBBF8\uB9AC \uBCF4\uAE30: \uC0C8 \uD398\uC774\uC9C0 \uBCF8\uBB38\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC548\uC758 DB \uB294 \uBC1B\uC73C\uBA70 \uCC3E\uC74C (${pageId}): ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /** 이번 pull 에서 본문을 받은 페이지인가 — 그 본문의 `<database>` 로 새 DB 를 찾았다. */
+  bodyRead(pageId) {
+    return this._bodyReadPages.has(normalizeNotionId(pageId));
+  }
   /**
    * 링크드 뷰 컨테이너마다 그 보기로 `.base` 를 쓴다({@link DatabaseSyncer.pullLinkedView}). 원본 DB 를 받은 pull ·
    * 이번에 해소한 컨테이너 · 아직 `.base` 가 없는 컨테이너만 — 보기만 고친 것은 DB 수정 시각을 바꾸지 않아 원본처럼
@@ -23763,7 +24165,7 @@ var DatabaseDiscovery = class {
    *   (예: 부모 "AI Engineer (1).md" + DB "Minirecord Project" → "AI Engineer (1)/Minirecord-Project")
    * - 제목 취득 실패 시 부모 폴더명 기반 안전 이름으로 폴백
    */
-  async buildDiscoveredDbConfig(dbId, parentPageId) {
+  async buildDiscoveredDbConfig(dbId, parentPageId, notePathOf = (pageId) => this.stateDb.getByNotionId(pageId)?.obsidianPath ?? null) {
     let dbTitle;
     try {
       const info = await this.notionClient.getDatabaseSyncability(dbId);
@@ -23789,10 +24191,9 @@ var DatabaseDiscovery = class {
       getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uC124\uC815 \uC0DD\uC131 \uC2E4\uD328:`, error);
       return { kind: "error", error: error instanceof Error ? error.message : String(error) };
     }
-    const parentEntry = parentPageId ? this.stateDb.getByNotionId(parentPageId) : null;
+    const obsPath = parentPageId ? notePathOf(parentPageId) : null;
     let parentFolder = "";
-    if (parentEntry?.obsidianPath) {
-      const obsPath = parentEntry.obsidianPath;
+    if (obsPath) {
       if (isMarkdownPath(obsPath)) {
         const parts = obsPath.split("/");
         const fileBase = stripMarkdownExtension(parts.pop() ?? "");
@@ -24544,7 +24945,14 @@ var LocalPlanner = class {
         live.add(target);
       }
     }
-    const pairs = scan.adoptions.map((a) => ({ from: a.record.obsidianPath, to: a.to }));
+    const filePairs = await this.movedFolderFilePairs(
+      [...folderRecords].filter((folder) => !live.has(folder))
+    );
+    for (const { to } of filePairs) for (const folder of foldersOf([to])) live.add(folder);
+    const pairs = [
+      ...scan.adoptions.map((a) => ({ from: a.record.obsidianPath, to: a.to })),
+      ...filePairs
+    ];
     const folderMoves = [];
     const databaseFolderMoves = [];
     for (const move of deriveFolderMoves(tracked, live, pairs, hints)) {
@@ -24553,6 +24961,29 @@ var LocalPlanner = class {
     }
     return { folderMoves, databaseFolderMoves };
   }
+  /**
+   * 사라진 폴더 페이지에 올린 폴더 첨부의 짝 — 노트 없이 파일만 든 폴더는 노트의 짝이 없어 이름을 바꿔도 옮긴 줄 몰랐다. 그
+   * 폴더 페이지에 올린 파일과 이름 · 크기가 같은 파일이 볼트에 하나뿐이면 그리로 옮겼다. 예전에는 새 폴더 페이지를 만들어 다시
+   * 올렸고, 삭제 동기화가 꺼져 있으면 옛 폴더 페이지가 남아 다른 볼트가 두 폴더를 받았다.
+   */
+  async movedFolderFilePairs(missing) {
+    const entries = missing.flatMap((folder) => {
+      const pageId = this.stateDb.getByPath(folder)?.notionPageId;
+      if (!pageId) return [];
+      return this.stateDb.getFilesByPageId(pageId).filter((entry) => entry.localPath.startsWith(`${folder}/`));
+    });
+    if (entries.length === 0) return [];
+    const files = await this.vaultFs.listNonMarkdownFiles();
+    const nameOf = (path) => path.slice(path.lastIndexOf("/") + 1);
+    const pairs = [];
+    for (const entry of entries) {
+      const found2 = files.filter(
+        (file) => nameOf(file.path) === nameOf(entry.localPath) && file.size === entry.fileSize
+      );
+      if (found2.length === 1) pairs.push({ from: entry.localPath, to: found2[0].path });
+    }
+    return pairs;
+  }
   /** 레코드를 새 경로로 옮겨 적는다 — 이동 WAL · 위키링크 · 보존 마커도 함께. */
   moveRecord(record, to) {
     const from = record.obsidianPath;
@@ -27174,11 +27605,14 @@ var PagePusher = class {
   async pushUpdatePage(pageId, markdownContent, notePath) {
     if (this.config.conversion.preferMarkdownApi !== false) {
       const deferred = deferSyncedReferences(obsidianToNotionEnhanced(markdownContent));
-      const { markdown, kept } = await this.imageHandler.keepUploadedMedia(
+      const { markdown: body, kept } = await this.imageHandler.keepUploadedMedia(
         pageId,
         deferred.nfm,
         notePath
       );
+      const folderFiles = await this.folderFileLines(pageId);
+      const markdown = folderFiles ? `${body}
+${folderFiles}` : body;
       const written = await replacePageBody(this.notionClient, pageId, markdown, {
         databaseIdsOfBase: (basePath) => this.databaseIdsOfBase(basePath),
         unknownTagFallbacks: unknownTagFallbacks(markdownContent)
@@ -27198,6 +27632,7 @@ var PagePusher = class {
         "\uC790\uC2DD \uD398\uC774\uC9C0 \xB7 DB \uAC00 \uC788\uB294 \uD398\uC774\uC9C0\uB294 \uBE14\uB85D \uBC29\uC2DD\uC73C\uB85C \uBCF8\uBB38\uC744 \uBCF4\uB0B4\uBA74 \uC790\uC2DD\uAE4C\uC9C0 \uC9C0\uC6CC\uC838 \uBCF4\uB0B4\uC9C0 \uC54A\uC74C \u2014 \uC124\uC815 conversion.preferMarkdownApi \uB97C \uAE30\uBCF8\uAC12(true)\uC73C\uB85C \uB450\uACE0 \uB2E4\uC2DC push \uD558\uC138\uC694"
       );
     }
+    this.forgetFolderFilesForBlockMode(pageId, notePath);
     const { nfm, blocks } = blockModeBody(markdownContent);
     if (blocks.length > 0) {
       await this.notionClient.appendBlockTree(pageId, blocks);
@@ -27215,6 +27650,32 @@ var PagePusher = class {
     );
     return { fingerprint: null, kept: [], sent: nfm, syncedRefs: [], syncedRefText: "" };
   }
+  /**
+   * 노트 페이지의 폴더 첨부 줄(ADR-056) — 본문을 통째로 바꿀 때 받은 줄 그대로 끝에 되실어야 Notion 이 그 블록을 둔다
+   * ({@link ImageHandler.keepUploadedMedia} 와 같은 실측). 이 페이지에 적어 둔 폴더 첨부가 없으면 읽지 않는다. 읽지 못하면
+   * 던진다 — 모르고 바꾸면 폴더 첨부가 지워진다.
+   */
+  async folderFileLines(pageId) {
+    const ids = new Set(folderFileIdsOf(this.stateDb, pageId).values());
+    if (ids.size === 0) return "";
+    const remote = (await this.notionClient.getPageMarkdown(pageId)).markdown;
+    return (folderFilesInNote(remote, { knownIds: ids })?.lines ?? []).join("\n");
+  }
+  /**
+   * 블록 방식은 본문 블록을 모두 지우고 새로 붙인다 — 폴더 첨부 블록을 남기면 새 본문이 그 뒤에 붙는다.
+   * 함께 지우고 기록을 놓는다 — 이어지는 첨부 push 가 볼트의 파일을 다시 끝에 올린다.
+   */
+  forgetFolderFilesForBlockMode(pageId, notePath) {
+    const ids = folderFileIdsOf(this.stateDb, pageId);
+    if (ids.size === 0) return;
+    for (const localPath of ids.keys()) {
+      this.stateDb.deleteFileRegistry(localPath);
+      forgetFolderFileId(this.stateDb, pageId, localPath);
+    }
+    getLogger().info(
+      `[Im-Nobsidian] \uBE14\uB85D \uBC29\uC2DD\uC73C\uB85C \uBCF8\uBB38\uC744 \uBC14\uAFD4 \uD3F4\uB354 \uCCA8\uBD80 ${ids.size}\uAC1C\uB97C \uB2E4\uC2DC \uC62C\uB9BC (${notePath})`
+    );
+  }
   /**
    * 자리표시로 보낸 코드를 채우고(S-22) 동기화 블록 참조를 붙인다({@link deferSyncedReferences}) — 본문을
    * 바꾼 뒤(블록 방식이면 옛 블록을 지운 뒤) 부른다.
@@ -27454,34 +27915,80 @@ var PagePuller = class {
     );
   }
   /**
-   * dry-run — 실제 pull 이 이 새 페이지를 새로 받지 않고 상태 기록에 없던 노트 · 폴더와 다시 잇는가(P7). 다시 이을 노트(`note`) ·
-   * 이미 있는 폴더(`folder` — 이은 노트가 없는 볼트에서 폴더로만 받으면 만들지 않는다), 아니면 null. 받기 전에는 폴더 노트가 될지
-   * 모른다 — 노트 자리 · 폴더 노트 자리를 차례로 본다. `taken` 은 이번 미리 보기가 이미 이은 자리({@link pathKey}) — 고르면
-   * 더한다. 볼트도 상태 DB 도 바꾸지 않는다.
+   * dry-run — 실제 pull({@link createPulledPage})이 이 새 페이지를 새로 받지 않고 상태 기록에 없던 노트 · 폴더와 다시 잇는가(P7).
+   * 다시 이을 노트(`note` — 충돌로 남길 것이면 `conflict`) · 이미 있는 폴더(`folder` — 폴더로만 받는 페이지), 아니면 null.
+   * 그 자리에 무엇이 있을 때만 본문을 받아 실제 pull 처럼 렌더해 견준다 — 미디어는 받되 볼트에 쓰지 않는다
+   * ({@link ImageHandler.preview}). `taken` 은 이번 미리 보기가 이미 이은 자리({@link pathKey}) — 고르면 더한다. 볼트도 상태 DB 도
+   * 바꾸지 않는다.
    */
   async plannedRelink(pageId, taken) {
     const page = this.detector.discoveredPage(pageId) ?? await this.notionClient.getPage(pageId);
-    const safeName = sanitizeFileName(this.notionClient.extractTitle(page));
+    const title = this.notionClient.extractTitle(page);
+    const safeName = sanitizeFileName(title);
     const parentPath = await this.resolveParentPath(page);
+    if (this.excludedCreatePath(parentPath, safeName) !== null) return null;
     const folder = parentPath ? `${parentPath}/${safeName}` : safeName;
-    for (const dir of [parentPath, folder]) {
-      const found2 = await findUntrackedNote(
-        this.stateDb,
-        this.vaultFs,
-        dir,
-        safeName,
-        pageId,
-        (key) => taken.has(key)
-      );
-      if (found2 && relinksWithoutContent(found2, this.unlinkedVault)) {
-        taken.add(pathKey(found2.path));
-        return { path: found2.path, kind: "note" };
-      }
+    const untrackedIn = (dir) => findUntrackedNote(this.stateDb, this.vaultFs, dir, safeName, pageId, (key) => taken.has(key));
+    const folderExists = async () => !taken.has(pathKey(folder)) && this.stateDb.getByPath(folder) === null && await this.vaultFs.exists(folder);
+    if (!await untrackedIn(parentPath) && !await untrackedIn(folder) && !await folderExists()) {
+      return null;
     }
-    const folderExists = this.unlinkedVault && !taken.has(pathKey(folder)) && this.stateDb.getByPath(folder) === null && await this.vaultFs.exists(folder);
-    if (!folderExists) return null;
-    taken.add(pathKey(folder));
-    return { path: folder, kind: "folder" };
+    const fetched = await this.fetchPageMarkdown(pageId);
+    const hasChildPages = this.hasChildContainers(pageId, fetched.children);
+    const folderOnly = hasChildPages && !fetched.hasBody || fetched.folderFiles !== null && (hasChildPages || fetched.folderFiles.named);
+    if (folderOnly) {
+      if (!await folderExists()) return null;
+      taken.add(pathKey(folder));
+      return { path: folder, kind: "folder" };
+    }
+    const found2 = await untrackedIn(hasChildPages ? folder : parentPath);
+    if (!found2) return null;
+    const local = await readLocalNote(this.vaultFs, found2.path);
+    if (local === void 0) return null;
+    const rendered = await this.imageHandler.preview(
+      () => this.renderPageNote({
+        pageId,
+        page,
+        fetched,
+        filePath: found2.path,
+        title,
+        titleFollowsName: extractTitle(found2.path) === title,
+        downloadMedia: true,
+        local: { content: local, markers: [] },
+        adoptLocalMedia: true
+      })
+    );
+    const same = sameNoteContent(local, rendered.content) || sameAsPendingLinks(local, rendered.content);
+    const outcome = relinkOutcome(
+      found2.existing,
+      same,
+      this.unlinkedVault,
+      this.config.sync.conflictStrategy
+    );
+    if (outcome === null) return null;
+    taken.add(pathKey(found2.path));
+    if (outcome !== "conflict") return { path: found2.path, kind: "note" };
+    const parentId = await extractParentId(this.notionClient, page);
+    return {
+      path: found2.path,
+      kind: "note",
+      conflict: relinkConflict({
+        record: plannedRelinkRecord({
+          path: found2.path,
+          pageId,
+          parentId,
+          remote: rendered.content,
+          lastEdited: page.last_edited_time,
+          fileType: hasChildPages ? "folder-note" : "file"
+        }),
+        path: found2.path,
+        local,
+        remote: rendered.content,
+        pageId,
+        lastEdited: page.last_edited_time,
+        title
+      })
+    };
   }
   /**
    * 새 페이지가 놓일 자리가 뺀 자리인가 — 부모 폴더 · 노트 이름 · 폴더 노트가 될 때의 폴더를 본다. 받기 전에는 폴더 노트가
@@ -27546,7 +28053,10 @@ var PagePuller = class {
       const local = await readLocalNote(this.vaultFs, filePath);
       rendered = await render2(filePath, local);
       const relinked = local === void 0 ? null : this.relinkExistingNote(filePath, claim.existing, local, rendered, note);
-      if (relinked) return relinked;
+      if (relinked) {
+        await this.receiveNoteFiles(filePath, fileType, pageId, fetched);
+        return relinked;
+      }
       this.claimedPaths.delete(pathKey(filePath));
       filePath = (await this.resolveUniqueFilePath(noteDir, safeName, pageId)).path;
       rendered = await render2(filePath);
@@ -27559,24 +28069,35 @@ var PagePuller = class {
       properties: rendered.properties,
       status: "synced"
     });
+    await this.receiveNoteFiles(filePath, fileType, pageId, fetched);
     return { path: filePath };
   }
+  /** 새로 받은 노트 페이지의 폴더 첨부를 그 노트의 폴더에 받는다(ADR-056) — 폴더 노트는 그 폴더, 노트는 이름의 폴더. */
+  async receiveNoteFiles(filePath, fileType, pageId, fetched) {
+    if (fetched.noteFiles.length === 0) return;
+    await this.receiveFolderFiles(
+      childFolderOf({ fileType, obsidianPath: filePath }, this.placement.folderLookup()),
+      pageId,
+      fetched.noteFiles,
+      fetched.noteFilesComplete
+    );
+  }
   /**
    * 상태 기록에 없는 노트가 이 페이지가 놓일 자리에 이미 있다 — 상태 DB 를 잃었거나 처음 잇는 볼트다(P7).
    * 예전에는 남의 노트로 보고 id 를 붙인 이름으로 또 받아 모든 노트가 두 벌이 됐다(push 는 모든 페이지를 또 만들었다).
-   *
-   * - 글이 같으면(끝 개행만 달라도) 그 노트를 이 페이지와 다시 잇는다 — 쓰지 않는다.
-   * - 다르면 이 페이지 id 를 단 이름(지난번 이 페이지를 받은 이름)이면 충돌 전략을 따른다: remote-first 는 원격으로 덮고 ·
-   *   local-first 는 로컬을 두어 다음 push 가 올리고 · 그 밖은 충돌로 남긴다(지난 사본이 없어 merge 도 합칠 수 없다).
-   * - 자연 이름에 있는 다른 글은 이은 노트가 하나도 없는 볼트에서만 잇고 전략과 상관없이 충돌로 남긴다 — 다른 노트일 수 있어
-   *   덮거나 올리면 잃는다. 이은 노트가 있는 볼트에서는 잇지 않는다(null) — 그 볼트의 새 노트일 수 있다.
+   * 받은 글과 견줘 {@link relinkOutcome} 대로 잇는다 — 잇지 않으면 null(id 를 단 새 이름으로 받는다).
    */
   relinkExistingNote(filePath, existing, local, rendered, note) {
     const same = sameNoteContent(local, rendered.content) || sameAsPendingLinks(local, rendered.content);
-    if (!same && existing === "name" && !this.unlinkedVault) return null;
+    const outcome = relinkOutcome(
+      existing,
+      same,
+      this.unlinkedVault,
+      this.config.sync.conflictStrategy
+    );
+    if (outcome === null) return null;
     return (async () => {
-      const strategy = existing === "own" ? this.config.sync.conflictStrategy : "manual";
-      if (same || strategy === "local-first") {
+      if (outcome === "relink") {
         await this.recordPulledNote(filePath, note, {
           content: rendered.content,
           properties: rendered.properties,
@@ -27587,7 +28108,7 @@ var PagePuller = class {
         });
         return { path: filePath, relinked: true };
       }
-      if (strategy === "remote-first") {
+      if (outcome === "overwrite") {
         await this.vaultFs.writeFile(filePath, rendered.content);
         await this.recordPulledNote(filePath, note, {
           content: rendered.content,
@@ -27603,27 +28124,15 @@ var PagePuller = class {
         snapshot: null,
         differsOnDisk: true
       });
-      const record = this.stateDb.getByPath(filePath);
-      const conflict = {
-        syncRecord: record,
-        localChange: {
-          path: filePath,
-          type: "modified",
-          currentHash: computeHash(local),
-          previousHash: record.contentHash
-        },
-        remoteChange: {
-          pageId: note.pageId,
-          type: "modified",
-          lastEdited: note.page.last_edited_time,
-          previousEdited: null,
-          path: filePath,
-          title: note.title
-        },
-        baseContent: null,
-        localContent: local,
-        remoteContent: rendered.content
-      };
+      const conflict = relinkConflict({
+        record: this.stateDb.getByPath(filePath),
+        path: filePath,
+        local,
+        remote: rendered.content,
+        pageId: note.pageId,
+        lastEdited: note.page.last_edited_time,
+        title: note.title
+      });
       return { path: filePath, relinked: true, conflict };
     })();
   }
@@ -27731,6 +28240,14 @@ var PagePuller = class {
     }
     const rendered = await this.renderRemotePage(record, change.pageId, page);
     const remoteContent = rendered.content;
+    if (rendered.folderFiles && !remoteGone) {
+      await this.receiveFolderFiles(
+        childFolderOf(record, this.placement.folderLookup()),
+        change.pageId,
+        rendered.folderFiles.files,
+        rendered.folderFiles.complete
+      );
+    }
     let localContent;
     let localExists = true;
     try {
@@ -27874,7 +28391,10 @@ var PagePuller = class {
     if (record.fileType === "db-row") {
       return this.databaseSyncer.renderRow(page, record.obsidianPath, { downloadMedia });
     }
-    const fetched = await this.fetchPageMarkdown(pageId);
+    const local = await readLocalNote(this.vaultFs, record.obsidianPath);
+    const fetched = await this.fetchPageMarkdown(pageId, {
+      embedded: embeddedNamesOf(local === void 0 ? [] : [local])
+    });
     const title = this.notionClient.extractTitle(page);
     const { content, properties } = await this.renderPageNote({
       pageId,
@@ -27885,11 +28405,17 @@ var PagePuller = class {
       titleFollowsName: this.titleFollowsName(record, title),
       downloadMedia,
       local: {
-        content: await readLocalNote(this.vaultFs, record.obsidianPath),
+        content: local,
         markers: this.stateDb.getPreserveMarkers(record.obsidianPath)
       }
     });
-    return { content, title, properties, bodyFingerprint: fetched.fingerprint };
+    return {
+      content,
+      title,
+      properties,
+      bodyFingerprint: fetched.fingerprint,
+      folderFiles: { files: fetched.noteFiles, complete: fetched.noteFilesComplete }
+    };
   }
   /**
    * 받은 페이지 본문을 볼트에 쓸 노트로 — 새로 받기(`createPulledPage`)와 다시 받기({@link renderRemotePage})가
@@ -27957,19 +28483,27 @@ var PagePuller = class {
   /**
    * 페이지 본문을 볼트 쪽 markdown 으로 받는다.
    *
+   * @param options.embedded 로컬 노트가 임베드한 파일 이름 — 폴더 첨부({@link folderFilesInNote})를 노트에서 떼어
+   *   `noteFiles` 로 돌려줄 때, 이 이름 · 이 볼트가 노트 첨부로 올린 파일은 노트의 것으로 둔다(ADR-056).
    * @returns `fingerprint` 는 받은 원격 본문의 지문({@link remoteBodyFingerprint}). 블록 API 로
    *   받았으면 null — 지문은 Markdown API 의 본문으로만 견준다.
    */
-  async fetchPageMarkdown(pageId) {
+  async fetchPageMarkdown(pageId, options = {}) {
+    const noteFilesOf = (markdown) => this.noteFolderFilesOf(pageId, markdown, options);
     if (this.config.conversion.preferMarkdownApi !== false) {
       try {
         const result = await this.notionClient.getPageMarkdown(pageId);
         this.discovery.collectInlineDbRefs(pageId, result.markdown);
         this.detector.noteBodyChildren(pageId, result.markdown);
+        const found2 = noteFilesOf(result.markdown);
         return {
           content: await this.resolveBlockLinks(
             this.resolveNotionIdWikilinks(
-              await notionBodyToObsidian(this.notionClient, result.markdown, pageId)
+              await notionBodyToObsidian(
+                this.notionClient,
+                found2?.markdown ?? result.markdown,
+                pageId
+              )
             ),
             pageId
           ),
@@ -27979,7 +28513,9 @@ var PagePuller = class {
           children: extractChildTags(result.markdown),
           fingerprint: remoteBodyFingerprint(result.markdown),
           hasBody: hasBodyBesidesChildren(result.markdown),
-          folderFiles: folderFilesInBody(result.markdown)
+          folderFiles: folderFilesInBody(result.markdown),
+          noteFiles: found2?.files ?? [],
+          noteFilesComplete: !result.truncated && this.noteFilesHoldAll(pageId, found2?.markdown ?? result.markdown)
         };
       } catch (error) {
         getLogger().warn(
@@ -27987,7 +28523,14 @@ var PagePuller = class {
         );
       }
     }
-    const fallback = await pageBlocksToObsidian(this.notionClient, pageId);
+    let noteFiles = [];
+    let noteFilesComplete = true;
+    const fallback = await pageBlocksToObsidian(this.notionClient, pageId, (markdown) => {
+      const found2 = noteFilesOf(markdown);
+      noteFiles = found2?.files ?? [];
+      noteFilesComplete = this.noteFilesHoldAll(pageId, found2?.markdown ?? markdown);
+      return found2?.markdown ?? markdown;
+    });
     this.discovery.collectInlineDbRefs(pageId, fallback.markdown);
     this.detector.noteBodyChildren(pageId, fallback.markdown);
     return {
@@ -27999,9 +28542,28 @@ var PagePuller = class {
       children: extractChildTags(fallback.markdown),
       fingerprint: null,
       hasBody: hasBodyBesidesChildren(fallback.markdown),
-      folderFiles: folderFilesInBody(fallback.markdown)
+      folderFiles: folderFilesInBody(fallback.markdown),
+      noteFiles,
+      noteFilesComplete
     };
   }
+  /** 노트 페이지의 폴더 첨부({@link folderFilesInNote}) — 없으면 null. */
+  noteFolderFilesOf(pageId, markdown, options) {
+    const media = recallUploadedMedia(this.stateDb, pageId);
+    return folderFilesInNote(markdown, {
+      knownIds: new Set(folderFileIdsOf(this.stateDb, pageId).values()),
+      exclude: (file) => {
+        const fileId = notionFileIdOf(file.url);
+        return options.embedded?.has(file.name) === true || fileId !== null && media.has(fileId);
+      }
+    });
+  }
+  /** 폴더 첨부를 뗀 본문에 적어 둔 폴더 첨부가 남지 않았나 — {@link fetchPageMarkdown} 의 `noteFilesComplete`. */
+  noteFilesHoldAll(pageId, rest) {
+    const ids = new Set(folderFileIdsOf(this.stateDb, pageId).values());
+    if (ids.size === 0) return true;
+    return !notionMediaSpans(rest).some((span) => ids.has(notionFileIdOf(span.url) ?? ""));
+  }
   /** 폴더 첨부를 받아 받은 파일 수에 더한다. */
   async receiveFolderFiles(folder, pageId, files, complete2 = false) {
     this._pullFileCount += await this.fileHandler.receiveFolderFiles(
@@ -28413,7 +28975,7 @@ function resolvesNow(stateDb, record, marker, pushed) {
 
 // src/sync/pull-planner.ts
 var PullPlanner = class {
-  constructor(config, stateDb, vaultFs, databaseSyncer, drift, planner, puller) {
+  constructor(config, stateDb, vaultFs, databaseSyncer, drift, planner, puller, discovery, detector) {
     this.config = config;
     this.stateDb = stateDb;
     this.vaultFs = vaultFs;
@@ -28421,6 +28983,8 @@ var PullPlanner = class {
     this.drift = drift;
     this.planner = planner;
     this.puller = puller;
+    this.discovery = discovery;
+    this.detector = detector;
   }
   config;
   stateDb;
@@ -28429,11 +28993,13 @@ var PullPlanner = class {
   drift;
   planner;
   puller;
+  discovery;
+  detector;
   /**
    * pull 할 것을 세기만 한다(dry-run) — 볼트 · 상태 DB · Notion 을 바꾸지 않는다. 페이지와 DB 행을
-   * 같이 센다. DB 는 설정한 DB 와 이미 발견해 둔 DB 가운데 실제 pull 이 조회할 것(`ledger`)만 센다 —
-   * 이번 pull 이 새로 발견할 DB 는 받아 봐야 안다. 세지 못한 DB 는 이유와 함께 `failed` 에 싣는다
-   * (세지 못한 것을 없다고 하지 않는다).
+   * 같이 센다. DB 는 설정한 DB 와 이미 발견해 둔 DB 가운데 실제 pull 이 조회할 것(`ledger`)과, 이번 pull 이 새로 찾을
+   * DB(루트 · 미리 보며 읽은 본문 안)를 센다. 세지 못한 DB 는 이유와 함께 `failed` 에 싣는다(세지 못한 것을 없다고 하지
+   * 않는다).
    */
   async planPull(filtered, restoreChanges, restoreIds, localPlan, options, startTime, scan, ledger) {
     const unchangedDropped = await this.drift.withoutUnchangedRemotes(filtered, options.signal);
@@ -28459,20 +29025,36 @@ var PullPlanner = class {
       planned.push(change);
     }
     const relinks = await this.plannedRelinks(planned);
+    for (const relink of relinks.byPage.values()) {
+      if (relink.conflict) conflicts.push(relink.conflict);
+    }
     const queued = new Set(
       [...filtered, ...restoreChanges].map((change) => compactNotionId(change.pageId))
     );
     const movingInVault = new Set(localPlan?.scan.adoptions.map((adoption) => adoption.record.id));
+    const relinkPaths = new Map(
+      [...relinks.byPage].map(([pageId, relink]) => [compactNotionId(pageId), relink.path])
+    );
+    await this.discovery.readNewPageBodies(
+      planned.filter((change) => change.type === "created").map((change) => change.pageId),
+      options.signal
+    );
+    const newDatabases = await this.discovery.plannedNewDatabases(failed, {
+      rescanRoot: this.detector.rootChanged(),
+      notePathOf: (pageId) => relinkPaths.get(compactNotionId(pageId)) ?? this.stateDb.getByNotionId(pageId)?.obsidianPath ?? null
+    });
     const rows = [];
     for (const row of await this.planDatabaseRows(
       options.paths,
       failed,
       ledger,
       movingInVault,
-      relinks.taken
+      relinks.taken,
+      newDatabases
     )) {
       if (queued.has(compactNotionId(row.pageId))) continue;
       if (row.resolution?.action === "conflict") conflicts.push(row.resolution.conflict);
+      if (row.relinkConflict) conflicts.push(row.relinkConflict);
       else if (row.resolution?.action === "merge") mergedPaths.push(row.path);
       if (row.resolution?.action === "conflict" || row.resolution?.action === "skip") continue;
       rows.push(row);
@@ -28514,7 +29096,7 @@ var PullPlanner = class {
     const rowCount = (operation, restore = false) => rows.filter(
       (row) => row.operation === operation && (row.restore ?? false) === restore && !row.relink
     ).length;
-    const undiscoveredDatabases = !isDatabaseMode(this.config) && (discoveryScanPending(this.stateDb) || planned.some((c) => c.type === "created"));
+    const undiscoveredDatabases = !isDatabaseMode(this.config) && planned.some((c) => c.type === "created" && !this.discovery.bodyRead(c.pageId));
     const relinkedPaths = [
       ...[...relinks.byPage.values()].filter((relink) => relink.kind === "note").map((relink) => relink.path),
       ...rows.filter((row) => row.relink).map((row) => row.path)
@@ -28617,11 +29199,12 @@ var PullPlanner = class {
    * (`DatabaseDiscovery.pullDiscoveredDatabases`)를 같은 규칙으로 고른다. 세지 못한 DB 는 이유와
    * 함께 `failed` 에 싣는다 — 세지 못한 것을 없다고 하지 않는다.
    */
-  async planDatabaseRows(paths, failed, ledger, movingInVault, relinkTaken) {
+  async planDatabaseRows(paths, failed, ledger, movingInVault, relinkTaken, databases) {
     const configured = this.config.notion.databases ?? [];
     const rows = [];
+    const found2 = new Set(databases.found);
     const plan = async (dbConfig, resolveDbFolder2) => {
-      if (!ledger.selects(dbConfig.databaseId)) {
+      if (!found2.has(dbConfig) && !ledger.selects(dbConfig.databaseId)) {
         ledger.skip();
         return;
       }
@@ -28646,17 +29229,9 @@ var PullPlanner = class {
     };
     for (const dbConfig of configured) await plan(dbConfig);
     if (isDatabaseMode(this.config)) return rows;
-    const discovered = parseDiscoveredDbs(this.stateDb.getMeta(DISCOVERED_DBS_META_KEY));
-    repairDbFolderCollisions(
-      discovered,
-      new Map(configured.map((d) => [d.localFolder, d.databaseId]))
-    );
-    const inaccessible = loadInaccessibleDbIds(this.stateDb);
+    const discovered = databases.all;
     const resolveDbFolder = (dbId) => [...discovered, ...configured].find((c) => notionIdsEqual(c.databaseId, dbId))?.localFolder ?? null;
-    for (const dbConfig of discovered) {
-      if (inaccessible.has(dbConfig.databaseId.replace(/-/g, ""))) continue;
-      await plan(dbConfig, resolveDbFolder);
-    }
+    for (const dbConfig of discovered) await plan(dbConfig, resolveDbFolder);
     return rows;
   }
 };
@@ -29541,7 +30116,9 @@ var SyncOrchestrator = class {
       this.databaseSyncer,
       this.drift,
       this.planner,
-      this.puller
+      this.puller,
+      this.discovery,
+      this.detector
     );
     this.pusher = new PagePusher(
       config,
@@ -29654,7 +30231,11 @@ var SyncOrchestrator = class {
   async pushVaultFiles(failed) {
     if (this.config.sync.syncFiles === false) return 0;
     try {
-      const fileResults = await this.fileHandler.pushAllFiles(failed, this.placement);
+      const fileResults = await this.fileHandler.pushAllFiles(
+        failed,
+        this.placement,
+        this.notePageWrites()
+      );
       if (fileResults.length > 0) {
         getLogger().info(`[Im-Nobsidian] ${fileResults.length}\uAC1C \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC`);
       }
@@ -29664,6 +30245,42 @@ var SyncOrchestrator = class {
       return 0;
     }
   }
+  /**
+   * 폴더 첨부를 노트의 페이지에 붙이거나 지울 때({@link NotePageWrites}) — 쓰기 전에 원격과 맞던 노트만 쓴 뒤의 원격을 본
+   * 것으로 적는다. 받지 않은 Notion 편집이 걸린 노트를 적으면 다음 pull 이 그 편집을 받지 않는다. 읽지 못하면 적지 않는다 —
+   * 다음 push 가 그 노트를 올리지 않고 pull 을 먼저 하라고 알릴 뿐이다.
+   */
+  notePageWrites() {
+    const inSync = /* @__PURE__ */ new Map();
+    return {
+      begin: async (pageId) => {
+        const record = this.stateDb.getByNotionId(pageId);
+        if (!record || isFolderRecord(record)) return;
+        try {
+          const page = await this.notionClient.getPage(pageId);
+          if (await this.drift.remoteDrift(record, page) === "none")
+            inSync.set(pageId, record.id);
+        } catch (error) {
+          getLogger().warn(
+            `[Im-Nobsidian] \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBD99\uC77C \uB178\uD2B8\uC758 \uC6D0\uACA9\uC744 \uC77D\uC9C0 \uBABB\uD568 (${record.obsidianPath}): ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      },
+      end: async (pageId) => {
+        const recordId = inSync.get(pageId);
+        if (recordId === void 0) return;
+        inSync.delete(pageId);
+        try {
+          const page = await this.notionClient.getPage(pageId);
+          this.observation.record(recordId, page, await this.drift.remoteBodyFingerprintOf(pageId));
+        } catch (error) {
+          getLogger().warn(
+            `[Im-Nobsidian] \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBD99\uC778 \uB178\uD2B8\uC758 \uC6D0\uACA9\uC744 \uC801\uC9C0 \uBABB\uD568 (${pageId}): ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    };
+  }
   /**
    * @param mergedByPull sync dry-run 만 — 앞선 pull dry-run 이 합칠 노트. 실제 sync 는 합친 뒤 원격을 본 것으로
    *   적어 push 가 올린다 — dry-run 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
@@ -32242,7 +32859,7 @@ function hasColumnLayout(text) {
 var START_RE = new RegExp(`^[\\t ]*${COLUMN_LIST_START}[\\t ]*$`);
 var END_RE = new RegExp(`^[\\t ]*${COLUMN_LIST_END}[\\t ]*$`);
 var SEP_RE = new RegExp(`^[\\t ]*${COLUMN_SEP_SOURCE}[\\t ]*$`);
-var FENCE_RE = /^[\t ]*(`{3,}|~{3,})/;
+var FENCE_RE2 = /^[\t ]*(`{3,}|~{3,})/;
 function readColumnLayout(lines) {
   const places = new Array(lines.length);
   let group2 = -1;
@@ -32266,7 +32883,7 @@ function readColumnLayout(lines) {
     open = null;
   };
   lines.forEach((line, i) => {
-    const fenceMatch = FENCE_RE.exec(line);
+    const fenceMatch = FENCE_RE2.exec(line);
     if (fence) {
       if (fenceMatch && fenceMatch[1].startsWith(fence)) fence = null;
       return;