@im-nobsidian/core 0.14.1 → 0.15.0

package/dist/index.js

@@ -172,6 +172,15 @@ function withNotifications(args, mode) {
   return { ...args, body: { ...args.body, notifications: { mode } } };
 }
 
+// src/types/sync.ts
+var CONFLICT_STRATEGIES = [
+  "local-first",
+  "remote-first",
+  "manual",
+  "duplicate",
+  "merge"
+];
+
 // src/types/config.ts
 var NOTION_TOKEN_PREFIX = "ntn_";
 var DEFAULT_TITLE_PROPERTY = "Name";
@@ -246,7 +255,7 @@ var ConfigSchema = z.object({
   }),
   sync: z.object({
     direction: z.enum(["push", "pull", "both"]).default(D.sync.direction),
-    conflictStrategy: z.enum(["local-first", "remote-first", "manual", "duplicate"]).default(D.sync.conflictStrategy),
+    conflictStrategy: z.enum(CONFLICT_STRATEGIES).default(D.sync.conflictStrategy),
     autoSync: z.boolean().default(D.sync.autoSync),
     autoSyncInterval: z.number().min(30).max(3600).default(D.sync.autoSyncInterval),
     // 전체 대조 주기(초) — 그 사이의 pull 은 바뀐 페이지 · 행 · DB 만 받는다. 원격 삭제는 전체 대조가
@@ -3274,7 +3283,8 @@ var NotionClient2 = class _NotionClient {
         cover: db.cover ?? null,
         description: Array.isArray(db.description) ? db.description : [],
         showTitle: db.show_data_source_title !== false
-      }
+      },
+      ...db.in_trash === true || db.archived === true ? { inTrash: true } : {}
     };
     return { meta, owners };
   }
@@ -4943,8 +4953,72 @@ function pairLocalMoves(missing, untracked, hints) {
     paired.add(note.path);
     pairs.push({ from: note.path, to: file.path });
   }
+  const pairedTo = new Set(pairs.map((pair) => pair.to));
+  pairs.push(
+    ...pairSimilarContent(
+      missing.filter((note) => !paired.has(note.path)),
+      unmatched.filter((file) => !pairedTo.has(file.path))
+    )
+  );
   return pairs;
 }
+var SIMILAR_CONTENT_THRESHOLD = 0.6;
+var MIN_SIMILAR_WORDS = 8;
+function wordPairs(text) {
+  let body = text;
+  try {
+    body = splitFrontmatter(text).content;
+  } catch {
+  }
+  const words = body.split(/\s+/).filter((word) => word.length > 0);
+  if (words.length < MIN_SIMILAR_WORDS) return null;
+  const counts = /* @__PURE__ */ new Map();
+  for (let i = 1; i < words.length; i++) {
+    const key = `${words[i - 1]} ${words[i]}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function diceOf(a, b) {
+  let shared = 0;
+  let sizeA = 0;
+  let sizeB = 0;
+  for (const count of a.values()) sizeA += count;
+  for (const count of b.values()) sizeB += count;
+  for (const [key, count] of a) shared += Math.min(count, b.get(key) ?? 0);
+  return 2 * shared / (sizeA + sizeB);
+}
+function pairSimilarContent(missing, untracked) {
+  const files = untracked.map((file) => ({ file, pairs: file.text === void 0 ? null : wordPairs(file.text) })).filter((entry) => !!entry.pairs);
+  if (files.length === 0) return [];
+  const candidates = [];
+  for (const note of missing) {
+    const notePairs = note.text === void 0 ? null : wordPairs(note.text);
+    if (!notePairs) continue;
+    for (const { file, pairs } of files) {
+      const near = parentFolderOf(note.path) === parentFolderOf(file.path) || fileNameOf(note.path) === fileNameOf(file.path);
+      if (!near) continue;
+      const score = diceOf(notePairs, pairs);
+      if (score >= SIMILAR_CONTENT_THRESHOLD)
+        candidates.push({ from: note.path, to: file.path, score });
+    }
+  }
+  candidates.sort(
+    (a, b) => b.score - a.score || byPath({ path: a.from }, { path: b.from }) || byPath({ path: a.to }, { path: b.to })
+  );
+  const taken = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const candidate of candidates) {
+    if (taken.has(candidate.from) || taken.has(candidate.to)) continue;
+    const tied = candidates.some(
+      (other) => other !== candidate && other.score === candidate.score && (other.from === candidate.from || other.to === candidate.to) && !taken.has(other.from) && !taken.has(other.to)
+    );
+    taken.add(candidate.from);
+    taken.add(candidate.to);
+    if (!tied) result.push({ from: candidate.from, to: candidate.to });
+  }
+  return result;
+}
 function hintedFolderTarget(hints, folder) {
   let best = null;
   let ambiguous = false;
@@ -5042,10 +5116,16 @@ var ChangeDetector = class {
     for (const file of stats) {
       const record = this.stateDb.getByPath(file.path);
       const unchanged = hasRemotePage(record) && !this.movePending(record, moveOrigins) && record.localMtime === file.mtime && record.localFileSize === file.size;
+      if (unchanged) {
+        observed.push({ path: file.path, record, hash: null });
+        continue;
+      }
+      const text = await readFile3(file.path);
       observed.push({
         path: file.path,
         record,
-        hash: unchanged ? null : computeHash(await readFile3(file.path))
+        hash: computeHash(text),
+        ...record === null ? { text } : {}
       });
     }
     return this.assemble(observed, moveOrigins, options);
@@ -5055,7 +5135,12 @@ var ChangeDetector = class {
     const observed = currentFiles.map((file) => {
       const record = this.stateDb.getByPath(file.path);
       const unchanged = hasRemotePage(record) && !this.movePending(record, moveOrigins) && Boolean(record.localMtime) && record.localMtime === file.mtime;
-      return { path: file.path, record, hash: unchanged ? null : computeHash(file.content) };
+      return {
+        path: file.path,
+        record,
+        hash: unchanged ? null : computeHash(file.content),
+        ...record === null ? { text: file.content } : {}
+      };
     });
     return this.assemble(observed, moveOrigins, options);
   }
@@ -5073,7 +5158,13 @@ var ChangeDetector = class {
       const { record, hash } = file;
       if (!hasRemotePage(record)) {
         if (record === null) {
-          if (!isConflictCopyPath(file.path)) untracked.push({ path: file.path, hash });
+          if (!isConflictCopyPath(file.path)) {
+            untracked.push({
+              path: file.path,
+              hash,
+              ...file.text !== void 0 ? { text: file.text } : {}
+            });
+          }
         } else
           changes.push({
             path: file.path,
@@ -5110,7 +5201,8 @@ var ChangeDetector = class {
       missing.map((record) => ({
         path: record.obsidianPath,
         hash: record.contentHash,
-        origin: moveOrigins.get(record.id)
+        origin: moveOrigins.get(record.id),
+        ...record.baseSnapshot ? { text: record.baseSnapshot.toString("utf-8") } : {}
       })),
       untracked,
       options?.hints ?? EMPTY_RENAME_HINTS
@@ -5602,6 +5694,69 @@ function decodeMarkerTarget(encoded) {
 var MARKER_URL_CAPTURE = "((?:[^()\\s]|\\([^()]*\\))+)";
 var MARKER_LABEL_CAPTURE = "([^[\\]]+)";
 
+// src/converter/anchor-links.ts
+function splitAnchor(target) {
+  const at = target.indexOf("#");
+  if (at < 0) return null;
+  const anchor = target.slice(at + 1).trim();
+  return anchor === "" ? null : { note: target.slice(0, at).trim(), anchor };
+}
+function anchorDisplay(note, anchor) {
+  return [...note === "" ? [] : [note], ...anchor.split("#").map((s) => s.trim())].join(" > ");
+}
+function anchorTargetOfDisplay(text, notes, anchor) {
+  for (const note of notes) {
+    const prefix = note === "" ? "" : `${note} > `;
+    if (!text.startsWith(prefix)) continue;
+    const segments = text.slice(prefix.length).split(" > ");
+    const last = segments[segments.length - 1];
+    const same = anchor.startsWith("^") ? last === anchor : headingKey(last) === anchor;
+    if (same && segments.every((s) => s.trim() !== "")) return `${note}#${segments.join("#")}`;
+  }
+  return null;
+}
+var BLOCK_ID_SUFFIX_RE = /(?:^|\s)\^([A-Za-z0-9-]+)\s*$/;
+function headingKey(text) {
+  return text.replace(/[#|^:%[\]\\]/g, " ").replace(/\s+/g, " ").trim();
+}
+function anchorBlockId(blocks, anchor) {
+  if (anchor.startsWith("^")) {
+    const id = anchor.slice(1);
+    return blocks.find((b) => BLOCK_ID_SUFFIX_RE.exec(b.text)?.[1] === id)?.id ?? null;
+  }
+  const segments = anchor.split("#").map(headingKey);
+  let next = 0;
+  let found2 = null;
+  for (const block of blocks) {
+    if (!block.heading || headingKey(block.text) !== segments[next]) continue;
+    found2 = block.id;
+    if (++next === segments.length) return found2;
+  }
+  return null;
+}
+function anchorOfBlock(block) {
+  if (block.heading) return headingKey(block.text) || null;
+  const id = BLOCK_ID_SUFFIX_RE.exec(block.text)?.[1];
+  return id === void 0 ? null : `^${id}`;
+}
+function anchorBlockOf(block) {
+  const body = block[block.type];
+  return {
+    id: block.id,
+    heading: /^heading_[1-3]$/.test(block.type),
+    text: (body?.rich_text ?? []).map((t) => t.plain_text ?? "").join("")
+  };
+}
+var ANCHORED_WIKILINK_RE = /(?<!!)\[\[([^[\]|]*#[^[\]|]*?)\\?(?:\|[^[\]]+)?\]\]/g;
+function anchoredWikilinkTargets(markdown) {
+  return [...new Set([...markdown.matchAll(ANCHORED_WIKILINK_RE)].map((m) => m[1].trim()))].filter(
+    (target) => splitAnchor(target) !== null
+  );
+}
+function notionBlockUrl(pageId, blockId) {
+  return `https://www.notion.so/${compactNotionId(pageId)}#${compactNotionId(blockId)}`;
+}
+
 // src/converter/pre-processors/wikilink.ts
 var WIKILINK_REGEX2 = /(?<!!)\[\[([^[\]|]+)(?:\|([^[\]]+))?\]\]/g;
 function withoutTableAliasEscape(target) {
@@ -5626,6 +5781,8 @@ var WikilinkResolver = class {
         (_match, written, display, offset) => {
           const target = display === void 0 ? written : withoutTableAliasEscape(written);
           const label = display ?? target;
+          const anchored = this.anchorLink(target, display, input.context.anchors);
+          if (anchored) return anchored;
           if (this.resolve) {
             const entry = this.resolve(target);
             if (entry) {
@@ -5651,6 +5808,19 @@ var WikilinkResolver = class {
       metadata: { ...input.metadata, preserveMarkers }
     };
   }
+  /**
+   * `[[노트#제목]]` · `[[노트#^블록]]` · `[[#제목]]` → `[글자](https://www.notion.so/<페이지>#<블록>)`. 글자는 별칭,
+   * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 대상 페이지 · 블록을 못 찾으면 null.
+   */
+  anchorLink(target, display, anchors) {
+    const split = anchors ? splitAnchor(target) : null;
+    if (!anchors || !split) return null;
+    const pageId = split.note === "" ? anchors.selfPageId : this.resolve?.(split.note)?.notionPageId ?? null;
+    if (!pageId) return null;
+    const blockId = anchors.blockOf(pageId, split.anchor);
+    if (!blockId) return null;
+    return `[${display ?? anchorDisplay(split.note, split.anchor)}](${notionBlockUrl(pageId, blockId)})`;
+  }
 };
 
 // src/converter/callout-types.ts
@@ -12818,6 +12988,21 @@ function collectLocalMarkerBasenames(markdown) {
 function baseName(path) {
   return path.split("/").pop() ?? path;
 }
+function sha256Of(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+function localEmbedTargets(note) {
+  const targets = [...note.matchAll(/!\[\[([^\]\n]+)\]\]/g)].map((match) => match[1].trim());
+  for (const link of scanMarkdownLinks(note)) {
+    if (!link.isEmbed || /^[a-z][a-z0-9+.-]*:/i.test(link.url)) continue;
+    try {
+      targets.push(decodeURI(link.url));
+    } catch {
+      targets.push(link.url);
+    }
+  }
+  return targets;
+}
 function folderOf(notePath) {
   return notePath?.includes("/") ? notePath.slice(0, notePath.lastIndexOf("/")) : void 0;
 }
@@ -12953,8 +13138,9 @@ var ImageHandler = class {
    *
    * @param pageId 본문을 받은 페이지 — 그 페이지에 올린 것만 되찾는다
    * @param notePath 노트 경로 — 옛 캡션의 파일을 push 와 같은 사다리로 찾는다
+   * @param adoptFrom 상태 기록에 없던 같은 자리의 노트 글(P7 다시 잇기) — {@link adoptLocalEmbed}
    */
-  async restoreUploadedMedia(markdown, pageId, notePath) {
+  async restoreUploadedMedia(markdown, pageId, notePath, adoptFrom) {
     const spans = notionMediaSpans(markdown);
     if (spans.length === 0) return markdown;
     const known = pageId ? recallUploadedMedia(this.stateDb, pageId) : /* @__PURE__ */ new Map();
@@ -12962,11 +13148,51 @@ var ImageHandler = class {
     let result = markdown;
     for (const span of spans) {
       const uploadedName = this.uploadedNameOf(span.url);
-      const target = await this.knownEmbedTarget(known, span, uploadedName) ?? await this.resolveOriginalTarget(span.label, uploadedName, noteFolder);
+      const target = await this.knownEmbedTarget(known, span, uploadedName) ?? await this.resolveOriginalTarget(span.label, uploadedName, noteFolder) ?? (adoptFrom !== void 0 && pageId ? await this.adoptLocalEmbed(span, uploadedName, adoptFrom, noteFolder, pageId) : null);
       if (target) result = result.replace(span.full, () => `![[${target}]]`);
     }
     return result;
   }
+  /**
+   * 상태 DB 를 잃고 다시 잇는 노트(P7, ADR-049)의 미디어 — 올린 미디어 기록도 함께 잃어, push 가 올린 그림을 사본으로 받아
+   * 노트가 달라졌다(실측: `![[img/blue.png]]` → `![[attachments/blue-<해시>.png]]` 로 충돌). 받은 미디어의 이름과 바이트가
+   * 노트가 가리키는 볼트 파일과 같으면 그 임베드로 되살리고 받은 것으로 적는다 — 다음 push 가 그 블록을 둔다. 바이트를
+   * 견주므로 Notion 에서 같은 이름의 다른 파일로 바꾼 것은 되살리지 않는다. 받지 못하거나 다르면 null — 사본을 받는다.
+   */
+  async adoptLocalEmbed(span, uploadedName, local, noteFolder, pageId) {
+    if (!uploadedName || INTERNAL_FILE_URL_RE.test(span.url)) return null;
+    const targets = localEmbedTargets(local).filter(
+      (target) => baseName(stripAlias2(target)) === uploadedName
+    );
+    if (targets.length === 0) return null;
+    let remoteHash;
+    try {
+      const response = await this.fetchForDownload(span.url);
+      if (!response.ok) return null;
+      remoteHash = sha256Of(Buffer.from(await response.arrayBuffer()));
+    } catch {
+      return null;
+    }
+    for (const target of targets) {
+      for (const candidate of this.vaultCandidates(stripAlias2(target), noteFolder)) {
+        let localHash;
+        try {
+          localHash = sha256Of(await this.vaultFs.readBinary(candidate));
+        } catch {
+          continue;
+        }
+        if (localHash !== remoteHash) continue;
+        const fileId = notionFileIdOf(span.url);
+        if (fileId && this.stateDb) {
+          rememberReceivedMedia(this.stateDb, pageId, [
+            { fileId, target, localPath: candidate, fileHash: remoteHash }
+          ]);
+        }
+        return target;
+      }
+    }
+    return null;
+  }
   /** 적어 둔 업로드면 되살릴 임베드 대상. 볼트에서 그 파일이 사라졌으면 null — 사본을 받는다. */
   async knownEmbedTarget(known, span, uploadedName) {
     const fileId = notionFileIdOf(span.url);
@@ -14785,6 +15011,136 @@ async function readLocalNote(vaultFs, path) {
   }
 }
 
+// src/conflict/merger.ts
+function threeWayMerge(base, local, remote) {
+  const baseLines = base.split("\n");
+  const localLines = local.split("\n");
+  const remoteLines = remote.split("\n");
+  const hunks = [
+    ...computeHunks(baseLines, localLines, 0),
+    ...computeHunks(baseLines, remoteLines, 2)
+  ];
+  hunks.sort((a, b) => a.baseStart - b.baseStart || a.side - b.side);
+  const merged = [];
+  const conflicts = [];
+  let cursor = 0;
+  let i = 0;
+  while (i < hunks.length) {
+    const first = hunks[i];
+    if (first.baseStart > cursor) {
+      merged.push(...baseLines.slice(cursor, first.baseStart));
+    }
+    const regionStart = first.baseStart;
+    let regionEnd = first.baseEnd;
+    const group2 = [first];
+    i++;
+    while (i < hunks.length) {
+      const next = hunks[i];
+      const overlaps = next.baseStart < regionEnd || regionEnd === regionStart && next.baseStart === regionStart;
+      if (!overlaps) break;
+      regionEnd = Math.max(regionEnd, next.baseEnd);
+      group2.push(next);
+      i++;
+    }
+    const baseRegion = baseLines.slice(regionStart, regionEnd);
+    const localRegion = applyHunks(baseLines, group2, 0, regionStart, regionEnd);
+    const remoteRegion = applyHunks(baseLines, group2, 2, regionStart, regionEnd);
+    if (arraysEqual(localRegion, baseRegion)) {
+      merged.push(...remoteRegion);
+    } else if (arraysEqual(remoteRegion, baseRegion)) {
+      merged.push(...localRegion);
+    } else if (arraysEqual(localRegion, remoteRegion)) {
+      merged.push(...localRegion);
+    } else {
+      conflicts.push({ localLines: localRegion, remoteLines: remoteRegion });
+      merged.push("<<<<<<< LOCAL");
+      merged.push(...localRegion);
+      merged.push("=======");
+      merged.push(...remoteRegion);
+      merged.push(">>>>>>> REMOTE");
+    }
+    cursor = regionEnd;
+  }
+  if (cursor < baseLines.length) {
+    merged.push(...baseLines.slice(cursor));
+  }
+  return {
+    success: conflicts.length === 0,
+    merged: merged.join("\n"),
+    conflicts
+  };
+}
+function computeHunks(base, modified, side) {
+  const matches = lcsMatches(base, modified);
+  const hunks = [];
+  let prevBase = -1;
+  let prevMod = -1;
+  const emitGap = (curBase, curMod) => {
+    const baseLen = curBase - (prevBase + 1);
+    const modLen = curMod - (prevMod + 1);
+    if (baseLen > 0 || modLen > 0) {
+      hunks.push({
+        baseStart: prevBase + 1,
+        baseEnd: curBase,
+        content: modified.slice(prevMod + 1, curMod),
+        side
+      });
+    }
+  };
+  for (const [b, m] of matches) {
+    emitGap(b, m);
+    prevBase = b;
+    prevMod = m;
+  }
+  emitGap(base.length, modified.length);
+  return hunks;
+}
+function applyHunks(baseLines, group2, side, regionStart, regionEnd) {
+  const out = [];
+  let b = regionStart;
+  for (const hunk of group2) {
+    if (hunk.side !== side) continue;
+    if (hunk.baseStart > b) out.push(...baseLines.slice(b, hunk.baseStart));
+    out.push(...hunk.content);
+    b = hunk.baseEnd;
+  }
+  if (b < regionEnd) out.push(...baseLines.slice(b, regionEnd));
+  return out;
+}
+function lcsMatches(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = new Array(n + 1);
+  for (let i2 = 0; i2 <= n; i2++) dp[i2] = new Uint32Array(m + 1);
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    const row = dp[i2];
+    const next = dp[i2 + 1];
+    const ai = a[i2];
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      row[j2] = ai === b[j2] ? next[j2 + 1] + 1 : Math.max(next[j2], row[j2 + 1]);
+    }
+  }
+  const matches = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      matches.push([i, j]);
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return matches;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((val, idx) => val === b[idx]);
+}
+
 // src/sync/conflict-detector.ts
 function sameNoteContent(a, b) {
   return a === b || a.replace(/\n+$/, "") === b.replace(/\n+$/, "");
@@ -14812,6 +15168,10 @@ function resolvePullConflict(input) {
   if (strategy === "local-first") {
     return { action: "skip", localHash };
   }
+  if (strategy === "merge" && baseContent !== null) {
+    const result = threeWayMerge(baseContent, localContent, remoteContent);
+    if (result.success) return { action: "merge", merged: result.merged, localHash };
+  }
   const conflict = {
     syncRecord: record,
     localChange: {
@@ -14828,49 +15188,211 @@ function resolvePullConflict(input) {
   return { action: "conflict", conflict, localHash };
 }
 
-// src/sync/remote-deletion.ts
-async function remotePresence(client, pageId) {
-  let page;
-  try {
-    page = await client.getPage(pageId);
-  } catch (error) {
-    if (isNotionObjectNotFound(error)) return { kind: "gone" };
-    throw error;
-  }
-  return isTrashedOrArchived(page) ? { kind: "gone" } : { kind: "alive", page };
-}
-async function applyRemoteDeletion(stateDb, vaultFs, record, options) {
-  const decision = await decideRemoteDeletion(vaultFs, record, options);
-  if (decision.action === "kept") {
-    untrack(stateDb, record);
-    getLogger().info(
-      `[Im-Nobsidian] Notion \uC5D0\uC11C \uC9C0\uC6B4 ${record.obsidianPath} \uC5D0 \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uB85C\uCEEC \uD3B8\uC9D1\uC774 \uC788\uC5B4 \uD30C\uC77C\uC744 \uB460 \u2014 \uB2E4\uC74C push \uAC00 \uC0C8 \uD398\uC774\uC9C0\uB85C \uB9CC\uB4E0\uB2E4(local-first)`
-    );
-    return { action: "kept" };
-  }
-  if (decision.action === "conflict") {
-    stateDb.updateStatus(record.id, "conflict");
-    return {
-      action: "conflict",
-      conflict: remoteDeletionConflict(record, decision.local, options.remoteChange)
-    };
+// src/converter/notion-id-links.ts
+var NOTION_ID_WIKILINK_RE = /\[\[notion:([a-f0-9]{32}|[a-f0-9-]{36})(?:(\\?\|)([^[\]]+))?\]\]/g;
+var compactId = (id) => id.replace(/-/g, "");
+var PENDING_LINK_RE = new RegExp(
+  `${NOTION_ID_WIKILINK_RE.source}|\\b([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}|[a-f0-9]{32})\\b`,
+  "g"
+);
+function sameAsPendingLinks(local, remote) {
+  if (!PENDING_LINK_RE.test(remote)) return false;
+  PENDING_LINK_RE.lastIndex = 0;
+  const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let pattern = "";
+  let last = 0;
+  for (const match of remote.matchAll(PENDING_LINK_RE)) {
+    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]+\\))`;
+    last = match.index + match[0].length;
   }
-  await removeTrackedNote(stateDb, vaultFs, record, options.deleteFile);
-  return { action: "deleted" };
-}
-async function decideRemoteDeletion(vaultFs, record, options) {
-  const local = options.deleteFile ? await unsyncedLocalEdit(vaultFs, record) : null;
-  if (local === null || options.strategy === "remote-first") return { action: "deleted" };
-  return options.strategy === "local-first" ? { action: "kept" } : { action: "conflict", local };
+  pattern += escape(remote.slice(last).replace(/\n+$/, ""));
+  return new RegExp(`^${pattern}\\n*$`).test(local.replace(/\n+$/, ""));
 }
-async function removeTrackedNote(stateDb, vaultFs, record, deleteFile) {
-  if (deleteFile) {
-    try {
-      await vaultFs.deleteFile(record.obsidianPath);
-    } catch {
-    }
-  }
-  untrack(stateDb, record);
+function resolveNotionIdWikilinks(markdown, lookup) {
+  let resolved = 0;
+  const out = markdown.replace(
+    NOTION_ID_WIKILINK_RE,
+    (match, id, separator, rawAlias) => {
+      const path = lookup(id);
+      if (!path) return match;
+      resolved++;
+      const base = wikilinkTitleFromPath(path);
+      const alias = rawAlias === compactId(id) ? void 0 : rawAlias;
+      const link = formatWikilink(base, alias);
+      return separator === "\\|" ? link.replace("|", separator) : link;
+    }
+  );
+  return { markdown: out, resolved };
+}
+function degradeUnresolvedNotionIdWikilinks(markdown, titles = /* @__PURE__ */ new Map()) {
+  let degraded = 0;
+  const out = markdown.replace(
+    NOTION_ID_WIKILINK_RE,
+    (_match, id, _separator, alias) => {
+      degraded++;
+      const compact = compactId(id);
+      return `[${alias ?? (titles.get(compact) || compact)}](https://www.notion.so/${compact})`;
+    }
+  );
+  return { markdown: out, degraded };
+}
+function unlabeledNotionIds(markdown) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const m of markdown.matchAll(NOTION_ID_WIKILINK_RE)) {
+    if (m[3] === void 0) ids.add(compactId(m[1]));
+  }
+  return [...ids];
+}
+function linkLabelOfTitle(title) {
+  return title.replace(/[\r\n]+/g, " ").trim().replace(/\[/g, "(").replace(/\]/g, ")").replace(/[\\*_`~]/g, "\\$&");
+}
+var NOTION_RELATIVE_PAGE_LINK_RE = /\[([^\]]+)\]\(\/(?:p\/)?([a-f0-9]{32})(?:\?[^)#]*)?(?:#([^)]*))?\)/g;
+function resolveNotionRelativePageLinks(markdown, lookup) {
+  let resolved = 0;
+  const out = markdown.replace(NOTION_RELATIVE_PAGE_LINK_RE, (match, label, id) => {
+    const path = lookup(id);
+    if (!path) return match;
+    resolved++;
+    return formatWikilink(wikilinkTitleFromPath(path), label);
+  });
+  return { markdown: out, resolved };
+}
+function degradeUnresolvedNotionRelativePageLinks(markdown) {
+  let degraded = 0;
+  const out = markdown.replace(
+    NOTION_RELATIVE_PAGE_LINK_RE,
+    (_match, label, id, anchor) => {
+      degraded++;
+      return `[${label}](https://www.notion.so/${id}${anchor === void 0 ? "" : `#${anchor}`})`;
+    }
+  );
+  return { markdown: out, degraded };
+}
+var NOTION_BLOCK_LINK_RE = new RegExp(
+  `\\[${MARKER_LABEL_CAPTURE}\\]\\(https?:\\/\\/(?:www\\.|app\\.)?notion\\.(?:so|com)\\/(?:p\\/)?([a-f0-9]{32})#([a-f0-9]{32}|[a-f0-9-]{36})\\)`,
+  "g"
+);
+function noteForms(path, self) {
+  const parts = path.replace(/\.md$/i, "").split("/");
+  return [...parts.map((_, i) => parts.slice(i).join("/")), ...self ? [""] : []];
+}
+function notionBlockLinkIds(markdown, lookup) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const m of markdown.matchAll(NOTION_BLOCK_LINK_RE)) {
+    if (lookup(m[2])) ids.add(compactId(m[3]));
+  }
+  return [...ids];
+}
+function resolveNotionBlockLinks(markdown, lookup, anchorOf, selfPageId = null) {
+  let resolved = 0;
+  const self = selfPageId === null ? null : compactId(selfPageId);
+  const out = markdown.replace(
+    NOTION_BLOCK_LINK_RE,
+    (match, label, pageId, blockId, offset) => {
+      const path = lookup(pageId);
+      const anchor = anchorOf(compactId(blockId));
+      if (!path || !anchor) return match;
+      resolved++;
+      const note = compactId(pageId) === self ? "" : wikilinkTitleFromPath(path);
+      const text = label.replace(/\\([>^])/g, "$1");
+      const written = anchorTargetOfDisplay(text, noteForms(path, note === ""), anchor);
+      const link = written ? formatWikilink(written) : formatWikilink(`${note}#${anchor}`, text);
+      const line = markdown.slice(markdown.lastIndexOf("\n", offset) + 1, offset);
+      return line.trimStart().startsWith("|") ? link.replace("|", "\\|") : link;
+    }
+  );
+  return { markdown: out, resolved };
+}
+
+// src/sync/update-journal.ts
+var UpdateJournal = class {
+  constructor(stateDb) {
+    this.stateDb = stateDb;
+  }
+  stateDb;
+  /**
+   * 보내기 전에 적는다. 같은 노트의 끊긴 기록은 마친 것으로 돌린다 — 이번에 보내는 글이 그것을 대신한다.
+   * @param sentHash 보내는 노트 글의 해시(`computeHash(content)`).
+   */
+  begin(recordId, sentHash) {
+    this.finish(recordId);
+    this.stateDb.recordPendingOperation({
+      syncStateId: recordId,
+      operation: "update",
+      direction: "push",
+      payload: JSON.stringify({ hash: sentHash })
+    });
+  }
+  /** 상태 DB 에 적었다 — 끊긴 기록을 마친다. */
+  finish(recordId) {
+    for (const op of this.stateDb.getIncompletePendingOperations()) {
+      if (op.syncStateId === recordId && op.operation === "update") {
+        this.stateDb.markPendingCompleted(op.id);
+      }
+    }
+  }
+  /**
+   * 원격이 이 노트를 쓰다 끊긴 그대로인가.
+   * @param localHash 지금 노트 글의 해시 — 그때 보내던 글과 같아야 한다. 그 뒤 고쳤으면 끊긴 쓰기로 보지 않는다.
+   * @param botUserId 이 토큰의 봇 id. 모르면 가를 수 없어 아니다.
+   */
+  wroteRemote(record, remote, localHash, botUserId) {
+    if (botUserId === null || remote.last_edited_by?.id !== botUserId) return false;
+    const op = this.stateDb.getIncompleteOpByState(record.id, "update");
+    if (!op?.payload) return false;
+    try {
+      return JSON.parse(op.payload).hash === localHash;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/sync/remote-deletion.ts
+async function remotePresence(client, pageId) {
+  let page;
+  try {
+    page = await client.getPage(pageId);
+  } catch (error) {
+    if (isNotionObjectNotFound(error)) return { kind: "gone" };
+    throw error;
+  }
+  return isTrashedOrArchived(page) ? { kind: "gone" } : { kind: "alive", page };
+}
+async function applyRemoteDeletion(stateDb, vaultFs, record, options) {
+  const decision = await decideRemoteDeletion(vaultFs, record, options);
+  if (decision.action === "kept") {
+    untrack(stateDb, record);
+    getLogger().info(
+      `[Im-Nobsidian] Notion \uC5D0\uC11C \uC9C0\uC6B4 ${record.obsidianPath} \uC5D0 \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uB85C\uCEEC \uD3B8\uC9D1\uC774 \uC788\uC5B4 \uD30C\uC77C\uC744 \uB460 \u2014 \uB2E4\uC74C push \uAC00 \uC0C8 \uD398\uC774\uC9C0\uB85C \uB9CC\uB4E0\uB2E4(local-first)`
+    );
+    return { action: "kept" };
+  }
+  if (decision.action === "conflict") {
+    stateDb.updateStatus(record.id, "conflict");
+    return {
+      action: "conflict",
+      conflict: remoteDeletionConflict(record, decision.local, options.remoteChange)
+    };
+  }
+  await removeTrackedNote(stateDb, vaultFs, record, options.deleteFile);
+  return { action: "deleted" };
+}
+async function decideRemoteDeletion(vaultFs, record, options) {
+  const local = options.deleteFile ? await unsyncedLocalEdit(vaultFs, record) : null;
+  if (local === null || options.strategy === "remote-first") return { action: "deleted" };
+  return options.strategy === "local-first" ? { action: "kept" } : { action: "conflict", local };
+}
+async function removeTrackedNote(stateDb, vaultFs, record, deleteFile) {
+  if (deleteFile) {
+    try {
+      await vaultFs.deleteFile(record.obsidianPath);
+    } catch {
+    }
+  }
+  untrack(stateDb, record);
 }
 function untrack(stateDb, record) {
   stateDb.transaction(() => {
@@ -15090,6 +15612,12 @@ function isDirectDbRowPath(localFolder, path) {
   const rel = path.slice(prefix.length);
   return rel.length > 0 && !rel.includes("/");
 }
+function databaseFolderName(title) {
+  return truncateBytes(
+    title.replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-"),
+    FILE_SYSTEM_NAME_MAX_BYTES
+  );
+}
 
 // src/sync/discovered-databases.ts
 var ROOT_DATABASES_FOLDER = "databases";
@@ -15706,6 +16234,25 @@ var DbBaseFiles = class {
     this.loadedRaw = JSON.stringify(Object.fromEntries(entries));
     this.stateDb.setMeta(DB_BASE_FILES_META_KEY, this.loadedRaw);
   }
+  /** 기록을 지운다 — Notion 에서 지운 링크드 뷰. */
+  delete(databaseId) {
+    const entries = this.load();
+    if (!entries.delete(compactNotionId(databaseId))) return;
+    this.loadedRaw = JSON.stringify(Object.fromEntries(entries));
+    this.stateDb.setMeta(DB_BASE_FILES_META_KEY, this.loadedRaw);
+  }
+  /** 이 DB 를 원본으로 둔 링크드 뷰의 `.base` 경로. */
+  linkedBasesOf(databaseId) {
+    const owner = compactNotionId(databaseId);
+    return [...this.load().values()].filter((file) => file.linkedTo === owner).map((file) => file.basePath);
+  }
+  /** 이 경로에 쓴 링크드 뷰 컨테이너(줄인 id) — 없으면 null. */
+  linkedContainerAt(basePath) {
+    for (const [id, file] of this.load()) {
+      if (file.linkedTo && file.basePath === basePath) return id;
+    }
+    return null;
+  }
   /** 상태 메타에서 읽는다 — 값이 그대로면 읽어 둔 것을 쓴다. 없거나 깨졌으면 비어 있다 — 이번 실행이 기록하는 것부터 다시 쌓는다. */
   load() {
     const raw = this.stateDb.getMeta(DB_BASE_FILES_META_KEY);
@@ -15726,7 +16273,9 @@ var DbBaseFiles = class {
               title: entry.title,
               ...typeof entry.hash === "string" ? { hash: entry.hash } : {},
               ...Array.isArray(entry.views) ? { views: entry.views } : {},
-              ...typeof entry.rest === "string" ? { rest: entry.rest } : {}
+              ...typeof entry.rest === "string" ? { rest: entry.rest } : {},
+              ...typeof entry.docRest === "string" ? { docRest: entry.docRest } : {},
+              ...typeof entry.linkedTo === "string" ? { linkedTo: entry.linkedTo } : {}
             })
           );
         }
@@ -15742,7 +16291,9 @@ function normalize(info) {
     title: info.title,
     ...info.hash ? { hash: info.hash } : {},
     ...info.views && info.views.length > 0 ? { views: info.views } : {},
-    ...info.views && info.views.length > 0 && info.rest ? { rest: info.rest } : {}
+    ...info.views && info.views.length > 0 && info.rest ? { rest: info.rest } : {},
+    ...info.views && info.views.length > 0 && info.docRest ? { docRest: info.docRest } : {},
+    ...info.linkedTo ? { linkedTo: info.linkedTo } : {}
   };
 }
 
@@ -15808,8 +16359,22 @@ function matchViews(records, views) {
   });
   return out;
 }
+var without = (from, keys) => Object.fromEntries(Object.entries(from).filter(([key]) => !keys.includes(key)));
+function viewRestOf(view) {
+  return computeHash(canonical(without(view, PUSHABLE_KEYS)));
+}
+function docRestOf(parsed) {
+  return computeHash(canonical(without(parsed.doc, ["views"])));
+}
+function restUnchanged(parsed, matched, base) {
+  const records = base.views ?? [];
+  if (base.docRest === void 0 || records.some((record) => record.rest === void 0)) {
+    return matched.filter(Boolean).length === records.length && restSignature(parsed, matched) === base.rest;
+  }
+  if (docRestOf(parsed) !== base.docRest) return false;
+  return parsed.views.every((view, i) => !matched[i] || viewRestOf(view) === matched[i].rest);
+}
 function restSignature(parsed, matched) {
-  const without = (from, keys) => Object.fromEntries(Object.entries(from).filter(([key]) => !keys.includes(key)));
   const views = {};
   parsed.views.forEach((view, i) => {
     const key = matched[i] ? `id:${matched[i].viewId}` : `new:${String(view["name"])}`;
@@ -15841,10 +16406,11 @@ function recordBaseViews(content, written, views) {
       type: String(parsed.views[i]["type"]),
       ...pushableOf(parsed.views[i]),
       ...source.lossyFilter ? { lossyFilter: true } : {},
-      notion: viewFingerprint(view)
+      notion: viewFingerprint(view),
+      rest: viewRestOf(parsed.views[i])
     });
   }
-  return { views: records, rest: restSignature(parsed, records) };
+  return { views: records, rest: restSignature(parsed, records), docRest: docRestOf(parsed) };
 }
 function canonical(value) {
   return JSON.stringify(sortKeys3(value)) ?? "null";
@@ -16091,6 +16657,7 @@ var SidecarSchemaEdits = class {
         hash,
         properties,
         payload: diff.payload,
+        ...diff.staged ? { staged: diff.staged, optionRenames: diff.optionRenames } : {},
         edit: { path: base.path, ...diff.edit },
         seen: this.ledger.get(databaseId) ? null : seenSchemaOf(meta)
       });
@@ -16104,6 +16671,12 @@ var SidecarSchemaEdits = class {
       if (edit.seen) this.ledger.set(edit.databaseId, edit.seen);
       let after;
       try {
+        if (edit.staged) {
+          await this.notionClient.updateDataSourceProperties(edit.dataSourceId, edit.staged);
+          for (const rename2 of edit.optionRenames ?? []) {
+            await this.moveOptionValues(edit.databaseId, rename2);
+          }
+        }
         after = await this.notionClient.updateDataSourceProperties(edit.dataSourceId, edit.payload);
       } catch (error) {
         failed.push({
@@ -16125,6 +16698,30 @@ var SidecarSchemaEdits = class {
     }
     return { applied, failed };
   }
+  /**
+   * 옛 옵션 값을 가진 Notion 행을 새 이름으로 옮긴다. 중간에 멈추면 두 이름이 다 남는다 — 사이드카 기록을 고치지 않아
+   * 다음 push 가 같은 이름 바꾸기를 다시 해 남은 행을 마저 옮긴다.
+   */
+  async moveOptionValues(databaseId, rename2) {
+    const { propertyId, type, from, to } = rename2;
+    const filter = type === "select" ? { property: propertyId, select: { equals: from } } : { property: propertyId, multi_select: { contains: from } };
+    const rows = await this.notionClient.queryAllDatabasePages(databaseId, filter);
+    for (const row of rows) {
+      let value;
+      if (type === "select") {
+        value = { name: to };
+      } else {
+        const current = Object.values(row.properties).find(
+          (prop) => prop?.id === propertyId
+        );
+        const names = (current?.multi_select ?? []).map(
+          (option) => option.name === from ? to : option.name ?? ""
+        );
+        value = [...new Set(names.filter((name) => name.length > 0))].map((name) => ({ name }));
+      }
+      await this.notionClient.updatePageProperties(row.id, { [propertyId]: { [type]: value } });
+    }
+  }
 };
 function sidecarPropertiesEdited(content, base) {
   let parsed;
@@ -16159,9 +16756,12 @@ function diffSidecarProperties(base, edited) {
     removed: [],
     renamed: [],
     retyped: [],
-    redefined: []
+    redefined: [],
+    renamedOptions: []
   };
   const droppedOptions = [];
+  const optionRenames = [];
+  const staged = {};
   const names = /* @__PURE__ */ new Set();
   const seenIds = /* @__PURE__ */ new Set();
   for (const prop of edited) {
@@ -16196,10 +16796,35 @@ function diffSidecarProperties(base, edited) {
           `\u300C${prop.name}\u300D(${prop.type}) \uC758 \uC124\uC815\uC740 \uC0AC\uC774\uB4DC\uCE74\uC5D0\uC11C \uBC14\uAFC0 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. Notion \uC5D0\uC11C \uBC14\uAFB8\uC138\uC694`
         );
       }
-      change[prop.type] = definitionOf(prop, old);
       edit.redefined.push(prop.name);
-      const dropped = (old.options ?? []).filter((name) => !(prop.options ?? []).includes(name));
+      const isSelect = prop.type === "select" || prop.type === "multi_select";
+      const before = isSelect ? optionNamesOf(old) : [];
+      const after = isSelect ? sentOptionNamesOf(prop, old) : [];
+      const renames = renamedOptions(before, after);
+      change[prop.type] = definitionOf(prop, old, renames);
+      const dropped = before.filter(
+        (name) => !after.includes(name) && !renames.some(([from]) => from === name)
+      );
       if (dropped.length > 0) droppedOptions.push([prop.name, dropped]);
+      if (renames.length > 0) {
+        const type = prop.type;
+        const final = change[type]?.options ?? [];
+        const known = old.definition?.["options"] ?? [];
+        staged[old.id] = {
+          ...change,
+          [type]: {
+            ...change[type],
+            options: [
+              ...final,
+              ...renames.map(([from]) => known.find((o) => o.name === from) ?? { name: from })
+            ]
+          }
+        };
+        for (const [from, to] of renames) {
+          optionRenames.push({ propertyId: old.id, type, from, to });
+          edit.renamedOptions.push([prop.name, from, to]);
+        }
+      }
     }
     if (Object.keys(change).length > 0) payload[old.id] = change;
   }
@@ -16213,19 +16838,50 @@ function diffSidecarProperties(base, edited) {
   if (kept >= 2 && edit.removed.length === kept && edit.added.length === 0) {
     return fail("\uC81C\uBAA9 \uB9D0\uACE0 \uBAA8\uB4E0 \uC18D\uC131\uC744 \uC9C0\uC6B0\uB294 \uAC83\uC740 \uBC1B\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 \u2014 \uC815\uB9D0\uC774\uBA74 Notion \uC5D0\uC11C \uC9C0\uC6B0\uC138\uC694");
   }
+  const { renamedOptions: renamedOptionList, ...rest } = edit;
   return {
     ok: true,
     payload,
-    edit: droppedOptions.length > 0 ? { ...edit, droppedOptions } : edit
+    // 먼저 보낼 것 — 옵션 이름을 바꾼 속성만 새 이름 · 옛 이름을 함께, 나머지는 마지막 것과 같다.
+    ...optionRenames.length > 0 ? { staged: { ...payload, ...staged }, optionRenames } : {},
+    edit: {
+      ...rest,
+      ...droppedOptions.length > 0 ? { droppedOptions } : {},
+      ...renamedOptionList.length > 0 ? { renamedOptions: renamedOptionList } : {}
+    }
   };
 }
-function definitionOf(prop, old) {
+function optionNamesOf(prop) {
+  if (prop.options) return [...prop.options];
+  const options = prop.definition?.["options"];
+  return Array.isArray(options) ? options.map((o) => o.name).filter((n) => typeof n === "string") : [];
+}
+function sentOptionNamesOf(prop, old) {
+  if (sameJson(prop.definition, old.definition)) return [...prop.options ?? []];
+  return optionNamesOf({ ...prop, options: void 0 });
+}
+function renamedOptions(before, after) {
+  const renames = [];
+  for (let i = 0; i < Math.min(before.length, after.length); i++) {
+    const from = before[i];
+    const to = after[i];
+    if (from !== to && !after.includes(from) && !before.includes(to)) renames.push([from, to]);
+  }
+  return renames;
+}
+function definitionOf(prop, old, renames = []) {
   if (!DEFINABLE_TYPES.has(prop.type)) return {};
   const definition = prop.definition ?? {};
   if (old && (prop.type === "select" || prop.type === "multi_select") && sameJson(prop.definition, old.definition) && !sameJson(prop.options, old.options)) {
     const known = old.definition?.["options"] ?? [];
+    const renamedFrom = new Map(renames.map(([from, to]) => [to, from]));
     return {
-      options: (prop.options ?? []).map((name) => known.find((o) => o.name === name) ?? { name })
+      options: (prop.options ?? []).map((name) => {
+        const from = renamedFrom.get(name);
+        if (from === void 0) return known.find((o) => o.name === name) ?? { name };
+        const color = known.find((o) => o.name === from)?.color;
+        return color === void 0 ? { name } : { name, color };
+      })
     };
   }
   return definition;
@@ -17534,12 +18190,60 @@ function rewriteCreatedDatabaseFolders(stateDb, folders) {
 async function retargetBaseFiles(vaultFs, moves, stateDb) {
   const folders = moves.filter((move) => !isMarkdownPath(move.from));
   if (folders.length === 0) return;
+  const found2 = [];
   await rewriteBaseFilters(
     vaultFs,
     stateDb,
     (folder) => finalPath(folder, folders),
-    "\uC62E\uAE34 \uD3F4\uB354\uB97C \uAC00\uB9AC\uD0A4\uB358 .base \uBCF4\uAE30\uB97C \uACE0\uCE58\uC9C0 \uBABB\uD568"
+    "\uC62E\uAE34 \uD3F4\uB354\uB97C \uAC00\uB9AC\uD0A4\uB358 .base \uBCF4\uAE30\uB97C \uACE0\uCE58\uC9C0 \uBABB\uD568",
+    (fix) => found2.push(fix)
   );
+  if (!stateDb) return;
+  const pending = pendingUserBaseFilterFixes(stateDb).map((fix) => ({
+    path: finalPath(fix.path, folders),
+    from: fix.from,
+    to: finalPath(fix.to, folders)
+  }));
+  for (const fix of found2) {
+    if (!pending.some((p) => p.path === fix.path && p.from === fix.from)) pending.push(fix);
+  }
+  const asks = pending.filter((fix) => fix.from !== fix.to);
+  stateDb.setMeta(USER_BASE_FILTER_FIXES_META_KEY, asks.length > 0 ? JSON.stringify(asks) : "");
+}
+var USER_BASE_FILTER_FIXES_META_KEY = "user_base_filter_fixes";
+function pendingUserBaseFilterFixes(stateDb) {
+  try {
+    const parsed = JSON.parse(stateDb.getMeta(USER_BASE_FILTER_FIXES_META_KEY) || "[]");
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (fix) => typeof fix?.path === "string" && typeof fix.from === "string" && typeof fix.to === "string"
+    );
+  } catch {
+    return [];
+  }
+}
+async function resolveUserBaseFilterFixes(vaultFs, stateDb, accept) {
+  const fixes = pendingUserBaseFilterFixes(stateDb);
+  stateDb.setMeta(USER_BASE_FILTER_FIXES_META_KEY, "");
+  if (!accept) return [];
+  const fixed = [];
+  for (const path of [...new Set(fixes.map((fix) => fix.path))]) {
+    const content = await vaultFs.readFile(path).catch(() => null);
+    if (content === null) continue;
+    const next = content.replace(
+      FOLDER_FILTER_RE,
+      (whole, legacy, current) => {
+        const folder = legacy ?? current;
+        const fix = fixes.find((f) => f.path === path && f.from === folder);
+        if (!fix) return whole;
+        return legacy !== void 0 ? `file.inFolder("${fix.to}")` : folderFilter(fix.to);
+      }
+    );
+    if (next === content) continue;
+    await vaultFs.writeFile(path, next);
+    fixed.push(path);
+  }
+  return fixed;
 }
 var BASE_FOLDER_FILTER_UPGRADED_META_KEY = "base_folder_filter_v2";
 async function upgradeBaseFolderFilters(vaultFs, stateDb) {
@@ -17552,7 +18256,7 @@ async function upgradeBaseFolderFilters(vaultFs, stateDb) {
   );
   if (done) stateDb.setMeta(BASE_FOLDER_FILTER_UPGRADED_META_KEY, "1");
 }
-async function rewriteBaseFilters(vaultFs, stateDb, retarget, failure) {
+async function rewriteBaseFilters(vaultFs, stateDb, retarget, failure, onUserBase) {
   const rehashed = /* @__PURE__ */ new Map();
   const viewed = stateDb ? recordedViewBases(stateDb) : /* @__PURE__ */ new Set();
   let done = true;
@@ -17560,7 +18264,16 @@ async function rewriteBaseFilters(vaultFs, stateDb, retarget, failure) {
     for (const file of await vaultFs.listNonMarkdownFiles()) {
       if (!file.path.endsWith(BASE_SUFFIX)) continue;
       const content = await vaultFs.readFile(file.path);
-      if (!isGeneratedDbArtifact(file.path, content) && !viewed.has(file.path)) continue;
+      if (!isGeneratedDbArtifact(file.path, content) && !viewed.has(file.path)) {
+        if (onUserBase) {
+          for (const match of content.matchAll(FOLDER_FILTER_RE)) {
+            const from = match[1] ?? match[2];
+            const to = retarget(from);
+            if (to !== from) onUserBase({ path: file.path, from, to });
+          }
+        }
+        continue;
+      }
       const next = content.replace(
         FOLDER_FILTER_RE,
         (whole, legacy, current) => {
@@ -17949,7 +18662,7 @@ function compareRemote(record, page, botUserId) {
     return "changed";
   }
   if (isSettled(record.notionLastEdited, record.notionSeenAt)) return "unchanged";
-  if (botUserId !== null && editor === botUserId && record.notionLastEditedBy === botUserId) {
+  if (botUserId !== null && editor === botUserId && record.notionLastEditedBy === botUserId && (record.notionBodyFingerprint === null || record.baseSnapshot === null)) {
     return "unchanged";
   }
   return "unverified";
@@ -18152,6 +18865,7 @@ var DatabaseSyncer = class {
     this.observation = observation;
     this.noteRowBody = noteRowBody;
     this.baseFileInfo = new DbBaseFiles(stateDb);
+    this.journal = new UpdateJournal(stateDb);
     this.sidecarBases = new SidecarBases(stateDb);
     this.schemaLedger = new SchemaLedger(stateDb);
     this.relocator = new NoteRelocator(stateDb, vaultFs, config.notion.databases ?? []);
@@ -18193,6 +18907,19 @@ var DatabaseSyncer = class {
   };
   /** 볼트에서 사라져 되살린 행의 경로 — pull 마감이 가져가 화면에 알린다(D8). */
   restoredRows = [];
+  /** 쓰다 끊긴 행을 알아본다 — {@link UpdateJournal}. */
+  journal;
+  /** merge 전략이 받은 행에 로컬 편집을 합친 행 — {@link takeMergedRows}. */
+  mergedRows = [];
+  /** 상태 기록에 없던 같은 자리의 행 노트를 다시 이은 것(P7) — {@link takeRelinkedRows}. */
+  relinkedRows = [];
+  /**
+   * 이번 pull 을 시작할 때 Notion 과 이은 노트가 하나도 없었다 — 그때는 자연 이름에 있는 행 노트의 글이 달라도 다시
+   * 잇는다({@link relinkExistingRow}). 오케스트레이터가 pull 을 시작할 때 정한다({@link beginPull}).
+   */
+  unlinkedVault = false;
+  /** 이번 pull 에서 다시 이으려고 고른 행 노트 경로 — 같은 이름의 두 행이 한 노트를 고르지 않게. */
+  relinkClaims = /* @__PURE__ */ new Set();
   /** Notion 에서 바뀐 속성을 행 노트에 옮긴 것 — pull 마감이 가져가 화면에 알린다(ADR-045). */
   schemaFollowed = [];
   /** pull 이 마지막으로 쓴 사이드카 — 볼트에서 고친 것은 덮어쓰지 않는다(ADR-045). */
@@ -18201,6 +18928,10 @@ var DatabaseSyncer = class {
   heldSidecars = /* @__PURE__ */ new Set();
   /** 이번 pull 이 볼트에서 고친 것이라 덮어쓰지 않은 `.base` 경로(ADR-046). */
   heldBases = /* @__PURE__ */ new Set();
+  /** 이번 pull 이 치운 링크드 뷰의 `.base`({@link takeRetiredBases}). */
+  retiredBases = /* @__PURE__ */ new Set();
+  /** 이번 실행에서 받은 DB(줄인 id)의 기간 날짜 짝 키 — 그 DB 를 원본으로 둔 링크드 뷰의 `.base` 도 같게 쓴다. */
+  rangeEnds = /* @__PURE__ */ new Map();
   /**
    * 실제로 기록한 .base 경로/DB 제목 — placeholder 임베드 재작성(F22)의 SSOT. 이번 pull 이 조회하지
    * 않은 DB 의 것도 남아 있다({@link DbBaseFiles}).
@@ -18270,10 +19001,6 @@ var DatabaseSyncer = class {
       }
     }
     if (target.kind === "linked") {
-      if (target.wholeDbInScope) {
-        const viewsConfig = await this.pullDatabaseViews(dbConfig);
-        await this.generateBaseFile(dbConfig, viewsConfig, target.meta, target.ownerFolder);
-      }
       return { ...emptyDatabaseSyncResult(), linkedOriginalDbId: target.ownerDbId };
     }
     const { pages, wholeDbInScope, meta } = target;
@@ -18284,7 +19011,9 @@ var DatabaseSyncer = class {
     const refreshedKeys = (page) => followed.changes.get(sourceKeyOf(page, dbConfig.databaseId))?.refreshed;
     if (wholeDbInScope) {
       const viewsConfig = await this.pullDatabaseViews(dbConfig);
-      await this.generateBaseFile(dbConfig, viewsConfig, meta, void 0, this.rangeEndsOf(pages));
+      const rangeEnds = this.rangeEndsOf(pages);
+      this.rangeEnds.set(compactNotionId(dbConfig.databaseId), rangeEnds);
+      await this.generateBaseFile(dbConfig, viewsConfig, meta, void 0, rangeEnds);
     }
     let created = 0;
     let updated = followed.rekeyed.size;
@@ -18332,7 +19061,11 @@ var DatabaseSyncer = class {
           this.config.advanced.itemTimeoutMs,
           `pull ${dbConfig.localFolder}/${page.id}`
         );
-        if (!record) {
+        if (!record && outcome.relinked) {
+          this.relinkedRows.push(outcome.path);
+          if (outcome.action === "written") writtenPaths.push(outcome.path);
+          else if (outcome.action === "conflict") conflicts.push(outcome.conflict);
+        } else if (!record) {
           created++;
           if (outcome.action === "written") writtenPaths.push(outcome.path);
         } else if (outcome.action === "written") {
@@ -18341,12 +19074,19 @@ var DatabaseSyncer = class {
             this.restoredRows.push(outcome.path);
           } else if (!followed.rekeyed.has(record.id)) updated++;
           writtenPaths.push(outcome.path);
+        } else if (outcome.action === "merged") {
+          updated++;
+          this.mergedRows.push(outcome.path);
         } else if (outcome.action === "conflict") {
           conflicts.push(outcome.conflict);
         }
         opts?.progress?.done({
           path: outcome.path ?? record?.obsidianPath ?? `${dbConfig.localFolder}/${page.id}`,
-          operation: record ? "update" : "create"
+          operation: record ? "update" : "create",
+          // 받아 보니 그대로 · local-first 가 지킨 행은 받은 것이 아니다 — 페이지와 같다. 같은 분 봇 쓰기 뒤에는 행을
+          // 다시 읽어 견주므로(ADR-017 보강) 바뀌지 않은 행이 «updated» 로 찍혔다(0.15 회귀). 다시 이은 행은 쓴 것이
+          // 없으면 만든 것이 아니다(P7).
+          ...outcome.action === "unchanged" || outcome.action === "skipped" || !record && outcome.relinked && outcome.action !== "written" ? { unchanged: true } : {}
         });
       } catch (error) {
         failed.push(rowFailure(page, error));
@@ -18406,6 +19146,72 @@ var DatabaseSyncer = class {
       ...planned.map((row) => ({ ...row, path: moved(row.path) }))
     ];
   }
+  /**
+   * 받은 행이 지난 사본 그대로인가 — 렌더한 글이 달라도 받을 것이 없으면 그 사이 로컬 편집을 충돌로 올리지 않는다
+   * (N-05). 본문은 지문으로, 본문 밖은 지난 사본의 속성과 견준다. 이 도구가 이 행을 쓰다 끊긴 원격도 받을 것이
+   * 없다 — push 가 마저 올린다({@link UpdateJournal}).
+   */
+  rowRemoteUnchanged(record, page, bodyFingerprint, localContent) {
+    const base = snapshotFrontmatter(record.baseSnapshot);
+    return base !== null && bodyFingerprint === record.notionBodyFingerprint && this.rowOutsideBodyUnchanged(this.propertyMapper, page, base, record.obsidianPath) || this.journal.wroteRemote(
+      record,
+      page,
+      computeHash(localContent),
+      this.observation().botUserId
+    );
+  }
+  /**
+   * dry-run 이 알릴, 로컬도 고친 행을 실제 pull 이 어떻게 처리할지 — 받은 행과 견주는 판정은 실제 pull 과 같다.
+   * 첨부를 내려받지 않고 렌더하며 상태 DB 를 바꾸지 않는다. 로컬을 고치지 않았거나 읽지 못하면 null(받는다).
+   */
+  async previewRowResolution(record, page) {
+    let localContent;
+    try {
+      localContent = await this.vaultFs.readFile(record.obsidianPath);
+    } catch {
+      return null;
+    }
+    if (computeHash(localContent) === record.contentHash) return null;
+    const rendered = await this.renderRow(page, record.obsidianPath, { downloadMedia: false });
+    const resolution = resolvePullConflict({
+      record,
+      localContent,
+      remoteContent: rendered.content,
+      remoteUnchanged: this.rowRemoteUnchanged(
+        record,
+        page,
+        rendered.bodyFingerprint,
+        localContent
+      ),
+      remoteChange: {
+        pageId: page.id,
+        type: "modified",
+        lastEdited: page.last_edited_time,
+        previousEdited: record.notionLastEdited
+      },
+      strategy: this.config.sync.conflictStrategy
+    });
+    if (resolution.action === "conflict")
+      return { action: "conflict", conflict: resolution.conflict };
+    return resolution.action === "write" ? null : { action: resolution.action };
+  }
+  /**
+   * 수정 시각 · 편집자로 가르지 못한 행이 지난 사본 그대로인가 — 본문 지문과 본문 밖 속성으로({@link rowRemoteUnchanged}).
+   * dry-run 이 실제 pull 처럼 받을 것이 없는 행을 세지 않게. 견줄 사본 · 지문이 없거나 본문을 읽지 못하면 아니다.
+   */
+  async unverifiedRowUnchanged(record, page) {
+    if (this.remoteVerdict(record, page) !== "unverified") return false;
+    const base = snapshotFrontmatter(record.baseSnapshot);
+    if (base === null || record.notionBodyFingerprint === null) return false;
+    try {
+      const fingerprint = remoteBodyFingerprint(
+        (await this.notionClient.getPageMarkdown(page.id)).markdown
+      );
+      return fingerprint === record.notionBodyFingerprint && this.rowOutsideBodyUnchanged(this.propertyMapper, page, base, record.obsidianPath);
+    } catch {
+      return false;
+    }
+  }
   async planRows(dbConfig, target, paths, movingInVault = /* @__PURE__ */ new Set()) {
     const opts = { paths };
     const planned = [];
@@ -18451,11 +19257,18 @@ var DatabaseSyncer = class {
           moves: [{ from: record.obsidianPath, to: path }, ...children ? [children] : []]
         });
       } else {
+        if (action === "pull" && await this.unverifiedRowUnchanged(record, page)) continue;
+        const retitle = await this.retitledRowTarget(dbConfig.localFolder, record, page);
+        const renamed = retitle && "to" in retitle ? retitle : null;
+        const resolution = action === "restore" ? null : await this.previewRowResolution(record, page);
         planned.push({
           pageId: page.id,
-          path: record.obsidianPath,
+          path: renamed?.to ?? record.obsidianPath,
           operation: "update",
-          restore: action === "restore"
+          restore: action === "restore",
+          ...resolution ? { resolution } : {},
+          // 실제 pull 이 알리는 것과 같게 행만 — 하위 페이지 폴더는 함께 옮기지만 따로 알리지 않는다.
+          ...renamed ? { moves: [{ from: record.obsidianPath, to: renamed.to, renamed: true }] } : {}
         });
       }
     }
@@ -18547,6 +19360,9 @@ var DatabaseSyncer = class {
     const changed = misplaced || this.remoteVerdict(record, page) !== "unchanged";
     if (!changed && await this.staleKeysToRewrite(record, page, refreshed)) return "reform";
     if (this.config.sync.deleteSync || await this.vaultFs.exists(record.obsidianPath)) {
+      if (changed && !misplaced && this.config.sync.deleteSync && !await this.vaultFs.exists(record.obsidianPath) && await this.unverifiedRowUnchanged(record, page)) {
+        return "skip";
+      }
       return changed ? "pull" : "skip";
     }
     return "restore";
@@ -18795,10 +19611,10 @@ var DatabaseSyncer = class {
     }
     return ends;
   }
-  async generateBaseFile(dbConfig, viewsConfig, meta, rowsFolder, rangeEnds) {
+  async generateBaseFile(dbConfig, viewsConfig, meta, rowsFolder, rangeEnds, linked) {
     try {
       const schemaFull = await this.notionClient.getDatabaseSchemaFull(dbConfig.databaseId, meta);
-      const dbName = viewsConfig?.databaseName || await this.notionClient.getDatabaseTitle(dbConfig.databaseId, meta) || dbConfig.localFolder.split("/").pop() || "Database";
+      const dbName = linked?.name || viewsConfig?.databaseName || await this.notionClient.getDatabaseTitle(dbConfig.databaseId, meta) || dbConfig.localFolder.split("/").pop() || "Database";
       const resolvedViews = viewsConfig ?? {
         databaseId: dbConfig.databaseId,
         databaseName: dbName,
@@ -18823,11 +19639,12 @@ var DatabaseSyncer = class {
         title: dbName,
         hash: computeHash(baseContent),
         // Notion 보기를 받지 못해 기본 표 하나를 쓴 파일은 올릴 보기가 없다.
-        ...viewsConfig ? recordBaseViews(baseContent, generated.views, viewsConfig.views) : null
+        ...viewsConfig ? recordBaseViews(baseContent, generated.views, viewsConfig.views) : null,
+        ...linked ? { linkedTo: compactNotionId(linked.ownerId) } : null
       };
       const ours = existing === null || isGeneratedDbArtifact(basePath, existing) || previous?.basePath === basePath && previous.views !== void 0;
       if (!ours) {
-        record = { basePath, title: dbName, hash: record.hash };
+        record = { basePath, title: dbName, hash: record.hash, linkedTo: record.linkedTo };
         if (!this.keptUserBases.has(basePath)) {
           this.keptUserBases.add(basePath);
           getLogger().info(
@@ -18842,6 +19659,15 @@ var DatabaseSyncer = class {
       }
       this.baseFileInfo.set(dbConfig.databaseId, record);
       getLogger().debug(`[DB Sync] .base \uD30C\uC77C \uC0DD\uC131: ${basePath}`);
+      if (linked) {
+        if (previous && previous.basePath !== basePath) {
+          await this.removeLinkedBase(previous);
+          if (!await this.vaultFs.exists(previous.basePath) && await this.vaultFs.exists(basePath)) {
+            this.renamedRows.applied.push({ from: previous.basePath, to: basePath });
+          }
+        }
+        return;
+      }
       await this.generateSidecar(
         dbConfig,
         dbName,
@@ -18851,7 +19677,15 @@ var DatabaseSyncer = class {
         meta.isInline,
         await this.appearanceOf(meta, safeName)
       );
-      await this.cleanupStaleDbArtifacts(dbConfig.localFolder, safeName, previous);
+      await this.cleanupStaleDbArtifacts(
+        dbConfig.databaseId,
+        dbConfig.localFolder,
+        safeName,
+        previous
+      );
+      if (previous && previous.basePath !== basePath && !await this.vaultFs.exists(previous.basePath) && await this.vaultFs.exists(basePath)) {
+        this.renamedRows.applied.push({ from: previous.basePath, to: basePath });
+      }
     } catch (error) {
       getLogger().warn(`[DB Sync] .base \uD30C\uC77C \uC0DD\uC131 \uC2E4\uD328 (\uACC4\uC18D \uC9C4\uD589):`, error);
     }
@@ -18883,13 +19717,87 @@ var DatabaseSyncer = class {
       ...a.showTitle ? {} : { showTitle: false }
     };
   }
+  /**
+   * 링크드 뷰 컨테이너의 `.base` 를 그 컨테이너의 보기(이름 · 필터 · 정렬)로 원본 DB 폴더에 쓴다. 행은 원본 DB 가
+   * 갖는다(F25) — 폴더 필터도 원본 폴더를 가리킨다. 예전에는 링크드 뷰를 원본의 `.base` 로 몰아, 링크드 뷰가 고른
+   * 보기가 볼트에 오지 않았다.
+   *
+   * 이름은 Notion 이 그 블록 위에 보이는 것처럼 「원본 제목 - 첫 보기 이름」 이다. 컨테이너 제목은 비어 온다.
+   *
+   * @returns `gone` — Notion 에서 컨테이너를 지웠다. 쓴 `.base` 를 치웠으니 부른 쪽이 연결을 잊는다.
+   *   `failed` — 읽지 못했다. 쓴 `.base` 는 그대로 두고 다음 pull 이 다시 본다.
+   */
+  async pullLinkedView(containerId, owner) {
+    let meta;
+    try {
+      meta = await this.notionClient.getDatabaseMeta(containerId);
+    } catch (error) {
+      if (isNotionObjectNotFound(error)) {
+        await this.retireLinkedView(containerId);
+        return "gone";
+      }
+      getLogger().warn(
+        `[DB Sync] \uB9C1\uD06C\uB4DC \uBDF0 ${containerId} \uB97C \uC77D\uC9C0 \uBABB\uD568 (\uB2E4\uC74C pull \uC774 \uB2E4\uC2DC \uBD04):`,
+        error
+      );
+      return "failed";
+    }
+    if (meta.inTrash) {
+      await this.retireLinkedView(containerId);
+      return "gone";
+    }
+    const container = { ...owner, databaseId: containerId };
+    const views = await this.pullDatabaseViews(container);
+    if (!views || views.views.length === 0) return "failed";
+    await this.generateBaseFile(
+      container,
+      views,
+      meta,
+      owner.localFolder,
+      this.rangeEnds.get(compactNotionId(owner.databaseId)),
+      { ownerId: owner.databaseId, name: this.linkedBaseName(containerId, owner, views) }
+    );
+    return "written";
+  }
+  /** 링크드 뷰 `.base` 의 이름 — 같은 폴더의 다른 `.base` 가 쓰는 이름이면 컨테이너 id 앞 네 자리를 붙인다. */
+  linkedBaseName(containerId, owner, views) {
+    const ownerTitle = this.baseFileInfo.get(owner.databaseId)?.title || owner.localFolder.split("/").pop() || "Database";
+    const name = `${ownerTitle} - ${views.views[0]?.name || "View"}`;
+    const self = compactNotionId(containerId);
+    const taken = new Set(
+      this.baseFileInfo.all().filter(([id]) => id !== self).map(([, file]) => file.basePath)
+    );
+    return taken.has(`${owner.localFolder}/${sanitizeFileName(name)}${BASE_SUFFIX}`) ? `${name} (${self.slice(0, 4)})` : name;
+  }
+  /** Notion 에서 지운 링크드 뷰 — 쓴 `.base` 를 치우고 기록을 잊는다. */
+  async retireLinkedView(containerId) {
+    const record = this.baseFileInfo.get(containerId);
+    if (!record) return;
+    if (await this.removeLinkedBase(record)) this.retiredBases.add(record.basePath);
+    this.baseFileInfo.delete(containerId);
+    getLogger().info(`[DB Sync] Notion \uC5D0\uC11C \uC9C0\uC6B4 \uB9C1\uD06C\uB4DC \uBDF0\uC758 .base \uB97C \uCE58\uC6C0: ${record.basePath}`);
+  }
+  /**
+   * pull 이 쓴 그대로인 링크드 뷰 `.base` 를 지운다 — 볼트에서 고쳤으면 두고 알린다.
+   * @returns 지웠나.
+   */
+  async removeLinkedBase(record) {
+    const content = await this.vaultFs.readFile(record.basePath).catch(() => null);
+    if (content === null || !isGeneratedDbArtifact(record.basePath, content)) return false;
+    if (editedSince(record, record.basePath, content)) {
+      this.warnEditedBase(record.basePath);
+      return false;
+    }
+    await this.vaultFs.deleteFile(record.basePath);
+    return true;
+  }
   /** 볼트에서 고친 `.base` 를 덮어쓰거나 지우지 않았다고 한 번 알린다. */
   warnEditedBase(path) {
     this.heldBases.add(path);
     if (this.keptUserBases.has(path)) return;
     this.keptUserBases.add(path);
     getLogger().warn(
-      `[DB Sync] \uBCFC\uD2B8\uC5D0\uC11C \uACE0\uCE5C .base \uB77C Notion \uBCF4\uAE30\uB85C \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC74C: ${path} \u2014 push \uD558\uBA74 \uACE0\uCE5C \uBCF4\uAE30 \uC774\uB984 \xB7 \uC5F4 \xB7 \uC815\uB82C \xB7 \uD544\uD130\uB97C Notion \uC5D0 \uC62C\uB9BD\uB2C8\uB2E4. Notion \uC758 \uBCF4\uAE30\uB97C \uB2E4\uC2DC \uBC1B\uC73C\uB824\uBA74 \uC774 \uD30C\uC77C\uC744 \uC9C0\uC6B0\uC138\uC694`
+      `[DB Sync] \uBCFC\uD2B8\uC5D0\uC11C \uACE0\uCE5C .base \uB77C Notion \uBCF4\uAE30\uB85C \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC74C: ${path} \u2014 push \uD558\uBA74 \uACE0\uCE5C \uBCF4\uAE30 \uC774\uB984 \xB7 \uC5F4 \xB7 \uC815\uB82C \xB7 \uD544\uD130\uC640 \uB354\uD558\uACE0 \uC9C0\uC6B4 \uBCF4\uAE30\uB97C Notion \uC5D0 \uC62C\uB9BD\uB2C8\uB2E4. Notion \uC758 \uBCF4\uAE30\uB97C \uB2E4\uC2DC \uBC1B\uC73C\uB824\uBA74 \uC774 \uD30C\uC77C\uC744 \uC9C0\uC6B0\uC138\uC694`
     );
   }
   /**
@@ -18897,11 +19805,13 @@ var DatabaseSyncer = class {
    * 같은 폴더에 고아로 잔존한다(drift·부활 원인). DB 폴더 **직속**의 산출물 중 현재 이름이
    * 아닌 것을 삭제해 멱등을 보장한다. 하위 폴더(중첩 DB)의 산출물은 보호한다.
    */
-  async cleanupStaleDbArtifacts(localFolder, safeName, previous) {
+  async cleanupStaleDbArtifacts(databaseId, localFolder, safeName, previous) {
     try {
       const keep = /* @__PURE__ */ new Set([
         `${localFolder}/${safeName}${BASE_SUFFIX}`,
-        `${localFolder}/${safeName}${SIDECAR_SUFFIX}`
+        `${localFolder}/${safeName}${SIDECAR_SUFFIX}`,
+        // 이 DB 를 원본으로 둔 링크드 뷰의 `.base` — 같은 폴더에 놓인다.
+        ...this.baseFileInfo.linkedBasesOf(databaseId)
       ]);
       const files = await this.vaultFs.listNonMarkdownFiles();
       const stale = selectStaleDbArtifacts(files, localFolder, keep);
@@ -19035,7 +19945,12 @@ var DatabaseSyncer = class {
     const bodyFingerprint = remoteBodyFingerprint(mdResult.markdown);
     const exportCompact = isCompactExport(mdResult.markdown);
     let markdown = await notionBodyToObsidian(this.notionClient, mdResult.markdown, page.id);
-    markdown = await this.imageHandler.restoreUploadedMedia(markdown, page.id, filePath);
+    markdown = await this.imageHandler.restoreUploadedMedia(
+      markdown,
+      page.id,
+      filePath,
+      options?.adoptFrom
+    );
     if (downloadMedia && this.config.conversion.imageDownload === "immediate" && markdown) {
       try {
         const imageResult = await this.imageHandler.downloadAllImages(markdown, title, page.id);
@@ -19117,6 +20032,105 @@ var DatabaseSyncer = class {
     this.restoredRows = [];
     return rows;
   }
+  /** pull 을 시작한다 — 이은 노트가 하나도 없는 볼트인지 적고 다시 잇기 장부를 비운다. */
+  beginPull(unlinkedVault) {
+    this.unlinkedVault = unlinkedVault;
+    this.relinkClaims.clear();
+  }
+  /** 이번 받기에서 다시 이은 행의 경로를 가져가고 비운다. */
+  takeRelinkedRows() {
+    const rows = this.relinkedRows;
+    this.relinkedRows = [];
+    return rows;
+  }
+  /**
+   * 상태 기록에 없는 행 노트가 이 행이 놓일 자리에 이미 있다 — 이 행 id 를 단 이름이 먼저, 그 다음 자연 이름. 페이지의
+   * `claimExistingNote` 와 같은 규칙이다.
+   */
+  async claimExistingRow(localFolder, safeName, pageId) {
+    const [natural, ...suffixed] = pagePathCandidates(localFolder, safeName, pageId);
+    const order = [
+      ...suffixed.map((path) => [path, "own"]),
+      [natural, "name"]
+    ];
+    for (const [candidate, existing] of order) {
+      if (this.relinkClaims.has(candidate) || this.stateDb.getByPath(candidate)) continue;
+      if (!await this.vaultFs.exists(candidate)) continue;
+      this.relinkClaims.add(candidate);
+      return { path: candidate, existing };
+    }
+    return null;
+  }
+  /**
+   * 상태 기록에 없던 행 노트를 이 행과 다시 잇는다(P7) — 페이지의 `relinkExistingNote` 와 같은 규칙. 글이 같으면 잇고, 다르면
+   * 이 행 id 를 단 이름은 충돌 전략을 따르고 · 자연 이름은 이은 노트가 없는 볼트에서만 충돌로 잇는다. 잇지 않으면 null.
+   * remote-first 는 `"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 stat2 = same ? await this.vaultFs.getFileStat(filePath) : null;
+    this.stateDb.transaction(() => {
+      this.stateDb.upsert({
+        obsidianPath: filePath,
+        notionPageId: page.id,
+        notionParentId: dbConfig.databaseId,
+        // 같으면 로컬 글로 적어 바뀐 것이 없게 · local-first 는 받은 글로 적어 다음 push 가 로컬을 올리게.
+        contentHash: computeHash(same ? local : finalContent),
+        ...observedRecordFields(page, this.observation().seenAt, bodyFingerprint),
+        localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+        syncDirection: "both",
+        fileType: "db-row",
+        status: conflicted ? "conflict" : "synced",
+        // 충돌로 이으면 공통 조상을 모른다 — merge 도 합치지 않는다.
+        baseSnapshot: conflicted ? null : Buffer.from(finalContent, "utf-8"),
+        localMtime: stat2?.mtime ?? null,
+        localFileSize: stat2?.size ?? null
+      });
+      this.stateDb.upsertWikilink({
+        obsidianPath: filePath,
+        notionPageId: page.id,
+        title: rendered.title,
+        aliases: extractAliases(rendered.properties)
+      });
+    });
+    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: {
+          pageId: page.id,
+          type: "modified",
+          lastEdited: page.last_edited_time,
+          previousEdited: null,
+          path: filePath,
+          title: rendered.title
+        },
+        baseContent: null,
+        localContent: local,
+        remoteContent: finalContent
+      }
+    };
+  }
+  /** 이번 받기에서 로컬 편집을 합친 행의 경로를 가져가고 비운다. */
+  takeMergedRows() {
+    const rows = this.mergedRows;
+    this.mergedRows = [];
+    return rows;
+  }
   /**
    * Notion 에서 다른 페이지 아래로 옮긴 DB 의 폴더를 볼트에서도 옮긴다 — 옮겼으면 그 이동. 옮기지 못하면 까닭을 남기고
    * 옛 자리에서 받는다.
@@ -19130,7 +20144,7 @@ var DatabaseSyncer = class {
     this.renamedRows.renamed.push(move);
     this.renamedRows.applied.push(move);
     getLogger().info(
-      `[Im-Nobsidian] Notion \uC5D0\uC11C \uC62E\uAE34 DB \uC758 \uD3F4\uB354\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uC62E\uAE40: ${move.from} \u2192 ${move.to}`
+      `[Im-Nobsidian] Notion \uC5D0\uC11C ${move.renamed ? "\uC774\uB984\uC744 \uBC14\uAFBC" : "\uC62E\uAE34"} DB \uC758 \uD3F4\uB354\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uC62E\uAE40: ${move.from} \u2192 ${move.to}`
     );
     return move;
   }
@@ -19139,7 +20153,7 @@ var DatabaseSyncer = class {
     if (!outcome) return null;
     if ("reason" in outcome) {
       getLogger().warn(
-        `[Im-Nobsidian] Notion \uC5D0\uC11C \uC62E\uAE34 DB \uC758 \uD3F4\uB354\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uC62E\uAE30\uC9C0 \uC54A\uC74C (${outcome.path}): ${outcome.reason}`
+        `[Im-Nobsidian] Notion \uC5D0\uC11C \uC62E\uAE30\uAC70\uB098 \uC774\uB984\uC744 \uBC14\uAFBC DB \uC758 \uD3F4\uB354\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uC62E\uAE30\uC9C0 \uC54A\uC74C (${outcome.path}): ${outcome.reason}`
       );
       return null;
     }
@@ -19151,18 +20165,17 @@ var DatabaseSyncer = class {
     return movingInVault.has(record.id) || this.stateDb.getIncompleteOpByState(record.id, "move") !== null;
   }
   /**
-   * Notion 에서 다른 페이지 아래로 옮긴 발견 DB 의 폴더를 옮길 곳(ADR-047) — 제자리면 null.
+   * Notion 에서 다른 페이지 아래로 옮기거나 이름을 바꾼 발견 DB 의 폴더를 옮길 곳(ADR-047 · {@link retitledFolderName})
+   * — 제자리면 null.
    *
    * Notion 에서 DB 를 옮겨도 DB · 행의 수정 시각이 그대로라 받은 DB 의 부모로만 안다 — 전체 대조는 모든 DB 를 받으니
    * 거기서 보인다. 새 자리는 처음 발견할 때와 같다 — 부모 페이지의 하위 폴더 이름 그대로, 루트면 `databases` 선반.
    * 맨 위 폴더도 루트 아래로 본다(볼트에서 옮긴 DB 를 push 가 루트 아래에 둔다 — {@link DatabaseMover}).
    * 다음은 옮기지 않는다.
-   *   - 부모가 블록(토글 · 열) 안 · 볼트가 모르는 페이지 — 볼트에 그 자리가 없다
+   *   - 부모가 블록(토글 · 열) 안 · 볼트가 모르는 페이지 — 볼트에 그 자리가 없다(이름만 따른다)
    *   - 볼트에서 옮긴 DB 폴더 · 부모 노트를 아직 올리지 않았다 — 볼트가 먼저다(push 가 Notion 을 옮긴다)
    */
   placementMoveOf(dbConfig, meta, movingInVault = /* @__PURE__ */ new Set()) {
-    const parentId = meta.parentPageId;
-    if (!parentId) return null;
     const id = dbConfig.databaseId;
     if ((this.config.notion.databases ?? []).some((db) => notionIdsEqual(db.databaseId, id))) {
       return null;
@@ -19171,23 +20184,52 @@ var DatabaseSyncer = class {
       return null;
     }
     const folder = dbConfig.localFolder;
-    let places;
-    if (notionIdsEqual(parentId, this.config.notion.rootPageId)) {
-      places = [ROOT_DATABASES_FOLDER, ""];
-    } else {
-      const parent = this.stateDb.getByNotionId(parentId);
-      if (!parent) return null;
-      if (this.movedInVault(parent, movingInVault)) {
-        return {
-          path: folder,
-          reason: "\uBCFC\uD2B8\uC5D0\uC11C \uC62E\uAE34 \uBD80\uBAA8 \uB178\uD2B8\uB97C \uC544\uC9C1 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uB2E4 \u2014 \uB2E4\uC74C push \uAC00 Notion \uC744 \uB9DE\uCD98\uB2E4"
-        };
+    const current = parentFolderOf(folder);
+    let place = current;
+    const parentId = meta.parentPageId;
+    if (parentId) {
+      let places = null;
+      if (notionIdsEqual(parentId, this.config.notion.rootPageId)) {
+        places = [ROOT_DATABASES_FOLDER, ""];
+      } else {
+        const parent = this.stateDb.getByNotionId(parentId);
+        if (parent && this.movedInVault(parent, movingInVault)) {
+          return {
+            path: folder,
+            reason: "\uBCFC\uD2B8\uC5D0\uC11C \uC62E\uAE34 \uBD80\uBAA8 \uB178\uD2B8\uB97C \uC544\uC9C1 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uB2E4 \u2014 \uB2E4\uC74C push \uAC00 Notion \uC744 \uB9DE\uCD98\uB2E4"
+          };
+        }
+        if (parent) {
+          places = [childFolderOf(parent, { databaseAt: (path) => this.databaseAt(path) })];
+          if (isFolderRecord(parent)) places.push(parent.obsidianPath);
+        }
       }
-      places = [childFolderOf(parent, { databaseAt: (path) => this.databaseAt(path) })];
-      if (isFolderRecord(parent)) places.push(parent.obsidianPath);
+      if (places && !places.includes(current)) place = places[0];
     }
-    if (places.includes(parentFolderOf(folder))) return null;
-    return { from: folder, to: joinPath(places[0], baseName2(folder)) };
+    const renamed = this.retitledFolderName(folder, dbConfig.databaseId, meta.title);
+    const to = renamed === null ? joinPath(place, baseName2(folder)) : resolveDbFolderPath(joinPath(place, renamed), id, (path) => this.databaseAt(path));
+    if (to === folder) return null;
+    return { from: folder, to, ...renamed !== null ? { renamed: true } : {} };
+  }
+  /**
+   * Notion 에서 바꾼 DB 제목을 따른 폴더 이름(`sync.renameOnTitleChange`) — 바꿀 것이 없으면 null.
+   *
+   * 지난번에 받은 제목({@link DbBaseFiles})과 달라졌고, 폴더 이름이 그 옛 제목을 따르고 있을 때만 — 폴더를 만든 규칙
+   * (`databaseFolderName`) 이나 `.base` 이름 규칙(`sanitizeFileName`, 볼트에서 바꿔 올린 이름) 그대로일 때다. 사용자가
+   * 따로 정한 이름이면 두고, 새 이름도 지금 이름과 같은 규칙으로 짓는다. 같은 이름 DB 와 가르려 붙인 ` (id 조각)` 은
+   * 떼고 견준다(F24) — 새 자리에서 다시 가른다.
+   */
+  retitledFolderName(folder, databaseId, title) {
+    if (!this.config.sync.renameOnTitleChange || !title) return null;
+    const previous = this.baseFileInfo.get(databaseId)?.title;
+    if (!previous || previous === title) return null;
+    const name = baseName2(folder).replace(/ \([0-9a-f]{8,32}\)$/, "");
+    for (const style of [databaseFolderName, sanitizeFileName]) {
+      if (style(previous) !== name) continue;
+      const next = style(title);
+      return next && next !== name ? next : null;
+    }
+    return null;
   }
   /** 이 폴더가 받는 DB — 설정한 DB 와 발견한 DB 에서. */
   databaseAt(folder) {
@@ -19198,6 +20240,12 @@ var DatabaseSyncer = class {
     return all.find((db) => db.localFolder === folder)?.databaseId ?? null;
   }
   /** 이름을 바꾼 행을 가져가고 비운다. */
+  /** 이번 pull 이 Notion 에서 지운 링크드 뷰라 치운 `.base` — 그것을 넣은 노트의 임베드를 뺀다({@link LinkUpdater.dropEmbeds}). */
+  takeRetiredBases() {
+    const paths = [...this.retiredBases];
+    this.retiredBases.clear();
+    return paths;
+  }
   takeRenamedRows() {
     const rows = this.renamedRows;
     this.renamedRows = { renamed: [], applied: [] };
@@ -19212,43 +20260,60 @@ var DatabaseSyncer = class {
     const hasChildren = this.stateDb.getAll().some((r) => r.id !== record.id && within(r.obsidianPath, from));
     return hasChildren ? { from, to: stripMarkdownExtension(rowPath) } : null;
   }
+  /**
+   * Notion 에서 바꾼 제목으로 행 이름을 바꿀 자리(`sync.renameOnTitleChange`) — 바꿀 것이 없으면 null.
+   * 받기 · pull dry-run · status 가 같은 판정을 쓴다. 행의 하위 페이지 폴더(`행/`)도 새 이름으로 옮기며, 옮길 수
+   * 없으면 이름을 바꾸지 않는다(예전처럼 제목만 받는다) — 그 까닭을 돌려준다.
+   */
+  async retitledRowTarget(localFolder, record, page) {
+    const recordPath = record.obsidianPath;
+    const title = this.notionClient.extractTitle(page);
+    if (!this.config.sync.renameOnTitleChange || !isDirectDbRowPath(localFolder, recordPath) || !retitledInNotion(snapshotFrontmatter(record.baseSnapshot), null, recordPath, title) || this.stateDb.getIncompleteOpByState(record.id, "move")) {
+      return null;
+    }
+    const safeName = sanitizeFileName(title);
+    const to = resolveDbRowPath(
+      localFolder,
+      safeName,
+      page.id,
+      await this.rowPathOwners(localFolder, safeName, page.id)
+    );
+    if (to === recordPath) return null;
+    const from = stripMarkdownExtension(recordPath);
+    if (!this.stateDb.getAll().some((r) => within(r.obsidianPath, from))) {
+      return { to, children: null };
+    }
+    const children = { from, to: stripMarkdownExtension(to) };
+    const blocked = await this.relocator.blocked(children);
+    return blocked ? { reason: `\uD558\uC704 \uD398\uC774\uC9C0 \uD3F4\uB354 \u2014 ${blocked}` } : { to, children };
+  }
   async pullDatabasePage(page, dbConfig) {
     const safeName = sanitizeFileName(this.notionClient.extractTitle(page));
     const existingRecord = this.stateDb.getByNotionId(page.id);
     const recordPath = existingRecord?.obsidianPath;
+    const retitle = existingRecord && recordPath ? await this.retitledRowTarget(dbConfig.localFolder, existingRecord, page) : null;
     let filePath;
-    const retitled = !!existingRecord && !!recordPath && this.config.sync.renameOnTitleChange && isDirectDbRowPath(dbConfig.localFolder, recordPath) && retitledInNotion(
-      snapshotFrontmatter(existingRecord.baseSnapshot),
-      null,
-      recordPath,
-      this.notionClient.extractTitle(page)
-    ) && !this.stateDb.getIncompleteOpByState(existingRecord.id, "move");
-    if (recordPath && isDirectDbRowPath(dbConfig.localFolder, recordPath) && !retitled) {
+    let childFolderMove = null;
+    let adopt = null;
+    if (retitle && "to" in retitle) {
+      filePath = retitle.to;
+      childFolderMove = retitle.children;
+    } else if (recordPath && isDirectDbRowPath(dbConfig.localFolder, recordPath)) {
       filePath = recordPath;
     } else {
-      filePath = resolveDbRowPath(
+      filePath = (!existingRecord ? (adopt = await this.claimExistingRow(dbConfig.localFolder, safeName, page.id))?.path : void 0) ?? resolveDbRowPath(
         dbConfig.localFolder,
         safeName,
         page.id,
         await this.rowPathOwners(dbConfig.localFolder, safeName, page.id)
       );
     }
-    let childFolderMove = null;
-    if (retitled) {
-      const from = stripMarkdownExtension(recordPath);
-      if (this.stateDb.getAll().some((r) => within(r.obsidianPath, from))) {
-        childFolderMove = { from, to: stripMarkdownExtension(filePath) };
-        const blocked = await this.relocator.blocked(childFolderMove);
-        if (blocked) {
-          getLogger().warn(
-            `[Im-Nobsidian] Notion \uC5D0\uC11C \uBC14\uAFBC \uC81C\uBAA9\uC73C\uB85C \uD589 \uC774\uB984\uC744 \uBC14\uAFB8\uC9C0 \uC54A\uC74C (${recordPath}): \uD558\uC704 \uD398\uC774\uC9C0 \uD3F4\uB354 \u2014 ${blocked}`
-          );
-          filePath = recordPath;
-          childFolderMove = null;
-        }
-      }
+    if (retitle && "reason" in retitle) {
+      getLogger().warn(
+        `[Im-Nobsidian] Notion \uC5D0\uC11C \uBC14\uAFBC \uC81C\uBAA9\uC73C\uB85C \uD589 \uC774\uB984\uC744 \uBC14\uAFB8\uC9C0 \uC54A\uC74C (${recordPath}): ${retitle.reason}`
+      );
     }
-    const renaming = retitled && filePath !== recordPath;
+    const renaming = retitle !== null && "to" in retitle;
     const becomesRow = !!existingRecord && !!recordPath && wasPage(existingRecord);
     const arrives = becomesRow || !!existingRecord && !!recordPath && arrivesFromOtherDatabase(existingRecord, dbConfig);
     if (arrives && recordPath && this.stateDb.getIncompleteOpByState(existingRecord.id, "move")) {
@@ -19271,10 +20336,39 @@ var DatabaseSyncer = class {
         emptiedFolder = parentFolderOf(recordPath);
       }
     }
-    const rendered = await this.renderRow(page, filePath, { localPath: recordPath ?? filePath });
+    const local = adopt ? await readLocalNote(this.vaultFs, filePath) : void 0;
+    let rendered = await this.renderRow(page, filePath, {
+      localPath: recordPath ?? filePath,
+      ...local !== void 0 ? { adoptFrom: local } : {}
+    });
+    let relinked = false;
+    if (adopt) {
+      const outcome = local === void 0 ? null : await this.relinkExistingRow(
+        filePath,
+        adopt.existing,
+        local,
+        rendered.content,
+        page,
+        dbConfig,
+        rendered,
+        rendered.bodyFingerprint
+      );
+      if (outcome === "write") relinked = true;
+      else if (outcome) return outcome;
+      else {
+        filePath = resolveDbRowPath(
+          dbConfig.localFolder,
+          safeName,
+          page.id,
+          await this.rowPathOwners(dbConfig.localFolder, safeName, page.id)
+        );
+        rendered = await this.renderRow(page, filePath, { localPath: filePath });
+      }
+    }
     const { title, properties, bodyFingerprint } = rendered;
     const finalContent = becomesRow ? keepPageValues(rendered.content, await readLocalNote(this.vaultFs, recordPath)) : rendered.content;
     const seenAt = this.observation().seenAt;
+    let merged = null;
     if (existingRecord) {
       let localContent = "";
       let localExists = true;
@@ -19285,8 +20379,7 @@ var DatabaseSyncer = class {
         localContent = "";
         localExists = await this.vaultFs.exists(readPath);
       }
-      const base = snapshotFrontmatter(existingRecord.baseSnapshot);
-      const remoteUnchanged = localExists && base !== null && bodyFingerprint === existingRecord.notionBodyFingerprint && this.rowOutsideBodyUnchanged(this.propertyMapper, page, base, existingRecord.obsidianPath);
+      const remoteUnchanged = localExists && this.rowRemoteUnchanged(existingRecord, page, bodyFingerprint, localContent);
       const resolution = resolvePullConflict({
         record: existingRecord,
         localContent,
@@ -19337,9 +20430,10 @@ var DatabaseSyncer = class {
         });
         return { action: "unchanged", path: filePath };
       }
+      if (resolution.action === "merge") merged = resolution.merged;
     }
     await this.vaultFs.ensureFolder(dbConfig.localFolder);
-    await this.vaultFs.writeFile(filePath, finalContent);
+    await this.vaultFs.writeFile(filePath, merged ?? finalContent);
     const rehomed = existingRecord && recordPath && recordPath !== filePath;
     const outOfStep = becomesRow && (rendered.propertiesBlock || !this.rowOutsideBodyUnchanged(
       this.propertyMapper,
@@ -19370,9 +20464,9 @@ var DatabaseSyncer = class {
         fileType: "db-row",
         status: "synced",
         baseSnapshot: Buffer.from(finalContent, "utf-8"),
-        // 비운 해시를 변경 확인이 보게 — stat 이 맞으면 내용을 읽지 않는다(B5).
-        localMtime: outOfStep ? null : stat2?.mtime ?? null,
-        localFileSize: outOfStep ? null : stat2?.size ?? null,
+        // 비운 해시 · 합친 글을 변경 확인이 보게 — stat 이 맞으면 내용을 읽지 않는다(B5).
+        localMtime: outOfStep || merged !== null ? null : stat2?.mtime ?? null,
+        localFileSize: outOfStep || merged !== null ? null : stat2?.size ?? null,
         // 빈 해시와 함께 — push 가 지난 사본 대신 원격의 지금 값과 견줘 다른 속성을 모두 보낸다(overwritesRemote).
         ...outOfStep ? { notionBodyFingerprint: null } : {}
       });
@@ -19410,7 +20504,7 @@ var DatabaseSyncer = class {
         );
       }
     }
-    return { action: "written", path: filePath };
+    return merged !== null ? { action: "merged", path: filePath } : { action: "written", path: filePath, ...relinked ? { relinked: true } : {} };
   }
 };
 function arrivesFromOtherDatabase(record, dbConfig) {
@@ -19549,160 +20643,30 @@ function folderOf3(record) {
   if (record.fileType === "db-row") return null;
   if (isFolderRecord(record)) return record.obsidianPath;
   const slash = record.obsidianPath.lastIndexOf("/");
-  if (slash < 0) return null;
-  const folder = record.obsidianPath.slice(0, slash);
-  const stem = stripMarkdownExtension(record.obsidianPath.slice(slash + 1)).replace(ID_SUFFIX, "");
-  return stem === folder.slice(folder.lastIndexOf("/") + 1) ? folder : null;
-}
-function findNestedFolderPages(records) {
-  const byPage = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    if (record.notionPageId !== null) byPage.set(compactNotionId(record.notionPageId), record);
-  }
-  const found2 = [];
-  for (const inner of records) {
-    if (inner.notionPageId === null || inner.notionParentId === null) continue;
-    const folder = folderOf3(inner);
-    if (folder === null) continue;
-    const outer = byPage.get(compactNotionId(inner.notionParentId));
-    if (!outer || outer === inner || folderOf3(outer) !== folder) continue;
-    found2.push({
-      folder,
-      outer: { path: outer.obsidianPath, notionPageId: outer.notionPageId },
-      inner: { path: inner.obsidianPath, notionPageId: inner.notionPageId }
-    });
-  }
-  return found2.sort((a, b) => a.folder < b.folder ? -1 : a.folder > b.folder ? 1 : 0);
-}
-
-// src/conflict/merger.ts
-function threeWayMerge(base, local, remote) {
-  const baseLines = base.split("\n");
-  const localLines = local.split("\n");
-  const remoteLines = remote.split("\n");
-  const hunks = [
-    ...computeHunks(baseLines, localLines, 0),
-    ...computeHunks(baseLines, remoteLines, 2)
-  ];
-  hunks.sort((a, b) => a.baseStart - b.baseStart || a.side - b.side);
-  const merged = [];
-  const conflicts = [];
-  let cursor = 0;
-  let i = 0;
-  while (i < hunks.length) {
-    const first = hunks[i];
-    if (first.baseStart > cursor) {
-      merged.push(...baseLines.slice(cursor, first.baseStart));
-    }
-    const regionStart = first.baseStart;
-    let regionEnd = first.baseEnd;
-    const group2 = [first];
-    i++;
-    while (i < hunks.length) {
-      const next = hunks[i];
-      const overlaps = next.baseStart < regionEnd || regionEnd === regionStart && next.baseStart === regionStart;
-      if (!overlaps) break;
-      regionEnd = Math.max(regionEnd, next.baseEnd);
-      group2.push(next);
-      i++;
-    }
-    const baseRegion = baseLines.slice(regionStart, regionEnd);
-    const localRegion = applyHunks(baseLines, group2, 0, regionStart, regionEnd);
-    const remoteRegion = applyHunks(baseLines, group2, 2, regionStart, regionEnd);
-    if (arraysEqual(localRegion, baseRegion)) {
-      merged.push(...remoteRegion);
-    } else if (arraysEqual(remoteRegion, baseRegion)) {
-      merged.push(...localRegion);
-    } else if (arraysEqual(localRegion, remoteRegion)) {
-      merged.push(...localRegion);
-    } else {
-      conflicts.push({ localLines: localRegion, remoteLines: remoteRegion });
-      merged.push("<<<<<<< LOCAL");
-      merged.push(...localRegion);
-      merged.push("=======");
-      merged.push(...remoteRegion);
-      merged.push(">>>>>>> REMOTE");
-    }
-    cursor = regionEnd;
-  }
-  if (cursor < baseLines.length) {
-    merged.push(...baseLines.slice(cursor));
-  }
-  return {
-    success: conflicts.length === 0,
-    merged: merged.join("\n"),
-    conflicts
-  };
-}
-function computeHunks(base, modified, side) {
-  const matches = lcsMatches(base, modified);
-  const hunks = [];
-  let prevBase = -1;
-  let prevMod = -1;
-  const emitGap = (curBase, curMod) => {
-    const baseLen = curBase - (prevBase + 1);
-    const modLen = curMod - (prevMod + 1);
-    if (baseLen > 0 || modLen > 0) {
-      hunks.push({
-        baseStart: prevBase + 1,
-        baseEnd: curBase,
-        content: modified.slice(prevMod + 1, curMod),
-        side
-      });
-    }
-  };
-  for (const [b, m] of matches) {
-    emitGap(b, m);
-    prevBase = b;
-    prevMod = m;
-  }
-  emitGap(base.length, modified.length);
-  return hunks;
-}
-function applyHunks(baseLines, group2, side, regionStart, regionEnd) {
-  const out = [];
-  let b = regionStart;
-  for (const hunk of group2) {
-    if (hunk.side !== side) continue;
-    if (hunk.baseStart > b) out.push(...baseLines.slice(b, hunk.baseStart));
-    out.push(...hunk.content);
-    b = hunk.baseEnd;
-  }
-  if (b < regionEnd) out.push(...baseLines.slice(b, regionEnd));
-  return out;
+  if (slash < 0) return null;
+  const folder = record.obsidianPath.slice(0, slash);
+  const stem = stripMarkdownExtension(record.obsidianPath.slice(slash + 1)).replace(ID_SUFFIX, "");
+  return stem === folder.slice(folder.lastIndexOf("/") + 1) ? folder : null;
 }
-function lcsMatches(a, b) {
-  const n = a.length;
-  const m = b.length;
-  const dp = new Array(n + 1);
-  for (let i2 = 0; i2 <= n; i2++) dp[i2] = new Uint32Array(m + 1);
-  for (let i2 = n - 1; i2 >= 0; i2--) {
-    const row = dp[i2];
-    const next = dp[i2 + 1];
-    const ai = a[i2];
-    for (let j2 = m - 1; j2 >= 0; j2--) {
-      row[j2] = ai === b[j2] ? next[j2 + 1] + 1 : Math.max(next[j2], row[j2 + 1]);
-    }
+function findNestedFolderPages(records) {
+  const byPage = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (record.notionPageId !== null) byPage.set(compactNotionId(record.notionPageId), record);
   }
-  const matches = [];
-  let i = 0;
-  let j = 0;
-  while (i < n && j < m) {
-    if (a[i] === b[j]) {
-      matches.push([i, j]);
-      i++;
-      j++;
-    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
-      i++;
-    } else {
-      j++;
-    }
+  const found2 = [];
+  for (const inner of records) {
+    if (inner.notionPageId === null || inner.notionParentId === null) continue;
+    const folder = folderOf3(inner);
+    if (folder === null) continue;
+    const outer = byPage.get(compactNotionId(inner.notionParentId));
+    if (!outer || outer === inner || folderOf3(outer) !== folder) continue;
+    found2.push({
+      folder,
+      outer: { path: outer.obsidianPath, notionPageId: outer.notionPageId },
+      inner: { path: inner.obsidianPath, notionPageId: inner.notionPageId }
+    });
   }
-  return matches;
-}
-function arraysEqual(a, b) {
-  if (a.length !== b.length) return false;
-  return a.every((val, idx) => val === b[idx]);
+  return found2.sort((a, b) => a.folder < b.folder ? -1 : a.folder > b.folder ? 1 : 0);
 }
 
 // src/conflict/resolver.ts
@@ -19723,6 +20687,7 @@ function choiceForStrategy(conflict, strategy) {
     case "duplicate":
       return isRemoteDeletion(conflict) ? "local" : "duplicate";
     case "manual":
+    case "merge":
       if (isRemoteDeletion(conflict)) {
         throw new Error(
           `Notion \uC5D0\uC11C \uC9C0\uC6B4 \uB178\uD2B8\uB294 \uC790\uB3D9 \uBCD1\uD569\uD560 \uC218 \uC5C6\uC74C \u2014 \uB85C\uCEEC \uC720\uC9C0\uB098 \uC6D0\uACA9 \uC720\uC9C0\uB97C \uACE0\uB974\uC138\uC694: ${conflict.syncRecord.obsidianPath}`
@@ -20691,6 +21656,12 @@ function depthOf(filter) {
 }
 
 // src/sync/base-view-push.ts
+var BASES_TO_NOTION_VIEW = {
+  table: "table",
+  cards: "gallery",
+  list: "list"
+};
+var CREATABLE_KEYS = ["type", "name", "order", "sort", "filters"];
 var PROPERTY_REQUEST_KEYS = [
   "property_id",
   "visible",
@@ -20702,6 +21673,9 @@ var PROPERTY_REQUEST_KEYS = [
   "time_format"
 ];
 var REQUIRED_CONFIGURATION_KEYS = ["group_by", "date_property_id"];
+function plannedViewEdits(file) {
+  return [...file.created, ...file.views, ...file.deleted].map((planned) => planned.edit);
+}
 var BaseViewEdits = class {
   constructor(stateDb, vaultFs, notionClient) {
     this.vaultFs = vaultFs;
@@ -20741,7 +21715,9 @@ var BaseViewEdits = class {
         const changed = changedFields(record, edited);
         return changed.length > 0 ? [{ record, edited, changed }] : [];
       });
-      if (edits.length === 0) continue;
+      const added = parsed.views.flatMap((view, i) => matched[i] ? [] : [{ view, index: i }]);
+      const removed = base.views.filter((record) => !matched.includes(record));
+      if (edits.length === 0 && added.length === 0 && removed.length === 0) continue;
       const meta = await this.notionClient.getDatabaseMeta(databaseId);
       if (meta.dataSources.length > 1) {
         refuse2(base.basePath, "\uB370\uC774\uD130 \uC18C\uC2A4\uAC00 \uC5EC\uB7FF\uC778 DB \uC758 \uBCF4\uAE30\uB294 Notion \uC5D0\uC11C \uBC14\uAFB8\uC138\uC694");
@@ -20750,15 +21726,66 @@ var BaseViewEdits = class {
       const schema = await this.notionClient.getDatabaseSchemaFull(databaseId, meta);
       const views = [];
       let allPlanned = true;
-      for (const { record, edited, changed } of edits) {
-        const label = `\uBCF4\uAE30 '${record.name}'`;
-        let live;
+      const liveOf = async (viewId) => {
         try {
-          live = await this.notionClient.getView(record.viewId);
+          return await this.notionClient.getView(viewId);
         } catch (error) {
           if (!isNotionObjectNotFound(error)) throw error;
-          live = null;
+          return null;
+        }
+      };
+      const created = [];
+      for (const { view, index } of added) {
+        const planned2 = planCreate(view, index, base.basePath, schema);
+        if ("error" in planned2) {
+          refuse2(base.basePath, `\uB354\uD55C \uBCF4\uAE30 '${String(view["name"] ?? "")}': ${planned2.error}`);
+          allPlanned = false;
+          continue;
+        }
+        if (!meta.dataSources[0]) {
+          refuse2(
+            base.basePath,
+            `\uB354\uD55C \uBCF4\uAE30 '${planned2.edit.view}': DB \uC758 \uB370\uC774\uD130 \uC18C\uC2A4\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`
+          );
+          allPlanned = false;
+          continue;
+        }
+        created.push(planned2);
+        if (Object.keys(view).some((key) => !CREATABLE_KEYS.includes(key))) allPlanned = false;
+      }
+      const deleted = [];
+      const gone = [];
+      for (const record of removed) {
+        const label = `\uC9C0\uC6B4 \uBCF4\uAE30 '${record.name}'`;
+        if (parsed.views.length === 0) {
+          refuse2(
+            base.basePath,
+            `${label}: \uBCF4\uAE30\uB97C \uBAA8\uB450 \uC9C0\uC6B4 .base \uB85C\uB294 Notion \uBCF4\uAE30\uB97C \uC9C0\uC6B0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`
+          );
+          allPlanned = false;
+          continue;
+        }
+        const live = await liveOf(record.viewId);
+        if (!live) {
+          gone.push(record.viewId);
+          continue;
+        }
+        if (viewFingerprint(live) !== record.notion) {
+          refuse2(
+            base.basePath,
+            `${label}: \uADF8 \uC0AC\uC774 Notion \uC5D0\uC11C \uC774 \uBCF4\uAE30\uB97C \uACE0\uCCD0 \uC9C0\uC6B0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC9C0\uC6B0\uB824\uBA74 Notion \uC5D0\uC11C \uC9C0\uC6B0\uC138\uC694`
+          );
+          allPlanned = false;
+          continue;
         }
+        deleted.push({
+          viewId: record.viewId,
+          edit: { path: base.basePath, view: record.name, action: "deleted", changed: [] }
+        });
+      }
+      for (const { record, edited, changed } of edits) {
+        const label = `\uBCF4\uAE30 '${record.name}'`;
+        const live = await liveOf(record.viewId);
         if (!live) {
           refuse2(base.basePath, `${label}: Notion \uC5D0\uC11C \uC9C0\uC6B4 \uBCF4\uAE30\uC785\uB2C8\uB2E4`);
           allPlanned = false;
@@ -20792,18 +21819,25 @@ var BaseViewEdits = class {
             type: record.type,
             ...edited,
             ...record.lossyFilter && !changed.includes("filter") ? { lossyFilter: true } : {},
-            notion: record.notion
+            notion: record.notion,
+            ...record.rest !== void 0 ? { rest: record.rest } : {}
           }
         });
       }
-      if (views.length === 0) continue;
+      if (views.length === 0 && created.length === 0 && deleted.length === 0 && gone.length === 0) {
+        continue;
+      }
       planned.push({
         databaseId,
         path: base.basePath,
         base,
         hash,
-        complete: allPlanned && matched.filter(Boolean).length === base.views.length && restSignature(parsed, matched) === base.rest,
-        views
+        complete: allPlanned && restUnchanged(parsed, matched, base),
+        views,
+        created,
+        deleted,
+        gone,
+        matched
       });
     }
     return { planned, refused };
@@ -20813,29 +21847,73 @@ var BaseViewEdits = class {
     const failed = [];
     for (const file of planned) {
       const records = new Map(file.base.views.map((record) => [record.viewId, record]));
+      const made = /* @__PURE__ */ new Map();
       let allApplied = true;
+      const fail = (what, error) => {
+        allApplied = false;
+        failed.push({
+          path: file.path,
+          operation: "update",
+          error: `${what}: ${error instanceof Error ? error.message : String(error)}`
+        });
+      };
+      const fingerprintOf = async (viewId, fallback) => {
+        const after = await this.notionClient.getView(viewId).catch(() => null);
+        return after ? viewFingerprint(after) : fallback;
+      };
+      const meta = file.created.length > 0 ? await this.dataSourceOf(file.databaseId) : null;
+      for (const view of file.created) {
+        let viewId;
+        try {
+          if (!meta) throw new Error("DB \uC758 \uB370\uC774\uD130 \uC18C\uC2A4\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4");
+          viewId = await this.notionClient.createView({
+            databaseId: file.databaseId,
+            dataSourceId: meta,
+            request: view.request
+          });
+        } catch (error) {
+          fail(`\uBCF4\uAE30 '${view.edit.view}' \uB97C Notion \uC5D0 \uB9CC\uB4E4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`, error);
+          continue;
+        }
+        applied.push(view.edit);
+        made.set(view.index, { ...view.record, viewId, notion: await fingerprintOf(viewId, "") });
+      }
       for (const view of file.views) {
         try {
           await this.notionClient.updateView(view.viewId, view.request);
         } catch (error) {
-          allApplied = false;
-          failed.push({
-            path: file.path,
-            operation: "update",
-            error: `\uBCF4\uAE30 '${view.edit.view}' \uB97C Notion \uC5D0 \uC62C\uB9AC\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${error instanceof Error ? error.message : String(error)}`
-          });
+          fail(`\uBCF4\uAE30 '${view.edit.view}' \uB97C Notion \uC5D0 \uC62C\uB9AC\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`, error);
           continue;
         }
         applied.push(view.edit);
-        const after = await this.notionClient.getView(view.viewId).catch(() => null);
         records.set(view.viewId, {
           ...view.record,
-          notion: after ? viewFingerprint(after) : view.record.notion
+          notion: await fingerprintOf(view.viewId, view.record.notion)
         });
       }
+      for (const viewId of file.gone) records.delete(viewId);
+      for (const view of file.deleted) {
+        try {
+          await this.notionClient.deleteView(view.viewId);
+        } catch (error) {
+          if (!isNotionObjectNotFound(error)) {
+            fail(`\uBCF4\uAE30 '${view.edit.view}' \uB97C Notion \uC5D0\uC11C \uC9C0\uC6B0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`, error);
+            continue;
+          }
+        }
+        applied.push(view.edit);
+        records.delete(view.viewId);
+      }
+      const inFile = file.matched.flatMap((record, i) => {
+        const kept = record ? records.get(record.viewId) : made.get(i);
+        return kept ? [kept] : [];
+      });
+      const left = [...records.values()].filter(
+        (record) => !inFile.some((r) => r.viewId === record.viewId)
+      );
       this.bases.set(file.databaseId, {
         ...file.base,
-        views: file.base.views.map((record) => records.get(record.viewId) ?? record),
+        views: [...inFile, ...left],
         // 고친 것을 모두 올렸으면 이 파일은 이제 pull 이 쓴 것과 같은 뜻이다 — 다음 pull 이 Notion 의 모습으로 다시 쓴다.
         // 남은 것이 있으면 계속 붙잡아 둔다.
         ...file.complete && allApplied ? { hash: file.hash } : {}
@@ -20843,15 +21921,55 @@ var BaseViewEdits = class {
     }
     return { applied, failed };
   }
+  /** 보기를 만들 data source — 계획 때 하나뿐임을 보았다. */
+  async dataSourceOf(databaseId) {
+    const meta = await this.notionClient.getDatabaseMeta(databaseId).catch(() => null);
+    return meta?.dataSources[0]?.id ?? null;
+  }
 };
-function buildRequest(record, edited, changed, live, schema) {
+function planCreate(view, index, path, schema) {
+  const basesType = String(view["type"] ?? "");
+  const type = Object.hasOwn(BASES_TO_NOTION_VIEW, basesType) ? BASES_TO_NOTION_VIEW[basesType] : void 0;
+  if (!type) return { error: `Notion \uC5D0 \uAC19\uC740 \uBCF4\uAE30 \uC885\uB958\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4(${basesType || "\uD0C0\uC785 \uC5C6\uC74C"})` };
+  const edited = pushableOf(view);
+  if (!edited.name.trim()) return { error: "\uBCF4\uAE30 \uC774\uB984\uC774 \uBE44\uC5C8\uC2B5\uB2C8\uB2E4" };
+  const live = { id: "", name: edited.name, type, configuration: { type } };
+  const changed = ["columns", "sort", "filter"].filter(
+    (field) => field === "columns" ? edited.order !== void 0 : field === "sort" ? edited.sort !== void 0 : edited.filters !== void 0
+  );
+  const built = buildRequest(
+    { name: edited.name, notion: "", viewId: "", type: basesType },
+    edited,
+    changed,
+    live,
+    schema,
+    { hideRest: true }
+  );
+  if (!built.ok) return { error: built.error };
+  const { configuration, filter, sorts } = built.request;
+  return {
+    index,
+    request: {
+      name: edited.name,
+      type,
+      configuration: configuration ?? { type },
+      ...filter ? { filter } : {},
+      ...sorts ? { sorts } : {}
+    },
+    edit: { path, view: edited.name, action: "created", changed: [] },
+    record: { type: basesType, ...edited, rest: viewRestOf(view) }
+  };
+}
+function buildRequest(record, edited, changed, live, schema, options = {}) {
   const request = {};
   try {
     if (changed.includes("name")) {
       if (!edited.name.trim()) throw new Error("\uBCF4\uAE30 \uC774\uB984\uC774 \uBE44\uC5C8\uC2B5\uB2C8\uB2E4");
       request.name = edited.name;
     }
-    if (changed.includes("columns")) request.configuration = columnsOf(edited, live, schema);
+    if (changed.includes("columns")) {
+      request.configuration = columnsOf(edited, live, schema, options.hideRest === true);
+    }
     if (changed.includes("sort")) {
       request.sorts = edited.sort ? edited.sort.map((s) => ({
         property: propertyIdOf(s.property, schema, "\uC815\uB82C"),
@@ -20877,7 +21995,7 @@ function buildRequest(record, edited, changed, live, schema) {
   }
   return { ok: true, request };
 }
-function columnsOf(edited, live, schema) {
+function columnsOf(edited, live, schema, hideRest = false) {
   if (!edited.order) throw new Error("\uC5F4 \uBAA9\uB85D(order)\uC744 \uC9C0\uC6B4 \uBCF4\uAE30\uB294 \uC62C\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
   const configuration = live.configuration ?? {};
   const liveEntries = Array.isArray(configuration["properties"]) ? configuration["properties"] : [];
@@ -20906,7 +22024,7 @@ function columnsOf(edited, live, schema) {
   const properties = [
     ...titleId ? [entryOf(titleId)] : [],
     ...shown.map((id) => ({ ...entryOf(id), visible: true })),
-    ...liveEntries.map((entry) => decodePropertyId(String(entry["property_id"]))).filter((id) => id !== titleId && !shown.includes(id)).map((id) => ({ ...entryOf(id), visible: false }))
+    ...(hideRest ? Object.values(schema).map((prop) => decodePropertyId(prop.id)) : liveEntries.map((entry) => decodePropertyId(String(entry["property_id"])))).filter((id, i, all) => id !== titleId && !shown.includes(id) && all.indexOf(id) === i).map((id) => ({ ...entryOf(id), visible: false }))
   ];
   return {
     type: configuration["type"] ?? live.type,
@@ -21023,7 +22141,8 @@ var OPERATION_LABELS = {
   fetch: "\uC6D0\uACA9 \uD655\uC778",
   resolve: "\uCDA9\uB3CC \uD574\uACB0",
   discard: "\uBCC0\uACBD \uB418\uB3CC\uB9AC\uAE30",
-  "prepare-database": "DB \uB85C \uC62C\uB9B4 \uC900\uBE44"
+  "prepare-database": "DB \uB85C \uC62C\uB9B4 \uC900\uBE44",
+  "base-filters": ".base \uD3F4\uB354 \uD544\uD130 \uACE0\uCE58\uAE30"
 };
 function operationLabel(operation) {
   return OPERATION_LABELS[operation];
@@ -21208,6 +22327,7 @@ var InterruptedSyncRecovery = class {
     if (ops.length === 0) return;
     for (const op of ops) {
       if (op.direction === "push" && op.operation === "move") continue;
+      if (op.direction === "push" && op.operation === "update") continue;
       if (op.direction !== "push" || op.operation !== "create") {
         this.stateDb.markPendingFailed(op.id, "unsupported resume op");
         continue;
@@ -21329,6 +22449,101 @@ var InterruptedSyncRecovery = class {
   }
 };
 
+// src/sync/lost-state-guard.ts
+var SHOWN_CLASHES = 5;
+var UnlinkedVaultError = class extends Error {
+  clashes;
+  constructor(clashes) {
+    const shown = clashes.slice(0, SHOWN_CLASHES).join(", ");
+    const more = clashes.length > SHOWN_CLASHES ? ` \uC678 ${clashes.length - SHOWN_CLASHES}\uAC1C` : "";
+    super(
+      `\uC0C1\uD0DC \uAE30\uB85D\uC5D0 Notion \uACFC \uC774\uC740 \uB178\uD2B8\uAC00 \uC5C6\uB294\uB370 Notion \uC5D0 \uAC19\uC740 \uC774\uB984\uC758 \uD398\uC774\uC9C0\uAC00 \uC774\uBBF8 \uC788\uC5B4 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4(${shown}${more}) \u2014 \uC774\uB300\uB85C \uC62C\uB9AC\uBA74 \uAC19\uC740 \uD398\uC774\uC9C0\uB97C \uB610 \uB9CC\uB4ED\uB2C8\uB2E4. \uBA3C\uC800 pull(\uB610\uB294 sync)\uB85C \uBC1B\uC73C\uC138\uC694: \uAC19\uC740 \uC790\uB9AC\uC5D0 \uAC19\uC740 \uAE00\uC774 \uC788\uB294 \uB178\uD2B8\uB294 \uADF8 \uD398\uC774\uC9C0\uC640 \uB2E4\uC2DC \uC787\uACE0, \uAE00\uC774 \uB2E4\uB974\uBA74 \uCDA9\uB3CC\uB85C \uB0A8\uAE41\uB2C8\uB2E4`
+    );
+    this.name = "UnlinkedVaultError";
+    this.clashes = clashes;
+  }
+};
+async function assertVaultLinked(config, stateDb, notionClient, createdPaths) {
+  const unverified = /* @__PURE__ */ new Map();
+  if (config.sync.direction === "push" || createdPaths.length === 0) return unverified;
+  if (stateDb.getAll().length > 0 || stateDb.getIncompletePendingOperations().length > 0) {
+    return unverified;
+  }
+  const clashes = await new RemoteTree(notionClient).clashes(config, createdPaths, unverified);
+  if (clashes.length > 0) throw new UnlinkedVaultError(clashes);
+  return unverified;
+}
+var RemoteTree = class {
+  constructor(notionClient) {
+    this.notionClient = notionClient;
+  }
+  notionClient;
+  listed = /* @__PURE__ */ new Map();
+  async clashes(config, createdPaths, unverified) {
+    const databases = config.notion.databases ?? [];
+    const clashes = [];
+    for (const path of [...createdPaths].sort()) {
+      const database = databases.find((db) => path.startsWith(`${db.localFolder}/`));
+      const found2 = await (database ? this.find({ id: database.databaseId, kind: "database" }, [
+        path.slice(database.localFolder.length + 1)
+      ]) : isDatabaseMode(config) ? this.find({ id: config.notion.databaseId, kind: "database" }, [
+        path.split("/").pop()
+      ]) : this.find({ id: config.notion.rootPageId, kind: "page" }, path.split("/"))).catch((error) => {
+        unverified.set(
+          path,
+          "\uC0C1\uD0DC \uAE30\uB85D\uC774 \uBE48 \uBCFC\uD2B8\uB77C Notion \uC5D0 \uAC19\uC740 \uD398\uC774\uC9C0\uAC00 \uC788\uB294\uC9C0 \uBA3C\uC800 \uBCF4\uB294\uB370 \uC77D\uC9C0 \uBABB\uD574 \uC62C\uB9AC\uC9C0 \uC54A\uC74C: " + (error instanceof Error ? error.message : String(error))
+        );
+        return false;
+      });
+      if (found2) clashes.push(path);
+    }
+    return clashes;
+  }
+  /** `segments`(폴더 … 노트 파일)의 노트 페이지가 `node` 아래에 이미 있나. */
+  async find(node, segments) {
+    let current = node;
+    for (const folder of segments.slice(0, -1)) {
+      const next = (await this.children(current)).get(sanitizeFileName(folder));
+      if (!next) return false;
+      current = next;
+    }
+    const name = sanitizeFileName(stripMarkdownExtension(segments[segments.length - 1]));
+    const parentFolder = segments.length > 1 ? sanitizeFileName(segments[segments.length - 2]) : null;
+    if (parentFolder === name && current.kind === "page") return true;
+    return (await this.children(current)).has(name);
+  }
+  children(node) {
+    let listed = this.listed.get(node.id);
+    if (!listed) {
+      listed = node.kind === "database" ? this.rows(node.id) : this.subpages(node.id);
+      this.listed.set(node.id, listed);
+    }
+    return listed;
+  }
+  async rows(databaseId) {
+    const rows = /* @__PURE__ */ new Map();
+    for (const page of await this.notionClient.queryAllDatabasePages(databaseId)) {
+      rows.set(sanitizeFileName(this.notionClient.extractTitle(page)), {
+        id: page.id,
+        kind: "page"
+      });
+    }
+    return rows;
+  }
+  async subpages(pageId) {
+    const found2 = /* @__PURE__ */ new Map();
+    for (const block of await this.notionClient.fetchAllChildren(pageId)) {
+      const child = block;
+      if (child.type === "child_page" && child.child_page?.title !== void 0) {
+        found2.set(sanitizeFileName(child.child_page.title), { id: child.id, kind: "page" });
+      } else if (child.type === "child_database" && child.child_database?.title !== void 0) {
+        found2.set(sanitizeFileName(child.child_database.title), { id: child.id, kind: "database" });
+      }
+    }
+    return found2;
+  }
+};
+
 // src/sync/db-placeholder-rewriter.ts
 var ID32 = "[a-f0-9]{32}";
 var IDUUID = "[a-f0-9-]{32,36}";
@@ -21515,6 +22730,7 @@ var DatabaseDiscovery = class {
       }
       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;
@@ -21568,6 +22784,7 @@ var DatabaseDiscovery = class {
         } 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") {
@@ -21602,6 +22819,7 @@ var DatabaseDiscovery = class {
         await register(normalizeNotionId(nohyph), parentPageId);
       }
       const stillSyncable = [];
+      const pulledWhole = /* @__PURE__ */ new Set();
       let queue = [...dbConfigs];
       const MAX_DISCOVERY_ROUNDS = 4;
       const resolveDbFolder = (dbId) => {
@@ -21641,10 +22859,8 @@ var DatabaseDiscovery = class {
               }
             });
             if (dbResult.linkedOriginalDbId) {
-              linkedMap.set(
-                dbConfig.databaseId.replace(/-/g, ""),
-                dbResult.linkedOriginalDbId.replace(/-/g, "")
-              );
+              linkedMap.set(nohyph, dbResult.linkedOriginalDbId.replace(/-/g, ""));
+              linkedNow.add(nohyph);
               linkedChanged = true;
               changed = true;
               ledger?.settle(dbConfig.databaseId);
@@ -21653,6 +22869,7 @@ var DatabaseDiscovery = class {
               );
               continue;
             }
+            if (!paths) pulledWhole.add(nohyph);
             created += dbResult.created;
             updated += dbResult.updated;
             deleted += dbResult.deleted;
@@ -21699,6 +22916,11 @@ var DatabaseDiscovery = class {
           );
         }
       }
+      if (!signal?.aborted) {
+        linkedChanged = await this.pullLinkedViews(linkedMap, stillSyncable, {
+          pulled: (container, original) => forceRediscovery || linkedNow.has(container) || pulledWhole.has(original)
+        }) || linkedChanged;
+      }
       ledger?.keepOnly([...configuredIds, ...stillSyncable.map((c) => c.databaseId)]);
       if (changed || inaccessibleChanged || stillSyncable.length !== dbConfigs.length) {
         this.stateDb.setMeta(DISCOVERED_DBS_META_KEY, JSON.stringify(stillSyncable));
@@ -21723,6 +22945,29 @@ var DatabaseDiscovery = class {
     }
     return { created, updated, deleted, restored };
   }
+  /**
+   * 링크드 뷰 컨테이너마다 그 보기로 `.base` 를 쓴다({@link DatabaseSyncer.pullLinkedView}). 원본 DB 를 받은 pull ·
+   * 이번에 해소한 컨테이너 · 아직 `.base` 가 없는 컨테이너만 — 보기만 고친 것은 DB 수정 시각을 바꾸지 않아 원본처럼
+   * 다음 전체 대조가 받는다. Notion 에서 지운 컨테이너는 연결에서 뺀다.
+   *
+   * @returns 연결(`linkedMap`)을 바꿨나.
+   */
+  async pullLinkedViews(linkedMap, syncing, due) {
+    let changed = false;
+    const owners = [...syncing, ...this.config.notion.databases ?? []];
+    for (const [container, original] of [...linkedMap]) {
+      const owner = owners.find((c) => c.databaseId.replace(/-/g, "") === original);
+      if (!owner) continue;
+      if (!due.pulled(container, original) && this.databaseSyncer.baseFileInfo.get(container)) {
+        continue;
+      }
+      if (await this.databaseSyncer.pullLinkedView(container, owner) === "gone") {
+        linkedMap.delete(container);
+        changed = true;
+      }
+    }
+    return changed;
+  }
   async discoverChildDatabases(pageIds) {
     const found2 = [];
     const unread = [];
@@ -21836,6 +23081,12 @@ var DatabaseDiscovery = class {
     for (const [key, t] of [...targets]) {
       if (!await this.vaultFs.exists(t.basePath)) targets.delete(key);
     }
+    for (const container of linkedMap.keys()) {
+      const info = this.databaseSyncer.baseFileInfo.get(container);
+      if (info?.linkedTo && await this.vaultFs.exists(info.basePath)) {
+        targets.set(container, { basePath: info.basePath, title: info.title });
+      }
+    }
     if (targets.size === 0) return;
     const resolve2 = (nohyph) => targets.get(nohyph) ?? targets.get(linkedMap.get(nohyph) ?? "") ?? null;
     let total = 0;
@@ -21886,12 +23137,6 @@ var DatabaseDiscovery = class {
     return refs;
   }
 };
-function databaseFolderName(title) {
-  return truncateBytes(
-    title.replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-"),
-    FILE_SYSTEM_NAME_MAX_BYTES
-  );
-}
 
 // src/sync/folder-placement.ts
 var FolderPlacement = class {
@@ -22980,12 +24225,14 @@ function baseName3(path) {
 
 // src/sync/link-updater.ts
 var LinkUpdater = class {
-  constructor(stateDb, vaultFs) {
+  constructor(stateDb, vaultFs, outside) {
     this.stateDb = stateDb;
     this.vaultFs = vaultFs;
+    this.outside = outside;
   }
   stateDb;
   vaultFs;
+  outside;
   /**
    * @param moves 옮긴 차례 그대로의 이동 — 노트 하나거나 폴더 하나.
    * @returns 링크를 고친 노트.
@@ -23003,33 +24250,130 @@ var LinkUpdater = class {
     if (renames.size === 0) return [];
     const before = new Set([...after].map((path) => undo(path, moves)));
     const context = { before, after, renames };
+    const noteRenames = new Map([...renames].filter(([from]) => isMarkdownPath(from)));
     const relinked = [];
     for (const note of notes) {
       const source = { from: undo(note.path, moves), to: note.path };
       const next = rewriteLinks(note.content, source, context);
       if (next === note.content) continue;
+      const notesOnly = noteRenames.size === renames.size || rewriteLinks(note.content, source, { ...context, renames: noteRenames }) === next;
+      if (await this.rewrite(note, next, notesOnly)) relinked.push(note.path);
+    }
+    if (this.outside) relinked.push(...await this.applyOutside(this.outside, moves, after));
+    if (relinked.length > 0) {
+      getLogger().info(`[Im-Nobsidian] \uC62E\uAE34 \uB178\uD2B8\uB97C \uAC00\uB9AC\uD0A4\uB358 \uB9C1\uD06C\uB97C \uACE0\uCE68: \uB178\uD2B8 ${relinked.length}`);
+    }
+    return relinked;
+  }
+  /**
+   * 이 연결이 보지 않는 노트의 링크를 고친다 — 경로는 볼트 맨 위 기준으로 옮겨 견준다. Obsidian 은 링크를 볼트 전체에서
+   * 찾으므로 이름만 적은 링크도 볼트 전체의 파일로 가른다.
+   *
+   * @param own 이 연결이 보는 파일(연결 폴더 기준) — 위에서 고쳤다.
+   * @returns 고친 노트(볼트 맨 위 기준).
+   */
+  async applyOutside(outside, moves, own) {
+    const prefix = outside.folder === "" ? "" : `${outside.folder}/`;
+    const vaultMoves = moves.map((move) => ({
+      ...move,
+      from: prefix + move.from,
+      to: prefix + move.to
+    }));
+    const mine = new Set([...own].map((path) => prefix + path));
+    const notes = await outside.fs.listMarkdownFiles();
+    const others = await outside.fs.listNonMarkdownFiles();
+    const after = new Set([...notes, ...others].map((file) => file.path));
+    const renames = /* @__PURE__ */ new Map();
+    for (const path of after) {
+      const before = undo(path, vaultMoves);
+      if (before !== path) renames.set(before, path);
+    }
+    if (renames.size === 0) return [];
+    const context = {
+      before: new Set([...after].map((path) => undo(path, vaultMoves))),
+      after,
+      renames
+    };
+    const relinked = [];
+    for (const note of notes) {
+      if (mine.has(note.path)) continue;
+      const next = rewriteLinks(note.content, { from: note.path, to: note.path }, context);
+      if (next === note.content) continue;
       try {
-        await this.vaultFs.writeFile(note.path, next);
+        await outside.fs.writeFile(note.path, next);
+        relinked.push(note.path);
       } catch (error) {
         getLogger().warn(
-          `[Im-Nobsidian] \uC62E\uAE34 \uB178\uD2B8\uB97C \uAC00\uB9AC\uD0A4\uB358 \uB9C1\uD06C\uB97C \uACE0\uCE58\uC9C0 \uBABB\uD568 (${note.path}): ${error instanceof Error ? error.message : String(error)}`
+          `[Im-Nobsidian] \uB2E4\uB978 \uC5F0\uACB0\uC758 \uB178\uD2B8\uC5D0\uC11C \uC62E\uAE34 \uB178\uD2B8\uB97C \uAC00\uB9AC\uD0A4\uB358 \uB9C1\uD06C\uB97C \uACE0\uCE58\uC9C0 \uBABB\uD568 (${note.path}): ${error instanceof Error ? error.message : String(error)}`
         );
-        continue;
       }
-      const record = this.stateDb.getByPath(note.path);
-      if (record && record.contentHash === computeHash(note.content)) {
-        this.stateDb.updateHash(record.id, computeHash(next), Buffer.from(next, "utf-8"));
-        const stat2 = await this.vaultFs.getFileStat(note.path);
-        if (stat2) this.stateDb.updateStatCache(record.id, stat2.mtime, stat2.size);
-      }
-      relinked.push(note.path);
-    }
-    if (relinked.length > 0) {
-      getLogger().info(`[Im-Nobsidian] \uC62E\uAE34 \uB178\uD2B8\uB97C \uAC00\uB9AC\uD0A4\uB358 \uB9C1\uD06C\uB97C \uACE0\uCE68: \uB178\uD2B8 ${relinked.length}`);
     }
     return relinked;
   }
+  /**
+   * 치운 `.base` 를 넣은 줄을 뺀다 — Notion 에서 지운 링크드 뷰라 pull 이 그 `.base` 를 치웠다. Notion 의 본문에는 그
+   * 블록이 이미 없다. API 로 블록을 지우면 페이지의 수정 시각이 그대로라(2026-10-30 실측) 그 페이지를 다시 받지 않아
+   * 깨진 임베드가 남았다. 동기화된 노트는 고친 글을 사본으로 적는다 — Notion 의 본문과 같아졌다.
+   *
+   * @returns 임베드를 뺀 노트.
+   */
+  async dropEmbeds(basePaths) {
+    if (basePaths.length === 0) return [];
+    const gone = new Set(basePaths);
+    const dropped = [];
+    for (const note of await this.vaultFs.listMarkdownFiles()) {
+      const next = dropEmbedLines(note.content, gone);
+      if (next !== note.content && await this.rewrite(note, next, true)) dropped.push(note.path);
+    }
+    if (dropped.length > 0) {
+      getLogger().info(
+        `[Im-Nobsidian] Notion \uC5D0\uC11C \uC9C0\uC6B4 \uB9C1\uD06C\uB4DC \uBDF0\uC758 \uC784\uBCA0\uB4DC\uB97C \uBE8C: \uB178\uD2B8 ${dropped.length}`
+      );
+    }
+    return dropped;
+  }
+  /**
+   * 고친 글을 쓴다. `matchesNotion` 이고 동기화된 노트(지난 사본 그대로)면 고친 글을 사본으로 적어 다음 push 가 올리지
+   * 않게 한다 — Notion 의 본문은 이미 그 모양이다.
+   */
+  async rewrite(note, next, matchesNotion) {
+    try {
+      await this.vaultFs.writeFile(note.path, next);
+    } catch (error) {
+      getLogger().warn(
+        `[Im-Nobsidian] \uB2E4\uB978 \uB178\uD2B8\uB97C \uAC00\uB9AC\uD0A4\uB358 \uB9C1\uD06C\uB97C \uACE0\uCE58\uC9C0 \uBABB\uD568 (${note.path}): ${error instanceof Error ? error.message : String(error)}`
+      );
+      return false;
+    }
+    const record = this.stateDb.getByPath(note.path);
+    if (record && record.contentHash === computeHash(note.content) && matchesNotion) {
+      this.stateDb.updateHash(record.id, computeHash(next), Buffer.from(next, "utf-8"));
+      const stat2 = await this.vaultFs.getFileStat(note.path);
+      if (stat2) this.stateDb.updateStatCache(record.id, stat2.mtime, stat2.size);
+    }
+    return true;
+  }
 };
+var EMBED_LINE_RE = /^!\[\[([^\]|]+)(?:\|[^\]]*)?\]\]$/;
+function dropEmbedLines(content, gone) {
+  const kept = [];
+  let skipBlank = false;
+  for (const line of content.split("\n")) {
+    const target = EMBED_LINE_RE.exec(line.trim())?.[1];
+    if (target !== void 0 && gone.has(target)) {
+      if (kept.length > 0 && kept[kept.length - 1].trim() === "") kept.pop();
+      else skipBlank = kept.length === 0;
+      continue;
+    }
+    if (skipBlank && line.trim() === "") {
+      skipBlank = false;
+      continue;
+    }
+    skipBlank = false;
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
 function undo(path, moves) {
   let current = path;
   for (let i = moves.length - 1; i >= 0; i--) {
@@ -23041,6 +24385,19 @@ function undo(path, moves) {
   return current;
 }
 
+// src/sync/block-anchors.ts
+async function readBlockAnchors(client, blockIds) {
+  const anchors = /* @__PURE__ */ new Map();
+  for (const id of new Set(blockIds.map(compactNotionId))) {
+    try {
+      const anchor = anchorOfBlock(anchorBlockOf(await client.getBlock(id)));
+      if (anchor) anchors.set(id, anchor);
+    } catch {
+    }
+  }
+  return anchors;
+}
+
 // src/sync/change-inspector.ts
 var ChangeInspector = class {
   constructor(stateDb, vaultFs, notionClient, planner, puller) {
@@ -23549,6 +24906,7 @@ var RemoteDriftChecker = class {
     this.databaseSyncer = databaseSyncer;
     this.rowSchemas = rowSchemas;
     this.observation = observation;
+    this.journal = new UpdateJournal(stateDb);
   }
   config;
   stateDb;
@@ -23556,6 +24914,20 @@ var RemoteDriftChecker = class {
   databaseSyncer;
   rowSchemas;
   observation;
+  journal;
+  /**
+   * 원격이 이 노트를 쓰다 끊긴 그대로인가({@link UpdateJournal}) — push 는 마저 올리고, pull 은 받을 것이 없다고
+   * 본다.
+   * @param localContent 지금 노트 글.
+   */
+  interruptedOwnWrite(record, remote, localContent) {
+    return this.journal.wroteRemote(
+      record,
+      remote,
+      computeHash(localContent),
+      this.observation.context.botUserId
+    );
+  }
   /**
    * 원격이 바뀌었는지 확인하지 않고 로컬로 덮어써도 되는가 — 원격을 로컬로 맞추라는 요청이다.
    *
@@ -23702,6 +25074,7 @@ var PagePusher = class {
     this.drift = drift;
     this.placement = placement;
     this.recovery = recovery;
+    this.journal = new UpdateJournal(stateDb);
   }
   config;
   stateDb;
@@ -23720,6 +25093,8 @@ var PagePusher = class {
   }
   /** 이번 실행에서 relation 을 보내지 못한 행 — 대상 노트가 아직 Notion 에 없었다. */
   unsentRelations = /* @__PURE__ */ new Set();
+  /** 본문을 쓰다 끊긴 노트를 다음 실행이 알게 — {@link UpdateJournal}. */
+  journal;
   /** 이번 실행에서 페이지 ↔ 행 · 다른 DB 의 행이 된 노트({@link takePlacementChanges}). */
   placementChanges = [];
   /**
@@ -23770,10 +25145,63 @@ var PagePusher = class {
         );
         if (readOnly.length > 0) skips.push({ path: change.path, properties: readOnly });
       } catch {
-        continue;
+        continue;
+      }
+    }
+    return skips.sort((a, b) => a.path.localeCompare(b.path));
+  }
+  /**
+   * dry-run 이 알릴, 실제 push 가 원격을 보고 거절할 고침 · 지움 — {@link pushUpdate} · {@link pushDelete} 와 같은
+   * 판정이다(Notion 에서 지운 페이지 · pull 하지 않은 Notion 편집). 원격을 읽기만 하고 상태 DB 는 바꾸지 않는다 —
+   * 실제 push 는 지운 페이지를 충돌로 남기지만 dry-run 은 이유만 보인다. 원격을 읽지 못했으면 그 실패를 보인다.
+   *
+   * 옮김은 보지 않는다 — 옮기는 노트는 옮길 자리 판정을 먼저 받는다(S-11).
+   */
+  async previewRemoteRefusals(changes) {
+    const refused = [];
+    for (const change of changes) {
+      const operation = change.type === "modified" ? "update" : change.type === "deleted" ? "delete" : null;
+      if (operation === null) continue;
+      if (operation === "delete" && !this.config.sync.deleteSync) continue;
+      const record = this.stateDb.getByPath(change.path);
+      if (!record?.notionPageId) continue;
+      try {
+        if (operation === "update") await this.previewUpdate(change.path, record);
+        else await this.previewDelete(change.path, record);
+      } catch (error) {
+        refused.push({
+          path: change.path,
+          operation,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return refused;
+  }
+  /** 실제 고침이 원격을 보고 거절하면 그 오류를 던진다({@link pushUpdate} · {@link pushRowUpdate}). */
+  async previewUpdate(path, record) {
+    const presence = await remotePresence(this.notionClient, record.notionPageId);
+    if (presence.kind !== "alive") throw new Error(trashedPageRefusal(path));
+    if (this.drift.overwritesRemote(record, false)) return;
+    const content = await this.vaultFs.readFile(path);
+    if (this.drift.interruptedOwnWrite(record, presence.page, content)) return;
+    if (rowDatabaseOf(this.config, record)) {
+      const base = this.baseRowState(record);
+      let body;
+      try {
+        body = parseFrontmatter(content).body;
+      } catch {
+        return;
       }
+      if (base?.body != null && base.body === body) return;
     }
-    return skips.sort((a, b) => a.path.localeCompare(b.path));
+    refuseUnpulledBody(await this.drift.remoteDrift(record, presence.page), path);
+  }
+  /** 실제 지움이 원격을 보고 거절하면 그 오류를 던진다({@link pushDelete}). 이미 사라진 원격은 추적만 놓는다. */
+  async previewDelete(path, record) {
+    const presence = await remotePresence(this.notionClient, record.notionPageId);
+    if (presence.kind !== "alive" || this.drift.overwritesRemote(record, false)) return;
+    refuseUnpulledDeletion(await this.drift.remoteDrift(record, presence.page), path);
   }
   /** dry-run 이 견줄 행 — 새 행은 기준 없이, 고친 행은 지난 동기화 사본과. 행이 아니거나 사본이 없으면 null. */
   previewRow(change) {
@@ -23838,7 +25266,8 @@ var PagePusher = class {
       direction: "push",
       path: selectedPath,
       filePath: path,
-      parentMode: this.config.notion.parentMode
+      parentMode: this.config.notion.parentMode,
+      anchors: await this.anchorLookup(content, null)
     });
     const title = noteTitle(conversionResult.properties, path);
     const placeholder2 = this.stateDb.upsert({
@@ -23948,13 +25377,40 @@ var PagePusher = class {
     }
     return uploads;
   }
+  /**
+   * 노트의 제목 · 블록 링크(`[[노트#제목]]`)가 가리키는 페이지의 맨 위 블록을 읽어 둔다 — 변환은 기다리지 않는다
+   * (anchor-links). 그런 링크가 없으면 읽지 않는다. 읽지 못한 페이지의 링크는 예전처럼 간다.
+   *
+   * @param selfPageId 이 노트의 페이지 — `[[#제목]]` 의 대상. 새로 만드는 노트는 아직 없다(그 링크는 다음 push 에 걸린다).
+   */
+  async anchorLookup(content, selfPageId) {
+    const pages = /* @__PURE__ */ new Set();
+    for (const target of anchoredWikilinkTargets(content)) {
+      const { note } = splitAnchor(target);
+      const pageId = note === "" ? selfPageId : this.stateDb.resolveWikilink(note)?.notionPageId ?? null;
+      if (pageId) pages.add(compactNotionId(pageId));
+    }
+    if (pages.size === 0) return void 0;
+    const blocks = /* @__PURE__ */ new Map();
+    for (const pageId of pages) {
+      try {
+        blocks.set(pageId, (await this.notionClient.fetchAllChildren(pageId)).map(anchorBlockOf));
+      } catch (error) {
+        getLogger().debug(
+          `[Im-Nobsidian] \uC81C\uBAA9 \uB9C1\uD06C\uC758 \uB300\uC0C1 \uD398\uC774\uC9C0 \uBE14\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD568 (${pageId}): ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return {
+      selfPageId,
+      blockOf: (pageId, anchor) => anchorBlockId(blocks.get(compactNotionId(pageId)) ?? [], anchor)
+    };
+  }
   async livePage(record) {
     const presence = await remotePresence(this.notionClient, record.notionPageId);
     if (presence.kind === "alive") return presence.page;
     this.stateDb.updateStatus(record.id, "conflict");
-    throw new Error(
-      `Notion \uC5D0\uC11C \uC9C0\uC6B4 \uD398\uC774\uC9C0\uB77C \uC62C\uB9AC\uC9C0 \uC54A\uC74C \u2014 \uCDA9\uB3CC\uB85C \uB0A8\uACBC\uB2E4. \uCDA9\uB3CC \uD574\uACB0\uC5D0\uC11C \uB85C\uCEEC \uC720\uC9C0(\uC0C8 \uD398\uC774\uC9C0\uB85C \uB2E4\uC2DC \uB9CC\uB4E4\uAE30)\uB098 \uC6D0\uACA9 \uC720\uC9C0(\uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B0\uAE30)\uB97C \uACE0\uB974\uC138\uC694: ${record.obsidianPath}`
-    );
+    throw new Error(trashedPageRefusal(record.obsidianPath));
   }
   /**
    * @param options.overwriteRemote 원격을 로컬 내용으로 맞춘다(충돌 해소 결과 전파 · 입양한 행).
@@ -23982,15 +25438,15 @@ var PagePusher = class {
       direction: "push",
       path: updatePath,
       filePath: path,
-      parentMode: this.config.notion.parentMode
+      parentMode: this.config.notion.parentMode,
+      anchors: await this.anchorLookup(content, record.notionPageId)
     });
     const remote = await this.livePage(record);
-    const drift = this.drift.overwritesRemote(
-      record,
-      options?.overwriteRemote === true
-    ) ? "none" : await this.drift.remoteDrift(record, remote);
+    const drift = this.drift.overwritesRemote(record, options?.overwriteRemote === true) || this.drift.interruptedOwnWrite(record, remote, content) ? "none" : await this.drift.remoteDrift(record, remote);
     refuseUnpulledBody(drift, path);
     const settles = drift === "none";
+    const hash = computeHash(content);
+    this.journal.begin(record.id, hash);
     const pushed = await this.pushUpdatePage(record.notionPageId, conversionResult.content, path);
     let bodyFingerprint = pushed.fingerprint;
     let touched = await this.fillDeferredBlocks(
@@ -24025,11 +25481,11 @@ var PagePusher = class {
     } else if (settles) {
       written = await this.notionClient.getPage(record.notionPageId);
     }
-    const hash = computeHash(content);
     const fileStat = await this.vaultFs.getFileStat(path);
     const title = extractTitle(path);
     const aliases = extractAliases(conversionResult.properties);
     this.stateDb.transaction(() => {
+      this.journal.finish(record.id);
       this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
       this.stateDb.updateStatus(record.id, "synced");
       if (written !== null && settles) {
@@ -24244,20 +25700,28 @@ var PagePusher = class {
    * ({@link RemoteDriftChecker.overwritesRemote}).
    *
    * 다시 보내면 Notion 을 덮으므로, 받지 않은 Notion 편집이 있으면 옮기지 않는다.
+   *
+   * 옮기기 전에 보낼 노트를 갱신 WAL 에 적는다(P7). 옮긴 뒤 응답을 잃으면 같은 실행의 재시도 · 다음 push 는 이미 그
+   * 자리에 있고 마지막 편집자가 이 봇인 페이지를 본다 — 우리가 옮기다 끊긴 것이므로 옮기기를 건너뛰고 마저 보낸다.
+   * 예전에는 옮기며 바뀐 수정 시각을 Notion 편집으로 보고 «pull 을 먼저 하라» 고 거절했다.
    */
   async changePlacement(record, move) {
     const { path, databaseId } = move;
     const pageId = record.notionPageId;
+    let content;
     let current;
     try {
-      current = parseFrontmatter(await this.vaultFs.readFile(path)).data;
+      content = await this.vaultFs.readFile(path);
+      current = parseFrontmatter(content).data;
     } catch (error) {
       throw new Error(
         `frontmatter \uB97C \uC77D\uC9C0 \uBABB\uD574 \uC62E\uAE30\uC9C0 \uC54A\uC74C (${path}): ${error instanceof Error ? error.message : String(error)}`
       );
     }
     const remote = await this.livePage(record);
-    if (!this.drift.overwritesRemote(record, false) && await this.drift.remoteDrift(record, remote) !== "none") {
+    const pageParentId = databaseId ? null : this.placement.moveParentOf(path);
+    const resumed = placedAt(remote, databaseId ?? pageParentId, databaseId !== null) && this.drift.interruptedOwnWrite(record, remote, content);
+    if (!resumed && !this.drift.overwritesRemote(record, false) && await this.drift.remoteDrift(record, remote) !== "none") {
       throw new Error(
         `Notion \uC5D0\uC11C \uBC14\uB010 \uB4A4 \uBC1B\uC9C0 \uC54A\uC740 \uD3B8\uC9D1\uC774 \uC788\uC5B4 \uC62E\uAE30\uC9C0 \uC54A\uC74C \u2014 \uC62E\uAE30\uBA74 \uB178\uD2B8\uB97C \uD1B5\uC9F8\uB85C \uB2E4\uC2DC \uBCF4\uB0B4 \uADF8 \uD3B8\uC9D1\uC744 \uB36E\uB294\uB2E4. pull \uC744 \uBA3C\uC800 \uD558\uC138\uC694: ${path}`
       );
@@ -24276,11 +25740,17 @@ var PagePusher = class {
         );
         addedColumns = columnsAddedByMove(pagePropertiesOf(remote), schema);
       }
-      await this.notionClient.movePageToDataSource(pageId, source.id);
+      if (!resumed) {
+        this.journal.begin(record.id, computeHash(content));
+        await this.notionClient.movePageToDataSource(pageId, source.id);
+      }
       parentId = databaseId;
     } else {
-      parentId = this.placement.moveParentOf(path);
-      await this.notionClient.movePage(pageId, parentId);
+      parentId = pageParentId;
+      if (!resumed) {
+        this.journal.begin(record.id, computeHash(content));
+        await this.notionClient.movePage(pageId, parentId);
+      }
     }
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
@@ -24443,7 +25913,8 @@ var PagePusher = class {
       direction: "push",
       path: selectedPath,
       filePath: path,
-      parentMode: "database"
+      parentMode: "database",
+      anchors: await this.anchorLookup(content, null)
     });
     const placeholder2 = this.stateDb.upsert({
       obsidianPath: path,
@@ -24620,7 +26091,7 @@ var PagePusher = class {
     }
     const remote = await this.livePage(record);
     const mapper = await this.rowSchemas.mapperFor(databaseId, dataSourceIdOf(remote));
-    const drift = options.overwriteRemote ? "none" : await this.drift.remoteDrift(record, remote);
+    const drift = options.overwriteRemote || this.drift.interruptedOwnWrite(record, remote, content) ? "none" : await this.drift.remoteDrift(record, remote);
     const against = options.overwriteRemote ? this.remoteRowState(mapper, remote) : this.baseRowState(record);
     const title = noteTitle(current.data, path);
     const changes = diffRowProperties(
@@ -24658,8 +26129,10 @@ var PagePusher = class {
         direction: "push",
         path: selectedPath,
         filePath: path,
-        parentMode: "database"
+        parentMode: "database",
+        anchors: await this.anchorLookup(content, pageId)
       });
+      this.journal.begin(record.id, computeHash(content));
       const pushed = await this.pushUpdatePage(pageId, conversionResult.content, path);
       bodyFingerprint = pushed.fingerprint;
       let touched = await this.fillDeferredBlocks(
@@ -24709,6 +26182,7 @@ var PagePusher = class {
     const hash = computeHash(snapshot);
     const fileStat = unsent.length > 0 ? null : await this.vaultFs.getFileStat(path);
     this.stateDb.transaction(() => {
+      this.journal.finish(record.id);
       this.stateDb.updateHash(record.id, hash, Buffer.from(snapshot, "utf-8"));
       this.stateDb.updateStatus(record.id, "synced");
       if (written !== null && settles) {
@@ -24885,11 +26359,13 @@ var PagePusher = class {
     }
   }
   /**
-   * `.base` 가 나타내는 Notion DB id 들 — 옆 사이드카(`<이름>.notion.json`)의 DB 와, 그 DB 를
-   * 원본으로 둔 링크드 뷰 컨테이너(pull 이 `.base` 를 원본 DB 로 몰아 만든다). 사이드카가
-   * 없거나 읽지 못하면 빈 목록 — 호출측이 제목으로 맞춘다.
+   * `.base` 가 나타내는 Notion DB id 들 — 링크드 뷰의 `.base` 면 그 컨테이너. 아니면 옆 사이드카(`<이름>.notion.json`)의
+   * DB 와, 그 DB 를 원본으로 둔 링크드 뷰 컨테이너(예전 pull 은 링크드 뷰를 원본의 `.base` 로 몰아 넣었다 — 그 노트를
+   * 올릴 때도 링크드 뷰 블록을 지킨다). 사이드카가 없거나 읽지 못하면 빈 목록 — 호출측이 제목으로 맞춘다.
    */
   async databaseIdsOfBase(basePath) {
+    const container = new DbBaseFiles(this.stateDb).linkedContainerAt(basePath);
+    if (container) return [container];
     const sidecarPath = basePath.slice(0, -BASE_SUFFIX.length) + SIDECAR_SUFFIX;
     let databaseId;
     try {
@@ -24900,7 +26376,7 @@ var PagePusher = class {
     if (typeof databaseId !== "string") return [];
     const own = compactNotionId(databaseId);
     const made = loadCreatedDatabases(this.stateDb).get(own)?.databaseId;
-    const linked = [...loadLinkedDbMap(this.stateDb)].filter(([, original]) => original === own).map(([container]) => container);
+    const linked = [...loadLinkedDbMap(this.stateDb)].filter(([, original]) => original === own).map(([container2]) => container2);
     return [own, ...made ? [compactNotionId(made)] : [], ...linked];
   }
   /**
@@ -24994,69 +26470,13 @@ function blockModeBody(markdownContent) {
 function withoutDecorations(skipped) {
   return skipped.filter((key) => key !== "icon" && key !== "cover");
 }
-
-// src/converter/notion-id-links.ts
-var NOTION_ID_WIKILINK_RE = /\[\[notion:([a-f0-9]{32}|[a-f0-9-]{36})(?:(\\?\|)([^[\]]+))?\]\]/g;
-var compactId = (id) => id.replace(/-/g, "");
-function resolveNotionIdWikilinks(markdown, lookup) {
-  let resolved = 0;
-  const out = markdown.replace(
-    NOTION_ID_WIKILINK_RE,
-    (match, id, separator, rawAlias) => {
-      const path = lookup(id);
-      if (!path) return match;
-      resolved++;
-      const base = wikilinkTitleFromPath(path);
-      const alias = rawAlias === compactId(id) ? void 0 : rawAlias;
-      const link = formatWikilink(base, alias);
-      return separator === "\\|" ? link.replace("|", separator) : link;
-    }
-  );
-  return { markdown: out, resolved };
-}
-function degradeUnresolvedNotionIdWikilinks(markdown, titles = /* @__PURE__ */ new Map()) {
-  let degraded = 0;
-  const out = markdown.replace(
-    NOTION_ID_WIKILINK_RE,
-    (_match, id, _separator, alias) => {
-      degraded++;
-      const compact = compactId(id);
-      return `[${alias ?? (titles.get(compact) || compact)}](https://www.notion.so/${compact})`;
-    }
-  );
-  return { markdown: out, degraded };
-}
-function unlabeledNotionIds(markdown) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const m of markdown.matchAll(NOTION_ID_WIKILINK_RE)) {
-    if (m[3] === void 0) ids.add(compactId(m[1]));
-  }
-  return [...ids];
-}
-function linkLabelOfTitle(title) {
-  return title.replace(/[\r\n]+/g, " ").trim().replace(/\[/g, "(").replace(/\]/g, ")").replace(/[\\*_`~]/g, "\\$&");
-}
-var NOTION_RELATIVE_PAGE_LINK_RE = /\[([^\]]+)\]\(\/(?:p\/)?([a-f0-9]{32})(?:\?[^)#]*)?(?:#([^)]*))?\)/g;
-function resolveNotionRelativePageLinks(markdown, lookup) {
-  let resolved = 0;
-  const out = markdown.replace(NOTION_RELATIVE_PAGE_LINK_RE, (match, label, id) => {
-    const path = lookup(id);
-    if (!path) return match;
-    resolved++;
-    return formatWikilink(wikilinkTitleFromPath(path), label);
-  });
-  return { markdown: out, resolved };
+function trashedPageRefusal(path) {
+  return `Notion \uC5D0\uC11C \uC9C0\uC6B4 \uD398\uC774\uC9C0\uB77C \uC62C\uB9AC\uC9C0 \uC54A\uC74C \u2014 \uCDA9\uB3CC\uB85C \uB0A8\uAE34\uB2E4. \uCDA9\uB3CC \uD574\uACB0\uC5D0\uC11C \uB85C\uCEEC \uC720\uC9C0(\uC0C8 \uD398\uC774\uC9C0\uB85C \uB2E4\uC2DC \uB9CC\uB4E4\uAE30)\uB098 \uC6D0\uACA9 \uC720\uC9C0(\uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B0\uAE30)\uB97C \uACE0\uB974\uC138\uC694: ${path}`;
 }
-function degradeUnresolvedNotionRelativePageLinks(markdown) {
-  let degraded = 0;
-  const out = markdown.replace(
-    NOTION_RELATIVE_PAGE_LINK_RE,
-    (_match, label, id, anchor) => {
-      degraded++;
-      return `[${label}](https://www.notion.so/${id}${anchor === void 0 ? "" : `#${anchor}`})`;
-    }
-  );
-  return { markdown: out, degraded };
+function placedAt(page, targetId, asRow) {
+  const parent = page.parent;
+  const at = asRow ? parent.type === "data_source_id" || parent.type === "database_id" ? parent.database_id : void 0 : parent.type === "page_id" ? parent.page_id : void 0;
+  return at !== void 0 && notionIdsEqual(at, targetId);
 }
 
 // src/sync/notion-parent.ts
@@ -25129,6 +26549,15 @@ var PagePuller = class {
   claimTurns = /* @__PURE__ */ new Map();
   // Notion 에서 사라져 볼트에서 지운 페이지의 하위 폴더 — pull 이 마칠 때 비었으면 지운다({@link removeVacatedFolders}).
   vacatedFolders = /* @__PURE__ */ new Set();
+  /**
+   * 이번 pull 을 시작할 때 Notion 과 이은 노트가 하나도 없었다 — 상태 DB 를 잃었거나 처음 잇는 볼트다. 그때는 자연 이름에
+   * 있는 노트의 글이 달라도 다시 잇는다({@link relinkExistingNote}). 시작할 때 정한다 — 받는 동안 기록이 생긴다.
+   */
+  unlinkedVault = false;
+  /** 이번 pull 을 시작할 때 Notion 과 이은 노트가 하나도 없었나 — DB 행 받기도 같은 판정을 쓴다. */
+  get unlinkedVaultAtStart() {
+    return this.unlinkedVault;
+  }
   decorationsCache;
   get decorations() {
     return this.decorationsCache ??= new PageDecorations(this.notionClient, this.imageHandler);
@@ -25144,6 +26573,7 @@ var PagePuller = class {
     this._pullImageCount = 0;
     this._pullFileCount = 0;
     this.vacatedFolders.clear();
+    this.unlinkedVault = !this.stateDb.getAll().some((record) => record.notionPageId !== null);
   }
   /**
    * 이번 pull 이 지운 페이지의 폴더가 비었으면 지운다 — 안쪽부터, 그래야 바깥이 빈다. 예전에는 노트만 지우고
@@ -25263,58 +26693,147 @@ var PagePuller = class {
     const fetched = await this.fetchPageMarkdown(pageId);
     const hasChildPages = this.hasChildContainers(pageId, fetched.children);
     if (hasChildPages && !fetched.hasBody) {
-      return {
-        path: await this.createFolderOnly(pageId, page, fetched.fingerprint, parentPath, safeName)
-      };
-    }
-    let filePath;
-    let fileType;
-    if (hasChildPages) {
-      const folderPath = parentPath ? `${parentPath}/${safeName}` : safeName;
-      filePath = await this.resolveUniqueFilePath(folderPath, safeName, pageId);
-      fileType = "folder-note";
-      await this.vaultFs.ensureFolder(folderPath);
-    } else {
-      filePath = await this.resolveUniqueFilePath(parentPath, safeName, pageId);
-      fileType = "file";
-    }
-    const { content: finalContent, properties } = await this.renderPageNote({
+      return this.createFolderOnly(pageId, page, fetched.fingerprint, parentPath, safeName);
+    }
+    const fileType = hasChildPages ? "folder-note" : "file";
+    const noteDir = hasChildPages ? parentPath ? `${parentPath}/${safeName}` : safeName : parentPath;
+    if (hasChildPages) await this.vaultFs.ensureFolder(noteDir);
+    const claim = await this.resolveUniqueFilePath(noteDir, safeName, pageId, { adopt: true });
+    let filePath = claim.path;
+    const render2 = async (path, local) => await this.renderPageNote({
       pageId,
       page,
       fetched,
-      filePath,
+      filePath: path,
       title,
-      titleFollowsName: extractTitle(filePath) === title,
-      downloadMedia: true
+      titleFollowsName: extractTitle(path) === title,
+      downloadMedia: true,
+      ...local !== void 0 ? { local: { content: local, markers: [] }, adoptLocalMedia: true } : {}
     });
     const resolvedParentId = await extractParentId(this.notionClient, page);
-    await this.vaultFs.writeFile(filePath, finalContent);
-    const hash = computeHash(finalContent);
-    const pullStat = await this.vaultFs.getFileStat(filePath);
+    const note = {
+      pageId,
+      page,
+      fingerprint: fetched.fingerprint,
+      parentId: resolvedParentId,
+      fileType,
+      title
+    };
+    let rendered;
+    if (claim.existing) {
+      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;
+      this.claimedPaths.delete(filePath);
+      filePath = (await this.resolveUniqueFilePath(noteDir, safeName, pageId)).path;
+      rendered = await render2(filePath);
+    } else {
+      rendered = await render2(filePath);
+    }
+    await this.vaultFs.writeFile(filePath, rendered.content);
+    await this.recordPulledNote(filePath, note, {
+      content: rendered.content,
+      properties: rendered.properties,
+      status: "synced"
+    });
+    return { path: filePath };
+  }
+  /**
+   * 상태 기록에 없는 노트가 이 페이지가 놓일 자리에 이미 있다 — 상태 DB 를 잃었거나 처음 잇는 볼트다(P7).
+   * 예전에는 남의 노트로 보고 id 를 붙인 이름으로 또 받아 모든 노트가 두 벌이 됐다(push 는 모든 페이지를 또 만들었다).
+   *
+   * - 글이 같으면(끝 개행만 달라도) 그 노트를 이 페이지와 다시 잇는다 — 쓰지 않는다.
+   * - 다르면 이 페이지 id 를 단 이름(지난번 이 페이지를 받은 이름)이면 충돌 전략을 따른다: remote-first 는 원격으로 덮고 ·
+   *   local-first 는 로컬을 두어 다음 push 가 올리고 · 그 밖은 충돌로 남긴다(지난 사본이 없어 merge 도 합칠 수 없다).
+   * - 자연 이름에 있는 다른 글은 이은 노트가 하나도 없는 볼트에서만 잇고 전략과 상관없이 충돌로 남긴다 — 다른 노트일 수 있어
+   *   덮거나 올리면 잃는다. 이은 노트가 있는 볼트에서는 잇지 않는다(null) — 그 볼트의 새 노트일 수 있다.
+   */
+  relinkExistingNote(filePath, existing, local, rendered, note) {
+    const same = sameNoteContent(local, rendered.content) || sameAsPendingLinks(local, rendered.content);
+    if (!same && existing === "name" && !this.unlinkedVault) return null;
+    return (async () => {
+      const strategy = existing === "own" ? this.config.sync.conflictStrategy : "manual";
+      if (same || strategy === "local-first") {
+        await this.recordPulledNote(filePath, note, {
+          content: rendered.content,
+          properties: rendered.properties,
+          status: "synced",
+          // 같으면 로컬 글로 적어 바뀐 것이 없게 · local-first 는 받은 글로 적어 다음 push 가 로컬을 올리게.
+          hashOf: same ? local : rendered.content,
+          ...same ? {} : { differsOnDisk: true }
+        });
+        return { path: filePath, relinked: true };
+      }
+      if (strategy === "remote-first") {
+        await this.vaultFs.writeFile(filePath, rendered.content);
+        await this.recordPulledNote(filePath, note, {
+          content: rendered.content,
+          properties: rendered.properties,
+          status: "synced"
+        });
+        return { path: filePath, relinked: true, written: true };
+      }
+      await this.recordPulledNote(filePath, note, {
+        content: rendered.content,
+        properties: rendered.properties,
+        status: "conflict",
+        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
+      };
+      return { path: filePath, relinked: true, conflict };
+    })();
+  }
+  /**
+   * 받은 노트를 상태 기록 · 위키링크 표에 적는다. 해시는 `hashOf`(기본은 받은 글), 지난 사본은 `snapshot`(기본은 받은 글 —
+   * 충돌로 이은 노트는 공통 조상을 모르므로 null). `differsOnDisk` 는 노트가 적는 해시와 다르다는 뜻이다 — stat 을 적지 않아
+   * 변경 확인이 내용을 읽게 한다. 적으면 stat 이 맞아 바뀐 노트를 읽지 않고 지나쳤다(B5).
+   */
+  async recordPulledNote(filePath, note, input) {
+    const pullStat = input.differsOnDisk ? null : await this.vaultFs.getFileStat(filePath);
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
         obsidianPath: filePath,
-        notionPageId: pageId,
-        notionParentId: resolvedParentId,
-        contentHash: hash,
-        ...this.observation.fieldsOf(page, fetched.fingerprint),
+        notionPageId: note.pageId,
+        notionParentId: note.parentId,
+        contentHash: computeHash(input.hashOf ?? input.content),
+        ...this.observation.fieldsOf(note.page, note.fingerprint),
         localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
         syncDirection: "both",
-        fileType,
-        status: "synced",
-        baseSnapshot: Buffer.from(finalContent, "utf-8"),
+        fileType: note.fileType,
+        status: input.status,
+        baseSnapshot: input.snapshot === null ? null : Buffer.from(input.content, "utf-8"),
         localMtime: pullStat?.mtime ?? null,
         localFileSize: pullStat?.size ?? null
       });
-      const aliases = extractAliases(properties);
       this.stateDb.upsertWikilink({
         obsidianPath: filePath,
-        notionPageId: pageId,
-        title,
-        aliases
+        notionPageId: note.pageId,
+        title: note.title,
+        aliases: extractAliases(input.properties)
       });
     });
-    return { path: filePath };
   }
   /**
    * 자식 말고 본문이 없는 페이지는 폴더로만 받는다 — 노트를 쓰지 않고 폴더 경로를 추적한다(폴더 레코드).
@@ -25325,9 +26844,10 @@ var PagePuller = class {
    */
   async createFolderOnly(pageId, page, fingerprint, parentPath, safeName) {
     const folderPath = stripMarkdownExtension(
-      await this.resolveUniqueFilePath(parentPath, safeName, pageId)
+      (await this.resolveUniqueFilePath(parentPath, safeName, pageId)).path
     );
     const resolvedParentId = await extractParentId(this.notionClient, page);
+    const existed = await this.vaultFs.exists(folderPath);
     await this.vaultFs.ensureFolder(folderPath);
     this.stateDb.upsert({
       obsidianPath: folderPath,
@@ -25340,7 +26860,39 @@ var PagePuller = class {
       fileType: "folder-only",
       status: "synced"
     });
-    return folderPath;
+    return existed ? { path: folderPath, folderExisted: true } : { path: folderPath };
+  }
+  /**
+   * dry-run 이 알릴, 로컬도 고친 노트를 실제 pull({@link pullUpdate})이 어떻게 처리할지 — 받은 원격과 견주는 판정은
+   * 실제 pull 과 같다. 첨부를 내려받지 않고 렌더하며 상태 DB 를 바꾸지 않는다. 로컬을 고치지 않았거나 · 읽지 못했거나
+   * · 폴더로 추적하는 페이지면 null(받는다).
+   */
+  async previewUpdate(change) {
+    const record = this.stateDb.getByNotionId(change.pageId);
+    if (!record || isFolderRecord(record)) return null;
+    let localContent;
+    try {
+      localContent = await this.vaultFs.readFile(record.obsidianPath);
+    } catch {
+      return null;
+    }
+    if (computeHash(localContent) === record.contentHash) return null;
+    const page = await this.notionClient.getPage(change.pageId);
+    const rendered = await this.renderRemotePage(record, change.pageId, page, {
+      downloadMedia: false
+    });
+    const resolution = resolvePullConflict({
+      record,
+      localContent,
+      remoteContent: rendered.content,
+      remoteUnchanged: await this.drift.unchangedSinceSync(record, page, rendered.bodyFingerprint) || this.drift.interruptedOwnWrite(record, page, localContent),
+      remoteChange: change,
+      strategy: this.config.sync.conflictStrategy
+    });
+    if (resolution.action === "conflict") {
+      return { action: "conflict", conflict: resolution.conflict };
+    }
+    return resolution.action === "write" ? null : { action: resolution.action };
   }
   async pullUpdate(change) {
     let record = this.stateDb.getByNotionId(change.pageId);
@@ -25365,7 +26917,7 @@ var PagePuller = class {
       localContent = "";
       localExists = await this.vaultFs.exists(record.obsidianPath);
     }
-    const remoteUnchanged = localExists && await this.drift.unchangedSinceSync(record, page, rendered.bodyFingerprint);
+    const remoteUnchanged = localExists && (await this.drift.unchangedSinceSync(record, page, rendered.bodyFingerprint) || this.drift.interruptedOwnWrite(record, page, localContent));
     const resolution = resolvePullConflict({
       record,
       localContent,
@@ -25386,6 +26938,32 @@ var PagePuller = class {
       this.stateDb.updateStatus(record.id, "conflict");
       return { action: "conflict", path: record.obsidianPath, conflict: resolution.conflict };
     }
+    if (resolution.action === "merge") {
+      await this.vaultFs.writeFile(record.obsidianPath, resolution.merged);
+      this.stateDb.transaction(() => {
+        this.stateDb.upsert({
+          obsidianPath: record.obsidianPath,
+          notionPageId: change.pageId,
+          notionParentId: record.notionParentId,
+          contentHash: computeHash(remoteContent),
+          ...this.observation.fieldsOf(page, rendered.bodyFingerprint),
+          localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+          syncDirection: record.syncDirection,
+          fileType: record.fileType,
+          status: "synced",
+          baseSnapshot: Buffer.from(remoteContent, "utf-8"),
+          localMtime: null,
+          localFileSize: null
+        });
+        this.stateDb.upsertWikilink({
+          obsidianPath: record.obsidianPath,
+          notionPageId: change.pageId,
+          title: rendered.title,
+          aliases: extractAliases(rendered.properties)
+        });
+      });
+      return { action: "merged", path: record.obsidianPath };
+    }
     if (localExists && sameNoteContent(remoteContent, localContent)) {
       const stat2 = await this.vaultFs.getFileStat(record.obsidianPath);
       this.stateDb.upsert({
@@ -25509,7 +27087,7 @@ var PagePuller = class {
       properties = this.propertyMapper.fromNotionProperties(raw);
       notionKeys = [...this.propertyMapper.ownedKeys(raw), "title", ...DECORATION_KEYS];
     } else {
-      properties = this.notionClient.extractProperties(page);
+      properties = { ...this.notionClient.extractProperties(page) };
     }
     if (isDatabaseMode(this.config) || !input.titleFollowsName) {
       properties.title = title;
@@ -25521,7 +27099,8 @@ var PagePuller = class {
     let markdown = await this.imageHandler.restoreUploadedMedia(
       input.fetched.content,
       pageId,
-      filePath
+      filePath,
+      input.adoptLocalMedia ? input.local?.content : void 0
     );
     if (input.downloadMedia && this.config.conversion.imageDownload === "immediate") {
       const imageResult = await this.imageHandler.downloadAllImages(markdown, title, pageId);
@@ -25566,8 +27145,11 @@ var PagePuller = class {
         this.discovery.collectInlineDbRefs(pageId, result.markdown);
         this.detector.noteBodyChildren(pageId, result.markdown);
         return {
-          content: this.resolveNotionIdWikilinks(
-            await notionBodyToObsidian(this.notionClient, result.markdown, pageId)
+          content: await this.resolveBlockLinks(
+            this.resolveNotionIdWikilinks(
+              await notionBodyToObsidian(this.notionClient, result.markdown, pageId)
+            ),
+            pageId
           ),
           // 압축형 판정은 반드시 원시 export 기준 — enhanced 변환이 <empty-block/> 을
           // 빈 줄로 바꾼 뒤에는 BlockSpacer 가 저작형과 구분할 수 없다(D1).
@@ -25586,7 +27168,10 @@ var PagePuller = class {
     this.discovery.collectInlineDbRefs(pageId, fallback.markdown);
     this.detector.noteBodyChildren(pageId, fallback.markdown);
     return {
-      content: this.resolveNotionIdWikilinks(fallback.content),
+      content: await this.resolveBlockLinks(
+        this.resolveNotionIdWikilinks(fallback.content),
+        pageId
+      ),
       compact: isCompactExport(fallback.markdown),
       children: extractChildTags(fallback.markdown),
       fingerprint: null,
@@ -25725,15 +27310,38 @@ var PagePuller = class {
    * 파일 1개·레코드 1건). 그래서 마지막 확인과 등록을 **await 없는 동기 구간**에 묶는다 —
    * 그 사이에는 다른 작업이 끼어들 수 없으므로 두 페이지가 같은 경로를 얻는 일이 없다.
    */
-  async resolveUniqueFilePath(dir, safeName, pageId) {
+  async resolveUniqueFilePath(dir, safeName, pageId, options) {
     const turn = this.claimTurns.get(normalizeNotionId(pageId));
     await turn?.previous;
     try {
-      return await this.claimFilePath(dir, safeName, pageId);
+      if (options?.adopt) {
+        const existing = await this.claimExistingNote(dir, safeName, pageId);
+        if (existing) return existing;
+      }
+      return { path: await this.claimFilePath(dir, safeName, pageId) };
     } finally {
       turn?.release();
     }
   }
+  /**
+   * 상태 기록에 없는 노트가 이미 있는 자리를 고른다 — 이 페이지 id 를 단 이름(지난번 이 페이지를 받은 이름)이 먼저, 그 다음 자연
+   * 이름. 다시 이을지는 받은 글과 견줘 호출측이 정한다({@link relinkExistingNote}) — 잇지 않으면 장부에서 지운다.
+   */
+  async claimExistingNote(dir, safeName, pageId) {
+    const [natural, ...suffixed] = pagePathCandidates(dir, safeName, pageId);
+    const order = [
+      ...suffixed.map((path) => [path, "own"]),
+      [natural, "name"]
+    ];
+    for (const [candidate, existing] of order) {
+      if (this.claimedPaths.has(candidate) || this.stateDb.getByPath(candidate)) continue;
+      if (!await this.vaultFs.exists(candidate)) continue;
+      if (this.claimedPaths.has(candidate)) continue;
+      this.claimedPaths.add(candidate);
+      return { path: candidate, existing };
+    }
+    return null;
+  }
   async claimFilePath(dir, safeName, pageId) {
     const candidates = pagePathCandidates(dir, safeName, pageId);
     for (const candidate of candidates) {
@@ -25764,6 +27372,17 @@ var PagePuller = class {
       (id) => this.stateDb.getByNotionId(normalizeNotionId(id))?.obsidianPath ?? null
     ).markdown;
   }
+  /**
+   * 볼트에 있는 페이지로 가는 블록 링크를 `[[노트#제목]]` 으로 — 그 블록을 읽어 앵커를 안다(anchor-links). 아직 받지
+   * 않은 페이지로 가는 것은 pull 끝의 링크 패스가 푼다.
+   */
+  async resolveBlockLinks(markdown, pageId) {
+    const pathOf = (id) => this.stateDb.getByNotionId(normalizeNotionId(id))?.obsidianPath ?? null;
+    const blockIds = notionBlockLinkIds(markdown, pathOf);
+    if (blockIds.length === 0) return markdown;
+    const anchors = await readBlockAnchors(this.notionClient, blockIds);
+    return resolveNotionBlockLinks(markdown, pathOf, (id) => anchors.get(id) ?? null, pageId).markdown;
+  }
   async ensureDbSchema() {
     if (this.dbSchemaLoaded || !isDatabaseMode(this.config)) return;
     const schema = await this.notionClient.getDatabaseSchema(this.config.notion.databaseId);
@@ -25813,7 +27432,7 @@ function resolveFrontmatterRelations(content, idToTitle) {
 }
 
 // src/sync/notion-link-pass.ts
-async function resolveNotionLinks(stateDb, vaultFs, paths, pageTitle) {
+async function resolveNotionLinks(stateDb, vaultFs, paths, pageTitle, blockAnchors) {
   let totalResolved = 0;
   let totalDegraded = 0;
   const titles = /* @__PURE__ */ new Map();
@@ -25848,6 +27467,21 @@ async function resolveNotionLinks(stateDb, vaultFs, paths, pageTitle) {
         totalResolved += urlPass.resolved;
         changed = true;
       }
+      const blockIds = blockAnchors ? notionBlockLinkIds(content, notionIdToPath) : [];
+      if (blockIds.length > 0) {
+        const anchors = await blockAnchors(blockIds);
+        const blockPass = resolveNotionBlockLinks(
+          content,
+          notionIdToPath,
+          (id) => anchors.get(id) ?? null,
+          stateDb.getByPath(filePath)?.notionPageId ?? null
+        );
+        content = blockPass.markdown;
+        if (blockPass.resolved > 0) {
+          totalResolved += blockPass.resolved;
+          changed = true;
+        }
+      }
       const fm = resolveFrontmatterRelations(content, idToTitle);
       if (fm.count > 0) {
         content = fm.content;
@@ -25933,19 +27567,38 @@ var PullPlanner = class {
   async planPull(filtered, restoreChanges, restoreIds, localPlan, options, startTime, scan, ledger) {
     const unchangedDropped = await this.drift.withoutUnchangedRemotes(filtered, options.signal);
     const planned = [];
+    const failed = [];
+    const conflicts = [];
+    const mergedPaths = [];
     for (const change of unchangedDropped) {
       if (change.type === "deleted" && !await this.plannedRemoteDeletion(change)) continue;
       if (change.type === "modified" && !await this.plannedFolderPage(change)) continue;
+      if (change.type === "modified" && !restoreIds.has(change.pageId)) {
+        const resolution = await this.previewUpdate(change, failed);
+        if (resolution === void 0) continue;
+        if (resolution?.action === "conflict") {
+          conflicts.push(resolution.conflict);
+          continue;
+        }
+        if (resolution?.action === "skip") continue;
+        if (resolution?.action === "merge") {
+          mergedPaths.push(this.stateDb.getByNotionId(change.pageId).obsidianPath);
+        }
+      }
       planned.push(change);
     }
-    const failed = [];
     const queued = new Set(
       [...filtered, ...restoreChanges].map((change) => compactNotionId(change.pageId))
     );
     const movingInVault = new Set(localPlan?.scan.adoptions.map((adoption) => adoption.record.id));
-    const rows = (await this.planDatabaseRows(options.paths, failed, ledger, movingInVault)).filter(
-      (row) => !queued.has(compactNotionId(row.pageId))
-    );
+    const rows = [];
+    for (const row of await this.planDatabaseRows(options.paths, failed, ledger, movingInVault)) {
+      if (queued.has(compactNotionId(row.pageId))) continue;
+      if (row.resolution?.action === "conflict") conflicts.push(row.resolution.conflict);
+      else if (row.resolution?.action === "merge") mergedPaths.push(row.path);
+      if (row.resolution?.action === "conflict" || row.resolution?.action === "skip") continue;
+      rows.push(row);
+    }
     const items = [];
     const plannedPath = this.planner.plannedPaths(localPlan);
     for (const change of [...planned, ...restoreChanges]) {
@@ -25979,7 +27632,8 @@ var PullPlanner = class {
       restored: restoreChanges.length + restoredModified + rowCount("update", true),
       ...restoredPaths.length > 0 ? { restoredPaths } : {},
       ...movedRows.length > 0 ? { moved: movedRows.flatMap((row) => row.moves) } : {},
-      conflicts: [],
+      conflicts,
+      ...mergedPaths.length > 0 ? { mergedPaths } : {},
       writtenPaths: [],
       failed,
       duration: Date.now() - startTime,
@@ -26009,6 +27663,22 @@ var PullPlanner = class {
       return true;
     }
   }
+  /**
+   * 로컬도 고친 노트를 실제 pull 이 어떻게 처리할지({@link PagePuller.previewUpdate}). 원격을 읽지 못했으면 실제
+   * pull 도 그 노트에서 실패한다 — 실패로 싣고 undefined(세지 않는다).
+   */
+  async previewUpdate(change, failed) {
+    try {
+      return await this.puller.previewUpdate(change);
+    } catch (error) {
+      failed.push({
+        path: this.stateDb.getByNotionId(change.pageId)?.obsidianPath ?? change.pageId,
+        operation: "update",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return void 0;
+    }
+  }
   /** 원격에서 지운 페이지를 실제 pull 이 볼트에서 지우는가 — `PagePuller.pullDelete` 와 같게 가른다. */
   async plannedRemoteDeletion(change) {
     const record = this.stateDb.getByNotionId(change.pageId);
@@ -26733,7 +28403,7 @@ async function detectMissingLocalFiles(config, stateDb, vaultFs, paths) {
 }
 var LAST_SYNC_META_KEY = "last_sync_at";
 var SyncOrchestrator = class {
-  constructor(config, stateDb, notionClient, vaultFs, customFetch) {
+  constructor(config, stateDb, notionClient, vaultFs, customFetch, outside) {
     this.config = config;
     this.stateDb = stateDb;
     this.notionClient = notionClient;
@@ -26866,7 +28536,7 @@ var SyncOrchestrator = class {
       async (pageId) => this.detector.discoveredPage(pageId) ?? await notionClient.getPage(pageId),
       config.notion.databases ?? []
     );
-    this.linkUpdater = new LinkUpdater(stateDb, vaultFs);
+    this.linkUpdater = new LinkUpdater(stateDb, vaultFs, outside);
     this.puller = new PagePuller(
       config,
       stateDb,
@@ -26982,7 +28652,15 @@ var SyncOrchestrator = class {
     const foreign = this.stateDb.getAll().map((record) => record.obsidianPath).filter((path) => !vaultFs.ownsPath(path));
     if (foreign.length > 0) throw new ConnectionScopeError(foreign);
   }
-  async executePush(options) {
+  /**
+   * @param mergedByPull sync dry-run 만 — 앞선 pull dry-run 이 합칠 노트. 실제 sync 는 합친 뒤 원격을 본 것으로
+   *   적어 push 가 올린다 — dry-run 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
+   */
+  /**
+   * @param relinkedByPull 같은 sync 의 dry-run pull 이 다시 이을 것이라고 미리 봤다 — 실제 sync 는 받으며 먼저 잇고 올리므로
+   *   상태 기록이 비었어도 막지 않는다({@link assertVaultLinked}).
+   */
+  async executePush(options, mergedByPull = /* @__PURE__ */ new Set(), relinkedByPull = false) {
     const startTime = Date.now();
     this.assertConnectionScope();
     if (this.config.sync.direction === "pull") {
@@ -27013,13 +28691,25 @@ var SyncOrchestrator = class {
     const conflictPaths = new Set(this.stateDb.getByStatus("conflict").map((r) => r.obsidianPath));
     const eligible = options?.force ? changes : changes.filter((c) => !conflictPaths.has(c.path));
     const excludeSet = options?.excludePaths ? new Set(options.excludePaths) : null;
-    const filtered = (options?.paths ? eligible.filter((c) => inAnyPathScope(c.path, options.paths)) : eligible).filter((c) => !excludeSet || !excludeSet.has(c.path));
+    const scoped = (options?.paths ? eligible.filter((c) => inAnyPathScope(c.path, options.paths)) : eligible).filter((c) => !excludeSet || !excludeSet.has(c.path));
+    const unverified = relinkedByPull ? /* @__PURE__ */ new Map() : await assertVaultLinked(
+      this.config,
+      this.stateDb,
+      this.notionClient,
+      scoped.filter((c) => c.type === "created").map((c) => c.path)
+    );
+    const filtered = scoped.filter((c) => !unverified.has(c.path));
+    const unverifiedFailures = [...unverified].map(([path, error]) => ({
+      path,
+      operation: "create",
+      error
+    }));
     const folderMoves = this.planner.pendingFolderMoves(plan).filter((move) => inAnyPathScope(move.to, options?.paths));
     const inScope = (path) => inAnyPathScope(path, options?.paths) && !excludeSet?.has(path);
     const sidecarPlan = await this.sidecarEdits.plan(inScope);
     const plannedEdits = sidecarPlan.planned.map((edit) => edit.edit);
     const viewPlan = await this.viewEdits.plan(inScope);
-    const plannedViews = viewPlan.planned.flatMap((file) => file.views.map((view2) => view2.edit));
+    const plannedViews = viewPlan.planned.flatMap(plannedViewEdits);
     const preparedDatabases = loadPreparedDatabases(this.stateDb).size > 0;
     const recordedLookup = this.placement.folderLookup();
     const databaseMoves = mergeDatabaseMoves(
@@ -27045,7 +28735,13 @@ var SyncOrchestrator = class {
         updated: 0,
         deleted: 0,
         moved: 0,
-        failed: [...sidecarPlan.refused, ...edited2.failed, ...viewPlan.refused, ...viewed2.failed],
+        failed: [
+          ...unverifiedFailures,
+          ...sidecarPlan.refused,
+          ...edited2.failed,
+          ...viewPlan.refused,
+          ...viewed2.failed
+        ],
         duration: Date.now() - startTime,
         ...edited2.applied.length > 0 ? { schemaEdits: edited2.applied } : {},
         ...viewed2.applied.length > 0 ? { viewEdits: viewed2.applied } : {}
@@ -27078,7 +28774,12 @@ var SyncOrchestrator = class {
     const applicable = placeable2.filter((c) => !renameRefused.has(c.path));
     const plannedRenames = renames.planned.map(({ folder, from, to }) => ({ folder, from, to }));
     if (options?.dryRun) {
-      const planned = this.config.sync.deleteSync ? applicable : applicable.filter((c) => c.type !== "deleted");
+      await this.observation.resolveBotUserId();
+      const remoteRefusals = await this.pusher.previewRemoteRefusals(
+        applicable.filter((change) => !mergedByPull.has(change.path))
+      );
+      const remoteRefused = new Set(remoteRefusals.map((failure) => failure.path));
+      const planned = (this.config.sync.deleteSync ? applicable : applicable.filter((c) => c.type !== "deleted")).filter((change) => !remoteRefused.has(change.path));
       const items = [
         ...movableFolders.map(({ to }) => ({ path: to, operation: "move" })),
         ...planned.map((change) => ({ path: change.path, operation: pushOperationOf(change) }))
@@ -27109,7 +28810,12 @@ var SyncOrchestrator = class {
         updated: count("update") - convertedUpdates,
         deleted: count("delete"),
         moved: count("move") + preparedConversions.length + movableDatabases.length,
-        failed: [...refusedFailures, ...refusedDatabaseMoves],
+        failed: [
+          ...unverifiedFailures,
+          ...refusedFailures,
+          ...refusedDatabaseMoves,
+          ...remoteRefusals
+        ],
         duration: Date.now() - startTime,
         ...unsentDeletions2.length > 0 ? { unsentDeletions: unsentDeletions2 } : {},
         ...readOnlySkipped.length > 0 ? { readOnlySkipped } : {},
@@ -27123,7 +28829,7 @@ var SyncOrchestrator = class {
     this.stateDb.setMeta(PUSH_IN_PROGRESS_META_KEY, "true");
     await this.observation.resolveBotUserId();
     const counts = { created: 0, updated: 0, deleted: 0, moved: 0 };
-    const failed = [...refusedFailures];
+    const failed = [...unverifiedFailures, ...refusedFailures];
     const edited = await this.sidecarEdits.apply(sidecarPlan.planned);
     failed.push(...edited.failed);
     const viewed = await this.viewEdits.apply(viewPlan.planned);
@@ -27418,8 +29124,10 @@ var SyncOrchestrator = class {
     const startTime = Date.now();
     this.assertConnectionScope();
     this.puller.beginPull();
+    this.databaseSyncer.beginPull(this.puller.unlinkedVaultAtStart);
     this.rowSchemas.clear();
     this.databaseSyncer.takeRestoredRows();
+    this.databaseSyncer.takeMergedRows();
     this.databaseSyncer.takeSchemaFollowed();
     this.databaseSyncer.takeHeldSidecars();
     this.databaseSyncer.takeHeldBases();
@@ -27459,6 +29167,8 @@ var SyncOrchestrator = class {
     const conflicts = [];
     const writtenPaths = [];
     const restoredPaths = [];
+    const mergedPaths = [];
+    const relinkedPaths = [];
     const excluded = [];
     const failed = [];
     let detected = [];
@@ -27505,10 +29215,15 @@ var SyncOrchestrator = class {
       await this.puller.removeVacatedFolders();
       const renamedRows = this.databaseSyncer.takeRenamedRows();
       restoredPaths.push(...this.databaseSyncer.takeRestoredRows());
+      mergedPaths.push(...this.databaseSyncer.takeMergedRows());
+      relinkedPaths.push(...this.databaseSyncer.takeRelinkedRows());
       const schemaFollowed = this.databaseSyncer.takeSchemaFollowed();
       const heldSidecars = this.databaseSyncer.takeHeldSidecars();
       const heldBases = this.databaseSyncer.takeHeldBases();
-      const relinked = await this.linkUpdater.apply([...relocated.applied, ...renamedRows.applied]);
+      const relinked = [
+        ...await this.linkUpdater.apply([...relocated.applied, ...renamedRows.applied]),
+        ...await this.linkUpdater.dropEmbeds(this.databaseSyncer.takeRetiredBases())
+      ];
       const linkCount = writtenPaths.length > 0 ? await this.resolveNotionLinks(writtenPaths) : 0;
       if (!options?.paths) {
         const startedAt = new Date(startTime).toISOString();
@@ -27533,6 +29248,8 @@ var SyncOrchestrator = class {
         deleted,
         restored,
         ...restoredPaths.length > 0 ? { restoredPaths } : {},
+        ...mergedPaths.length > 0 ? { mergedPaths } : {},
+        ...relinkedPaths.length > 0 ? { relinkedPaths } : {},
         ...schemaFollowed.length > 0 ? { schemaFollowed } : {},
         ...heldSidecars.length > 0 ? { heldSidecars } : {},
         ...heldBases.length > 0 ? { heldBases } : {},
@@ -27605,7 +29322,8 @@ var SyncOrchestrator = class {
         },
         moved: [...relocated.moved, ...plan.moved ?? []],
         moveSkipped: relocated.skipped,
-        excluded: [...exclusions.values()]
+        excluded: [...exclusions.values()],
+        ...this.puller.unlinkedVaultAtStart && plan.created > 0 ? { relinkPending: true } : {}
       };
     }
     let pullTotal = workItems.length;
@@ -27687,6 +29405,14 @@ var SyncOrchestrator = class {
             excluded.push(created.path);
             return { path: created.path, unchanged: true };
           }
+          if (created.folderExisted) return { path: created.path, unchanged: true };
+          if (created.relinked) {
+            relinkedPaths.push(created.path);
+            if (created.conflict) conflicts.push(created.conflict);
+            if (!created.written) return { path: created.path, unchanged: true };
+            writtenPaths.push(created.path);
+            return { path: created.path, unchanged: false };
+          }
           writtenPaths.push(created.path);
           counts.created++;
           return { path: created.path, unchanged: false };
@@ -27695,6 +29421,9 @@ var SyncOrchestrator = class {
           const outcome = await this.puller.pullUpdate(change);
           if (outcome.action === "conflict") {
             conflicts.push(outcome.conflict);
+          } else if (outcome.action === "merged") {
+            counts.updated++;
+            mergedPaths.push(outcome.path);
           } else if (outcome.action === "written") {
             writtenPaths.push(outcome.path);
             if (restoreIds.has(change.pageId)) {
@@ -27805,12 +29534,17 @@ var SyncOrchestrator = class {
     const onProgress = options?.onProgress;
     const tagged = (direction) => onProgress && ((current, total, item) => onProgress(current, total, { ...item, direction }));
     const pullResult = await this.executePull({ ...options, onProgress: tagged("pull") });
-    const pushResult = await this.executePush({
-      ...options,
-      onProgress: tagged("push"),
-      paths: options?.paths,
-      excludePaths: pullResult.writtenPaths
-    });
+    const conflicted = options?.dryRun ? pullResult.conflicts.map((conflict) => conflict.syncRecord.obsidianPath) : [];
+    const pushResult = await this.executePush(
+      {
+        ...options,
+        onProgress: tagged("push"),
+        paths: options?.paths,
+        excludePaths: [...pullResult.writtenPaths, ...conflicted]
+      },
+      new Set(options?.dryRun ? pullResult.mergedPaths ?? [] : []),
+      pullResult.relinkPending === true
+    );
     return {
       pull: pullResult,
       push: pushResult,
@@ -27838,6 +29572,7 @@ var SyncOrchestrator = class {
     const detected = await this.drift.withoutUnchangedRemotes(detection.changes, signal);
     const moves = await this.followRemoteMoves({ dryRun: true }, plan);
     const renames = await this.followRemoteRenames(detected, { dryRun: true });
+    const rowRenames = await this.previewRowRenames(detected, signal);
     const exclusions = await this.plannedExclusions(detected);
     const remoteChanges = detected.filter((change) => !exclusions.has(change.pageId));
     const conflictRecords = this.stateDb.getByStatus("conflict");
@@ -27858,11 +29593,45 @@ var SyncOrchestrator = class {
       lastSyncAt,
       lastFullScanAt,
       remoteScan: remoteScanInfo(scan, lastFullScanAt, this.config.sync.deleteSync),
-      remoteMoves: [...moves.moved, ...renames.renamed],
-      remoteMoveSkipped: [...moves.skipped, ...renames.skipped],
+      remoteMoves: [...moves.moved, ...renames.renamed, ...rowRenames.renamed],
+      remoteMoveSkipped: [...moves.skipped, ...renames.skipped, ...rowRenames.skipped],
       remoteExcluded: [...exclusions.values()]
     };
   }
+  /**
+   * 다음 pull 이 Notion 에서 바꾼 제목으로 이름을 바꿀 행 — 바꾸지 않고 본다. 행 이름은 DB 받기가 바꾸므로
+   * 페이지 이름 바꾸기({@link followRemoteRenames})에 없다. 판정은 받기와 같다(`retitledRowTarget`).
+   */
+  async previewRowRenames(changes, signal) {
+    const renamed = [];
+    const skipped = [];
+    if (!this.config.sync.renameOnTitleChange) return { renamed, skipped };
+    const folders = /* @__PURE__ */ new Map();
+    for (const db of [
+      ...this.config.notion.databases ?? [],
+      ...parseDiscoveredDbs(this.stateDb.getMeta(DISCOVERED_DBS_META_KEY))
+    ]) {
+      if (db.databaseId) folders.set(compactNotionId(db.databaseId), db.localFolder);
+    }
+    for (const change of changes) {
+      throwIfAborted(signal);
+      if (change.type !== "modified") continue;
+      const record = this.stateDb.getByNotionId(change.pageId);
+      if (record?.fileType !== "db-row" || !record.notionParentId) continue;
+      if (this.vaultFs.excludesPath?.(record.obsidianPath)) continue;
+      const folder = folders.get(compactNotionId(record.notionParentId));
+      if (folder === void 0) continue;
+      try {
+        const page = this.detector.discoveredPage(change.pageId) ?? await this.notionClient.getPage(change.pageId);
+        const target = await this.databaseSyncer.retitledRowTarget(folder, record, page);
+        if (target === null) continue;
+        if ("reason" in target) skipped.push({ path: record.obsidianPath, reason: target.reason });
+        else renamed.push({ from: record.obsidianPath, to: target.to, renamed: true });
+      } catch {
+      }
+    }
+    return { renamed, skipped };
+  }
   /**
    * 로컬만 본다 — 원격 기준을 정하지 않아 도는 작업과 겹쳐도 된다. 변경은 push 가 쓰는 판정 그대로다
    * (옮긴 노트 · 폴더 포함). 상태 DB 는 바꾸지 않는다.
@@ -27955,7 +29724,8 @@ var SyncOrchestrator = class {
       this.stateDb,
       this.vaultFs,
       paths,
-      async (pageId) => this.notionClient.extractTitle(await this.notionClient.getPage(pageId))
+      async (pageId) => this.notionClient.extractTitle(await this.notionClient.getPage(pageId)),
+      (blockIds) => readBlockAnchors(this.notionClient, blockIds)
     );
   }
   // ──────────────────────────────────────────────────────────────────────────
@@ -28010,6 +29780,19 @@ var SyncOrchestrator = class {
   async discardLocalChange(path) {
     return this.gate.run("discard", () => this.inspector.discardLocalChange(path));
   }
+  /**
+   * 동기화가 옮긴 폴더를 가리키는 사용자 `.base` 의 폴더 필터 — 말없이 고치지 않고 고칠지 묻는다. 없으면 빈 목록.
+   */
+  userBaseFilterFixes() {
+    return pendingUserBaseFilterFixes(this.stateDb);
+  }
+  /** {@link userBaseFilterFixes} 를 물은 답대로 — 고치면 고친 `.base` 경로. 어느 쪽이든 다시 묻지 않는다. */
+  async resolveUserBaseFilterFixes(accept) {
+    return this.gate.run(
+      "base-filters",
+      () => resolveUserBaseFilterFixes(this.vaultFs, this.stateDb, accept)
+    );
+  }
   /**
    * 볼트에서 만든 노트 폴더를 Notion DB 로 올릴 준비 — frontmatter · `.base` 로 사이드카를 써 둔다(#75).
    * Notion 에는 쓰지 않는다. 다음 push 가 DB 를 만들고 노트를 행으로 올린다(ADR-036 · ADR-037).
@@ -28141,10 +29924,14 @@ function matchesWithin(path, pattern) {
 
 // src/sync/node-vault-fs.ts
 var NodeVaultFS = class {
-  constructor(rootPath, pathConfig) {
+  /**
+   * @param ignoreFile 폴더의 `.im-nobsidian-ignore` 를 따른다 — 볼트 전체를 보는 쪽(다른 연결의 노트에서 링크를 고칠 때)은
+   *   그 폴더를 맡은 연결의 제외 목록을 따르지 않는다.
+   */
+  constructor(rootPath, pathConfig, ignoreFile = true) {
     this.rootPath = rootPath;
     const configExclude = pathConfig?.exclude ?? [];
-    const ignorePatterns = this.loadImNobsidianIgnore();
+    const ignorePatterns = ignoreFile ? this.loadImNobsidianIgnore() : [];
     this.filter = new PathFilter(pathConfig?.include ?? [], [...configExclude, ...ignorePatterns]);
   }
   rootPath;
@@ -29383,6 +31170,6 @@ function formatRatio(ratio) {
   return String(Math.round(ratio * 100) / 100);
 }
 
-export { BaseFileGenerator, BlankLineCollapser, CONFIG_FILE, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConnectionBoundaryError, ConnectionScopeError, ConversionPipeline, DB_VIEWS_FILE, DB_VIEWS_PATH, DEFAULT_CONFIG, DEFAULT_TITLE_PROPERTY, DEFAULT_WATCH_DEBOUNCE_MS, DIFF_SIGN, DatabaseSyncer, EmbedResolver, EntryEditor, FileHandler, FileWatcher, FilteredVaultFS, FrontmatterExtractor, FrontmatterGenerator, GITIGNORE_ENTRY, IGNORE_FILE, INTERNAL_DIR, INTERNAL_DIR_GLOB, ImageHandler, InlineAnnotationPreserver, InlineDBParser, LocalImageRestorer, MARKER_BRAND, MathNormalizer, MentionToWikilink, NOTION_COLOR_NAMES, NOTION_TOKEN_PREFIX, NOTION_TO_BASES_VIEW, NodeVaultFS, NotionBlockBuilder, NotionClient2 as NotionClient, OBSIDIAN_CONFIG_DIR, PathFilter, PendingWalError, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, RENDER_LINE_RULES, SAVED_STATE_TABLES_QUERY, SEPARATOR_BODY, STATE_DB_FILE, STATE_DB_MIGRATIONS, STATE_DB_PATH, SavedStateDbError, ScopedVaultFS, SidecarGenerator, StateDB, StateDbLockedError, StateDbUnavailableError, StateLock, SyncBusyError, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, ViewDataProvider, WIKILINK_LOOKUPS, WatchSyncService, WikilinkResolver, applicableChoices, assertNoPendingWal, basesViewMappingOf, basesViewTypeOf, choiceForStrategy, classifyBodyFidelity, columnLabel, compactNotionId, computeBufferHash, computeHash, configDirFrom, connectionFolderOf, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, findConnectionFolders, findNestedFolderPages, formatUnifiedDiff, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, hasColumnLayout, hasDesignMarker, inAnyPathScope, isHeadingLine, isHeadingMarkerLine, isInternalPath, isMarkdownPath, isRemoteDeletion, lineDiff, lintRenderedMarkdown, matchesPathScope, normalizeNotionId, normalizeVaultPath, noteNameFromPath, notionIdFromInput, notionIdsEqual, operationLabel, parseDesignColor, parseIgnorePatterns, pendingWalBytes, readColumnLayout, readDesignLine, resolvePropertyName, sanitizeFileName, sectionLinesWithHeadingMarkers, setLogger, shortNotionId, sortEntries, stateDbLockPath, stateDbWalPath, stripMarkdownExtension, summarizeFidelity, systemTimeZone, threeWayMerge, toVaultPath, translateNotionFilter, verifyDatabaseCompleteness, verifyPageCompleteness, wikilinkLookupsIn };
+export { BaseFileGenerator, BlankLineCollapser, CONFIG_FILE, CONFLICT_STRATEGIES, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConnectionBoundaryError, ConnectionScopeError, ConversionPipeline, DB_VIEWS_FILE, DB_VIEWS_PATH, DEFAULT_CONFIG, DEFAULT_TITLE_PROPERTY, DEFAULT_WATCH_DEBOUNCE_MS, DIFF_SIGN, DatabaseSyncer, EmbedResolver, EntryEditor, FileHandler, FileWatcher, FilteredVaultFS, FrontmatterExtractor, FrontmatterGenerator, GITIGNORE_ENTRY, IGNORE_FILE, INTERNAL_DIR, INTERNAL_DIR_GLOB, ImageHandler, InlineAnnotationPreserver, InlineDBParser, LocalImageRestorer, MARKER_BRAND, MathNormalizer, MentionToWikilink, NOTION_COLOR_NAMES, NOTION_TOKEN_PREFIX, NOTION_TO_BASES_VIEW, NodeVaultFS, NotionBlockBuilder, NotionClient2 as NotionClient, OBSIDIAN_CONFIG_DIR, PathFilter, PendingWalError, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, RENDER_LINE_RULES, SAVED_STATE_TABLES_QUERY, SEPARATOR_BODY, STATE_DB_FILE, STATE_DB_MIGRATIONS, STATE_DB_PATH, SavedStateDbError, ScopedVaultFS, SidecarGenerator, StateDB, StateDbLockedError, StateDbUnavailableError, StateLock, SyncBusyError, SyncOrchestrator, TreeMapper, UnlinkedVaultError, UnsupportedBlockStripper, ViewDataProvider, WIKILINK_LOOKUPS, WatchSyncService, WikilinkResolver, applicableChoices, assertNoPendingWal, basesViewMappingOf, basesViewTypeOf, choiceForStrategy, classifyBodyFidelity, columnLabel, compactNotionId, computeBufferHash, computeHash, configDirFrom, connectionFolderOf, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, findConnectionFolders, findNestedFolderPages, formatUnifiedDiff, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, hasColumnLayout, hasDesignMarker, inAnyPathScope, isHeadingLine, isHeadingMarkerLine, isInternalPath, isMarkdownPath, isRemoteDeletion, lineDiff, lintRenderedMarkdown, matchesPathScope, normalizeNotionId, normalizeVaultPath, noteNameFromPath, notionIdFromInput, notionIdsEqual, operationLabel, parseDesignColor, parseIgnorePatterns, pendingWalBytes, readColumnLayout, readDesignLine, resolvePropertyName, sanitizeFileName, sectionLinesWithHeadingMarkers, setLogger, shortNotionId, sortEntries, stateDbLockPath, stateDbWalPath, stripMarkdownExtension, summarizeFidelity, systemTimeZone, threeWayMerge, toVaultPath, translateNotionFilter, verifyDatabaseCompleteness, verifyPageCompleteness, wikilinkLookupsIn };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map