@im-nobsidian/core 0.19.0 → 0.20.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));
@@ -15760,8 +15781,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 +16021,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(
@@ -16578,6 +16657,10 @@ function decodeId(id) {
 // src/sync/discovered-databases.ts
 var ROOT_DATABASES_FOLDER = "databases";
 var DISCOVERED_DBS_META_KEY = "discovered_dbs";
+var DISCOVERY_SCANNED_META_KEY = "discovery_scanned_at";
+function discoveryScanPending(stateDb) {
+  return parseDiscoveredDbs(stateDb.getMeta(DISCOVERED_DBS_META_KEY)).length === 0 && !stateDb.getMeta(DISCOVERY_SCANNED_META_KEY);
+}
 var INACCESSIBLE_DBS_META_KEY = "inaccessible_dbs";
 var LINKED_DBS_META_KEY = "linked_dbs";
 function parseDiscoveredDbs(raw) {
@@ -19985,13 +20068,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;
         }
@@ -20822,16 +20907,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({
@@ -20858,31 +20947,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
+      })
     };
   }
   /** 이번 받기에서 로컬 편집을 합친 행의 경로를 가져가고 비운다. */
@@ -23377,7 +23492,6 @@ function dropEmbeddedBaseMarkers(content, basePaths) {
 
 // src/sync/database-discovery.ts
 var DISCOVERY_RETRY_META_KEY = "discovery_retry";
-var DISCOVERY_SCANNED_META_KEY = "discovery_scanned_at";
 function parseDiscoveryRetry(raw) {
   if (!raw) return { parents: [], dbs: [] };
   try {
@@ -23443,144 +23557,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 || dbConfigs.length === 0 && !this.stateDb.getMeta(DISCOVERY_SCANNED_META_KEY);
-      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];
@@ -23618,14 +23613,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)`
@@ -23680,18 +23675,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) {
@@ -23708,6 +23703,196 @@ 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, ""))
+      )
+    };
+  }
+  /** 이번 pull 에서 본문을 받은 페이지인가 — 그 본문의 `<database>` 로 새 DB 를 찾았다. */
+  bodyRead(pageId) {
+    return this._bodyReadPages.has(normalizeNotionId(pageId));
+  }
   /**
    * 링크드 뷰 컨테이너마다 그 보기로 `.base` 를 쓴다({@link DatabaseSyncer.pullLinkedView}). 원본 DB 를 받은 pull ·
    * 이번에 해소한 컨테이너 · 아직 `.base` 가 없는 컨테이너만 — 보기만 고친 것은 DB 수정 시각을 바꾸지 않아 원본처럼
@@ -23760,7 +23945,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);
@@ -23786,10 +23971,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() ?? "");
@@ -27451,34 +27635,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
+      })
+    };
   }
   /**
    * 새 페이지가 놓일 자리가 뺀 자리인가 — 부모 폴더 · 노트 이름 · 폴더 노트가 될 때의 폴더를 본다. 받기 전에는 폴더 노트가
@@ -27561,19 +27791,19 @@ var PagePuller = class {
   /**
    * 상태 기록에 없는 노트가 이 페이지가 놓일 자리에 이미 있다 — 상태 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,
@@ -27584,7 +27814,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,
@@ -27600,27 +27830,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 };
     })();
   }
@@ -28410,7 +28628,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;
@@ -28418,6 +28636,8 @@ var PullPlanner = class {
     this.drift = drift;
     this.planner = planner;
     this.puller = puller;
+    this.discovery = discovery;
+    this.detector = detector;
   }
   config;
   stateDb;
@@ -28426,11 +28646,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);
@@ -28456,20 +28678,32 @@ 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])
+    );
+    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);
@@ -28511,6 +28745,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) && 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)
@@ -28527,6 +28762,7 @@ var PullPlanner = class {
       conflicts,
       ...mergedPaths.length > 0 ? { mergedPaths } : {},
       ...relinkedPaths.length > 0 ? { relinkedPaths, relinkPending: true } : {},
+      ...undiscoveredDatabases ? { undiscoveredDatabases: true } : {},
       writtenPaths: [],
       failed,
       duration: Date.now() - startTime,
@@ -28612,11 +28848,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;
       }
@@ -28641,17 +28878,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;
   }
 };
@@ -29536,7 +29765,9 @@ var SyncOrchestrator = class {
       this.databaseSyncer,
       this.drift,
       this.planner,
-      this.puller
+      this.puller,
+      this.discovery,
+      this.detector
     );
     this.pusher = new PagePusher(
       config,