@im-nobsidian/core 0.1.12 → 0.2.0

package/dist/index.js

@@ -5,7 +5,7 @@ import Database from 'better-sqlite3';
 import { randomUUID, createHash } from 'crypto';
 import { Client, LogLevel } from '@notionhq/client';
 import { Sema } from 'async-sema';
-import matter7 from 'gray-matter';
+import matter from 'gray-matter';
 import { markdownToBlocks } from '@tryfabric/martian';
 import { NotionToMarkdown } from 'notion-to-md';
 import { readFileSync } from 'fs';
@@ -228,6 +228,9 @@ function normalizeNotionId(id) {
 function notionIdsEqual(a, b) {
   return a.replace(/-/g, "") === b.replace(/-/g, "");
 }
+function compactNotionId(id) {
+  return id.replace(/-/g, "").toLowerCase();
+}
 
 // src/state/migrations/001-initial.ts
 var INITIAL_MIGRATION = `
@@ -553,6 +556,57 @@ var StateDB = class _StateDB {
       fileSize: row.file_size
     };
   }
+  // --- pending_operations (I12 크래시 복구 WAL) ---
+  recordPendingOperation(input) {
+    const id = generateId();
+    this.db.prepare(
+      `INSERT INTO pending_operations
+          (id, sync_state_id, operation, direction, payload, status)
+        VALUES (?, ?, ?, ?, ?, 'pending')`
+    ).run(id, input.syncStateId, input.operation, input.direction, input.payload ?? null);
+    return id;
+  }
+  getIncompletePendingOperations() {
+    const rows = this.db.prepare(
+      "SELECT * FROM pending_operations WHERE status IN ('pending', 'processing') ORDER BY created_at ASC"
+    ).all();
+    return rows.map((r) => this.mapPendingRow(r));
+  }
+  getIncompleteOpByState(syncStateId, operation) {
+    const row = this.db.prepare(
+      `SELECT * FROM pending_operations
+         WHERE sync_state_id = ? AND operation = ? AND status IN ('pending', 'processing')
+         ORDER BY created_at ASC LIMIT 1`
+    ).get(syncStateId, operation);
+    return row ? this.mapPendingRow(row) : null;
+  }
+  markPendingCompleted(id) {
+    this.db.prepare(
+      "UPDATE pending_operations SET status = 'completed', completed_at = datetime('now') WHERE id = ?"
+    ).run(id);
+  }
+  markPendingFailed(id, errorMessage) {
+    this.db.prepare(
+      "UPDATE pending_operations SET status = 'failed', retry_count = retry_count + 1, error_message = ?, completed_at = datetime('now') WHERE id = ?"
+    ).run(errorMessage, id);
+  }
+  clearCompletedOperations() {
+    this.db.prepare("DELETE FROM pending_operations WHERE status IN ('completed', 'failed')").run();
+  }
+  mapPendingRow(row) {
+    return {
+      id: row.id,
+      syncStateId: row.sync_state_id,
+      operation: row.operation,
+      direction: row.direction,
+      payload: row.payload,
+      retryCount: row.retry_count,
+      errorMessage: row.error_message,
+      status: row.status,
+      createdAt: row.created_at,
+      completedAt: row.completed_at
+    };
+  }
   // --- preserve markers ---
   storePreserveMarkers(path, markers) {
     if (markers.length === 0) {
@@ -608,6 +662,9 @@ var StateDB = class _StateDB {
 // src/notion/property-mapper.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 var WIKILINK_REGEX = /^\[\[(.+?)(?:\|.+?)?\]\]$/;
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
 var PropertyMapper = class {
   schema = /* @__PURE__ */ new Map();
   wikilinkResolver = null;
@@ -768,8 +825,8 @@ var PropertyMapper = class {
   extractValue(prop) {
     switch (prop.type) {
       case "rich_text": {
-        const arr = prop.rich_text;
-        return arr?.map((t) => t.plain_text).join("") || null;
+        const arr = asArray(prop.rich_text);
+        return arr.map((t) => t.plain_text).join("") || null;
       }
       case "number":
         return prop.number;
@@ -778,8 +835,7 @@ var PropertyMapper = class {
         return sel?.name ?? null;
       }
       case "multi_select": {
-        const items = prop.multi_select;
-        return items?.map((s) => s.name) ?? [];
+        return asArray(prop.multi_select).map((s) => s.name);
       }
       case "checkbox":
         return prop.checkbox;
@@ -804,12 +860,11 @@ var PropertyMapper = class {
       case "last_edited_time":
         return prop.last_edited_time;
       case "people": {
-        const people = prop.people;
-        return people?.map((p) => p.name ?? p.id) ?? [];
+        return asArray(prop.people).map((p) => p.name ?? p.id);
       }
       case "files": {
-        const files = prop.files;
-        const urls = (files ?? []).map((f) => f.type === "file" ? f.file?.url : f.external?.url).filter((u) => typeof u === "string" && u.length > 0);
+        const files = asArray(prop.files);
+        const urls = files.map((f) => f.type === "file" ? f.file?.url : f.external?.url).filter((u) => typeof u === "string" && u.length > 0);
         if (urls.length === 0) return [];
         return urls.length === 1 ? urls[0] : urls;
       }
@@ -819,8 +874,8 @@ var PropertyMapper = class {
         return formula[formula.type];
       }
       case "relation": {
-        const rel = prop.relation;
-        if (!rel || rel.length === 0) return [];
+        const rel = asArray(prop.relation);
+        if (rel.length === 0) return [];
         return rel.map((r) => {
           if (this.wikilinkResolver) {
             const title = this.wikilinkResolver.resolvePageId(r.id);
@@ -833,14 +888,14 @@ var PropertyMapper = class {
         const rollup = prop.rollup;
         if (!rollup) return null;
         if (rollup.type === "array") {
-          const arr = rollup.array;
+          const arr = asArray(rollup.array);
           return arr.map((item) => this.extractValue(item));
         }
         return rollup[rollup.type] ?? null;
       }
       case "unique_id": {
         const uid = prop.unique_id;
-        if (!uid) return null;
+        if (!uid || typeof uid.number !== "number") return null;
         return uid.prefix ? `${uid.prefix}-${uid.number}` : String(uid.number);
       }
       case "created_by":
@@ -875,12 +930,21 @@ function getLogger() {
 }
 
 // src/notion/client.ts
+function isNotionObjectNotFound(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const e = error;
+  return e.code === "object_not_found" || e.status === 404;
+}
+var DiscoveryTooLargeError = class extends Error {
+  constructor(elapsedMs) {
+    super(`subtree discovery exceeded time budget (${elapsedMs}ms)`);
+    this.name = "DiscoveryTooLargeError";
+  }
+};
 var NotionClient = class _NotionClient {
   client;
   sema;
-  token;
   propertyMapper = new PropertyMapper();
-  customFetch;
   minRequestInterval;
   maxRetries;
   retryBaseDelayMs;
@@ -894,8 +958,6 @@ var NotionClient = class _NotionClient {
       logLevel: LogLevel.ERROR,
       ...options.fetch ? { fetch: options.fetch } : {}
     });
-    this.token = options.token;
-    this.customFetch = options.fetch;
     this.sema = new Sema(options.concurrency ?? 3);
     this.minRequestInterval = options.rateLimitIntervalMs ?? 350;
     this.maxRetries = options.maxRetries ?? 5;
@@ -1006,30 +1068,61 @@ var NotionClient = class _NotionClient {
     );
   }
   // ─── Database / DataSource ───
-  async fetchDatabaseLegacy(databaseId) {
-    const cleanId = databaseId.replace(/-/g, "");
-    const formatted = `${cleanId.slice(0, 8)}-${cleanId.slice(8, 12)}-${cleanId.slice(12, 16)}-${cleanId.slice(16, 20)}-${cleanId.slice(20)}`;
-    const resp = await this.withRateLimit(async () => {
-      const doFetch = this.customFetch ?? globalThis.fetch;
-      const r = await doFetch(`https://api.notion.com/v1/databases/${formatted}`, {
-        headers: {
-          Authorization: `Bearer ${this.token}`,
-          "Notion-Version": "2022-06-28",
-          "Content-Type": "application/json"
+  /**
+   * 데이터베이스 1개를 신 모델(2025-09-03 data source 분리)로 조회한다.
+   * - title: database 객체에 그대로 존재한다.
+   * - properties(스키마): 신 모델에선 data source 에 있으므로 1차 data source 를 조회해 채운다.
+   *   data source 접근 불가(링크드 DB 등)면 database 객체의 properties 로 폴백한다(제목은 보존).
+   *
+   * 폐기한 레거시 raw fetch(`GET /v1/databases/{id}`, Notion-Version 2022-06-28)는 신 모델로
+   * 업그레이드된 다수 DB에 400 을 반환해 자동 발견 DB 가 통째 드롭(내용 손실)되던 원인이었다.
+   * SDK(`databases.retrieve`/`dataSources.retrieve`)는 동일 토큰으로 정상 동작한다.
+   */
+  async fetchDatabaseModern(databaseId) {
+    const db = await this.withRateLimit(
+      () => this.client.databases.retrieve({ database_id: databaseId })
+    );
+    const dataSources = db.data_sources ?? [];
+    const merged = {};
+    let anyAccessible = false;
+    for (const ds of dataSources) {
+      try {
+        const dsObj = await this.withRateLimit(
+          () => this.client.dataSources.retrieve({ data_source_id: ds.id })
+        );
+        if (dsObj.properties && Object.keys(dsObj.properties).length > 0) {
+          anyAccessible = true;
+          for (const [name, prop] of Object.entries(dsObj.properties)) {
+            if (!(name in merged)) merged[name] = prop;
+          }
         }
-      });
-      if (!r.ok) throw new Error(`Database fetch failed: ${r.status}`);
-      return await r.json();
-    });
-    return resp;
+      } catch {
+      }
+    }
+    const properties = anyAccessible ? merged : db.properties ?? {};
+    return { title: db.title, properties };
   }
   async getDatabaseTitle(databaseId) {
-    const db = await this.fetchDatabaseLegacy(databaseId);
+    const db = await this.fetchDatabaseModern(databaseId);
     const titleArr = db.title;
     return titleArr?.[0]?.plain_text ?? "";
   }
+  /**
+   * 발견된 DB 가 **동기화 가능한지**(접근 가능한 data source 가 있는지) 1회 호출로 판별한다.
+   * 신 모델(2025-09-03)에서 링크드 DB·미공유 데이터 소스·삭제 DB 는 `data_sources` 가
+   * 비어, 행 조회(`dataSources.query`)가 404 로 실패하고 그 전에 생성된 빈 폴더/`.base` 만
+   * 남긴다. 발견 단계에서 미리 걸러 **빈 폴더/.base 오염 + 매 pull 의 404 노이즈**를 차단한다.
+   * 제목은 함께 반환해 호출처가 추가 조회 없이 폴더명을 잡게 한다.
+   */
+  async getDatabaseSyncability(databaseId) {
+    const db = await this.withRateLimit(
+      () => this.client.databases.retrieve({ database_id: databaseId })
+    );
+    const title = Array.isArray(db.title) ? db.title[0]?.plain_text ?? "" : "";
+    return { title, queryable: (db.data_sources?.length ?? 0) > 0 };
+  }
   async getDatabaseSchema(databaseId) {
-    const db = await this.fetchDatabaseLegacy(databaseId);
+    const db = await this.fetchDatabaseModern(databaseId);
     const properties = db.properties;
     if (!properties) return {};
     const schema = {};
@@ -1039,7 +1132,7 @@ var NotionClient = class _NotionClient {
     return schema;
   }
   async getDatabaseSchemaFull(databaseId) {
-    const db = await this.fetchDatabaseLegacy(databaseId);
+    const db = await this.fetchDatabaseModern(databaseId);
     const properties = db.properties;
     if (!properties) return {};
     const schema = {};
@@ -1071,11 +1164,11 @@ var NotionClient = class _NotionClient {
     }
     return schema;
   }
-  async queryDatabase(databaseId, options) {
-    const dsId = await this.getDataSourceId(databaseId);
+  /** 특정 data source 1개를 직접 쿼리한다(저수준). 다중 data source 순회의 빌딩블록. */
+  async queryDataSource(dataSourceId, options) {
     const response = await this.withRateLimit(
       () => this.client.dataSources.query({
-        data_source_id: dsId,
+        data_source_id: dataSourceId,
         start_cursor: options?.startCursor,
         page_size: options?.pageSize ?? this.defaultPageSize,
         filter: options?.filter
@@ -1086,26 +1179,66 @@ var NotionClient = class _NotionClient {
       nextCursor: response.next_cursor
     };
   }
+  /**
+   * database 의 1차 data source 1페이지를 쿼리한다(증분 detect 등 단일 소스 경로용).
+   * 전 행을 빠짐없이 받으려면 {@link queryAllDatabasePages} 를 쓴다(전 data source 순회).
+   */
+  async queryDatabase(databaseId, options) {
+    const dsId = await this.getDataSourceId(databaseId);
+    return this.queryDataSource(dsId, options);
+  }
+  /**
+   * database 의 **모든 data source** 행을 빠짐없이 조회한다(2025-09-03 신 모델).
+   * 한 database 가 2개 이상의 data source(각자 행 집합)를 가질 수 있어, 1차 data source 만
+   * 페이지네이션하면 2번째+ 의 행이 통째 침묵 유실된다. 전 data source 를 순회·페이지네이션
+   * 하고 page_id 로 디듀프(소스 간 동일 페이지 방어)한 뒤 합친다. 다중 소스면 1회 경고해
+   * "소스별 탭 구분이 한 폴더로 병합"되는 점을 비침묵으로 알린다.
+   */
   async queryAllDatabasePages(databaseId, filter) {
+    const metas = await this.getDataSourceMetas(databaseId);
+    if (metas.length > 1) {
+      const label = metas.map((m) => m.name || m.id).join(", ");
+      getLogger().warn(
+        `[Notion] DB ${databaseId} \uC5D0 data source ${metas.length}\uAC1C \uBC1C\uACAC \u2014 \uC804 \uC18C\uC2A4 \uD589\uC744 \uD55C \uD3F4\uB354\uB85C \uBCD1\uD569 \uB3D9\uAE30\uD654\uD569\uB2C8\uB2E4 (${label}). \uC18C\uC2A4\uBCC4 \uD0ED \uAD6C\uBD84\uC740 .base \uBDF0\uC5D0 \uBCF4\uC874\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`
+      );
+    }
     const all = [];
-    let cursor;
-    do {
-      const response = await this.queryDatabase(databaseId, {
-        startCursor: cursor,
-        pageSize: this.defaultPageSize,
-        filter
-      });
-      all.push(...response.results);
-      cursor = response.nextCursor ?? void 0;
-    } while (cursor);
+    const seen = /* @__PURE__ */ new Set();
+    for (const meta of metas) {
+      let cursor;
+      do {
+        const response = await this.queryDataSource(meta.id, {
+          startCursor: cursor,
+          pageSize: this.defaultPageSize,
+          filter
+        });
+        for (const page of response.results) {
+          const key = normalizeNotionId(page.id);
+          if (seen.has(key)) continue;
+          seen.add(key);
+          all.push(page);
+        }
+        cursor = response.nextCursor ?? void 0;
+      } while (cursor);
+    }
     return all;
   }
+  /** database 의 1차 data source id(없으면 databaseId 폴백). 단일 소스 경로 호환용. */
   async getDataSourceId(databaseId) {
+    const metas = await this.getDataSourceMetas(databaseId);
+    return metas[0]?.id ?? databaseId;
+  }
+  /**
+   * database 의 전 data source 메타(id + 이름)를 반환한다. data source 가 없으면(레거시/단일)
+   * databaseId 자체를 단일 소스로 폴백해 호출처가 항상 ≥1 개를 받게 한다.
+   */
+  async getDataSourceMetas(databaseId) {
     const db = await this.withRateLimit(
       () => this.client.databases.retrieve({ database_id: databaseId })
     );
-    const dataSources = db.data_sources;
-    return dataSources?.[0]?.id ?? databaseId;
+    const list = db.data_sources ?? [];
+    if (list.length === 0) return [{ id: databaseId, name: "" }];
+    return list.map((ds) => ({ id: ds.id, name: ds.name ?? "" }));
   }
   async archivePage(pageId) {
     await this.withRateLimit(() => this.client.pages.update({ page_id: pageId, archived: true }));
@@ -1254,32 +1387,6 @@ var NotionClient = class _NotionClient {
     } while (cursor);
     return results;
   }
-  /**
-   * 통합이 접근 가능한 모든 페이지를 search API로 일괄 조회한다(요청당 최대 100건).
-   * 블록 트리를 페이지별로 재귀 순회하는 getChildPagesRecursive 대비 API 호출 수가
-   * 페이지 수의 수십분의 1로 줄어든다. search API는 휴지통(in_trash) 페이지를 반환하지 않는다.
-   * 반환 객체에는 parent 정보가 포함되어 호출 측에서 root subtree ancestry 필터링이 가능하다.
-   */
-  async searchAllPages() {
-    const results = [];
-    let cursor;
-    do {
-      const response = await this.withRateLimit(
-        () => this.client.search({
-          filter: { property: "object", value: "page" },
-          start_cursor: cursor,
-          page_size: this.defaultPageSize
-        })
-      );
-      for (const page of response.results) {
-        if ("properties" in page) {
-          results.push(page);
-        }
-      }
-      cursor = response.next_cursor ?? void 0;
-    } while (cursor);
-    return results;
-  }
   async getChildPages(parentId) {
     const blocks = await this.fetchAllChildrenDeep(parentId);
     const childPageBlocks = blocks.filter((b) => b.type === "child_page");
@@ -1296,12 +1403,24 @@ var NotionClient = class _NotionClient {
     const children = await this.fetchAllChildren(parentId);
     return children.filter((b) => b.type === "child_database").map((b) => b.id);
   }
-  async getChildPagesRecursive(parentId) {
+  /**
+   * root 서브트리를 직접 BFS 순회해 하위 페이지를 모두 수집한다(중첩 깊이 무관·무손실).
+   * 비용은 서브트리 전체 블록 수에 비례한다.
+   *
+   * @param opts.deadlineMs `Date.now()` 기준 마감 시각. 각 페이지 처리 전 초과를 검사해
+   *   초과 시 {@link DiscoveryTooLargeError}를 던진다(대규모 서브트리 → search 폴백 유도).
+   *   미지정 시 무제한(기존 동작 유지 — 테스트 mock 경로는 영향 없음).
+   */
+  async getChildPagesRecursive(parentId, opts) {
     const all = [];
     let currentLevel = [parentId];
+    const start = Date.now();
     while (currentLevel.length > 0) {
       const nextLevel = [];
       for (const id of currentLevel) {
+        if (opts?.deadlineMs !== void 0 && Date.now() > opts.deadlineMs) {
+          throw new DiscoveryTooLargeError(Date.now() - start);
+        }
         let children;
         try {
           children = await this.getChildPages(id);
@@ -1320,6 +1439,112 @@ var NotionClient = class _NotionClient {
     }
     return all;
   }
+  /** 워크스페이스에서 통합에 공유된 모든 페이지를 bulk search 로 열거한다(100/요청). */
+  async searchAllPages() {
+    const pages = [];
+    let cursor;
+    do {
+      const r = await this.search({
+        filter: { property: "object", value: "page" },
+        startCursor: cursor
+      });
+      pages.push(...r.results);
+      cursor = r.nextCursor ?? void 0;
+    } while (cursor);
+    return pages;
+  }
+  /**
+   * root 하위 페이지를 **search 기반**으로 디스커버리한다(대규모 서브트리용 폴백).
+   *
+   * 전략: 워크스페이스 전체 페이지를 1회 bulk search 로 열거(비용 ∝ 워크스페이스 페이지 수,
+   * 예측가능·유한)한 뒤, 각 페이지의 부모 체인을 따라 root 도달 여부를 판정한다. page_id
+   * 부모는 메모리 맵으로 추가 호출 없이 즉시 해석하고, block_id 부모(컬럼·토글 등 레이아웃에
+   * 중첩된 페이지)만 getBlock 으로 소유 페이지를 해석(memo)한다. search 는 중첩 깊이와 무관하게
+   * 모든 페이지를 반환하므로 직접 순회와 동일하게 **무손실**이다.
+   *
+   * getChildPagesRecursive 와 동일 집합을 보장하기 위해:
+   *  - DB 행(parent=data_source_id/database_id)은 child_page 로 도달 불가 → 제외
+   *  - 휴지통/보관(in_trash/archived) 페이지 제외
+   *  - root 자신은 제외(직접 순회도 root 의 *자식*부터 수집)
+   */
+  async getPagesUnderRootViaSearch(rootId) {
+    const all = await this.searchAllPages();
+    const rootN = normalizeNotionId(rootId);
+    const byId = /* @__PURE__ */ new Map();
+    for (const p of all) byId.set(normalizeNotionId(p.id), p);
+    const blockOwner = /* @__PURE__ */ new Map();
+    const resolveBlockOwner = async (blockId) => {
+      let bid = blockId;
+      const seen = /* @__PURE__ */ new Set();
+      for (let i = 0; i < 20 && bid && !seen.has(bid); i++) {
+        seen.add(bid);
+        const cached = blockOwner.get(bid);
+        if (cached !== void 0) return cached;
+        let bp;
+        try {
+          bp = (await this.getBlock(bid)).parent;
+        } catch {
+          blockOwner.set(bid, null);
+          return null;
+        }
+        if (bp.type === "page_id" && bp.page_id) {
+          const owner = bp.page_id;
+          blockOwner.set(blockId, owner);
+          return owner;
+        }
+        if (bp.type === "block_id" && bp.block_id) {
+          bid = bp.block_id;
+          continue;
+        }
+        blockOwner.set(blockId, null);
+        return null;
+      }
+      return null;
+    };
+    const memo = /* @__PURE__ */ new Map();
+    const isUnderRoot = async (startId) => {
+      const chain = [];
+      let cur = normalizeNotionId(startId);
+      const seen = /* @__PURE__ */ new Set();
+      let result = false;
+      while (cur && !seen.has(cur)) {
+        if (cur === rootN) {
+          result = true;
+          break;
+        }
+        const cached = memo.get(cur);
+        if (cached !== void 0) {
+          result = cached;
+          break;
+        }
+        seen.add(cur);
+        chain.push(cur);
+        const pg = byId.get(cur);
+        if (!pg) break;
+        const parent = pg.parent;
+        if (parent.type === "page_id" && parent.page_id) {
+          cur = normalizeNotionId(parent.page_id);
+        } else if (parent.type === "block_id" && parent.block_id) {
+          const owner = await resolveBlockOwner(parent.block_id);
+          cur = owner ? normalizeNotionId(owner) : null;
+        } else {
+          cur = null;
+        }
+      }
+      for (const c of chain) memo.set(c, result);
+      return result;
+    };
+    const out = [];
+    for (const p of all) {
+      const pid = normalizeNotionId(p.id);
+      if (pid === rootN) continue;
+      const ptype = p.parent.type;
+      if (ptype === "data_source_id" || ptype === "database_id") continue;
+      if (_NotionClient.isTrashedOrArchived(p)) continue;
+      if (await isUnderRoot(p.id)) out.push(p);
+    }
+    return out;
+  }
   // ─── Views API ───
   async listDatabaseViews(databaseId) {
     const allViews = [];
@@ -1394,13 +1619,23 @@ var NotionClient = class _NotionClient {
   extractTitle(page) {
     const props = page.properties;
     for (const prop of Object.values(props)) {
-      if (prop.type === "title" && prop.title) {
+      if (prop.type === "title" && Array.isArray(prop.title)) {
         const joined = prop.title.map((t) => t.plain_text ?? "").join("");
         if (joined) return joined;
       }
     }
     return "\uC81C\uBAA9 \uC5C6\uC74C";
   }
+  /**
+   * 페이지 모드 pull(extractProperties)의 relation/people 속성을 raw Notion UUID 가
+   * 아니라 [[제목]] 위키링크로 해소하도록 resolver 를 주입한다. 주입하지 않으면 매
+   * pull 마다 relation 이 raw UUID 로 재생성돼, 후처리(resolveNotionLinks)에만 의존하는
+   * 2-write churn 이 남는다(M1). DB 모드는 orchestrator/DatabaseSyncer 의 자체 mapper 가
+   * 이미 resolver 를 주입받아 면역이다.
+   */
+  setWikilinkResolver(resolver) {
+    this.propertyMapper.setWikilinkResolver(resolver);
+  }
   extractProperties(page) {
     return this.propertyMapper.fromNotionProperties(page.properties);
   }
@@ -1980,7 +2215,6 @@ var EMBED_PROTOCOL = `${MARKER_BRAND}://embed/`;
 function spacedMarker(body) {
   return `%% ${MARKER_BRAND}:${body} %%`;
 }
-var SPACED_END = spacedMarker("end");
 function compactMarker(body) {
   return `%%${MARKER_BRAND}:${body}%%`;
 }
@@ -1990,6 +2224,7 @@ var COLUMN_LIST_START = compactMarker("column-list:start");
 var COLUMN_LIST_END = compactMarker("column-list:end");
 var COLUMN_SEP = compactMarker("column");
 var TOC_MARKER = compactMarker("toc");
+var BREADCRUMB_MARKER = compactMarker("breadcrumb");
 var PROPERTIES_TAG = `# ${MARKER_BRAND}:properties`;
 var MARKER_BRAND_RE = MARKER_BRAND;
 
@@ -2066,7 +2301,7 @@ var FrontmatterExtractor = class {
   name = "FrontmatterExtractor";
   order = 10;
   process(input) {
-    const { data, content } = matter7(input.content);
+    const { data, content } = matter(input.content);
     return {
       content: content.trim(),
       metadata: {
@@ -2286,6 +2521,11 @@ var UnsupportedBlockStripper = class {
     };
   }
 };
+function stringifyFrontmatter(content, data) {
+  return matter.stringify({ content }, data);
+}
+
+// src/converter/pre-processors/properties-table.ts
 var PropertiesTableInjector = class {
   name = "PropertiesTableInjector";
   order = 15;
@@ -2307,7 +2547,7 @@ var PropertiesTableInjector = class {
     if (Object.keys(filteredProps).length === 0) {
       return { content: input.content, metadata: input.metadata };
     }
-    const yamlStr = matter7.stringify("", filteredProps).trim();
+    const yamlStr = stringifyFrontmatter("", filteredProps).trim();
     const yamlBody = yamlStr.slice(4, -3).trim();
     const codeBlock = "```yaml\n" + PROPERTIES_TAG + "\n" + yamlBody + "\n```";
     const content = codeBlock + "\n\n---\n\n" + input.content;
@@ -2317,51 +2557,66 @@ var PropertiesTableInjector = class {
 
 // src/converter/pre-processors/html-annotation.ts
 var UNDERLINE_REGEX = /<u>([\s\S]*?)<\/u>/g;
-var COLOR_SPAN_REGEX = /<span class="notion-(\w+?)(?:-bg)?">([\s\S]*?)<\/span>/g;
-var IM_NOBSIDIAN_COLOR_REGEX = new RegExp(
+var COLOR_SPAN_REGEX = /<span class="notion-(\w+)(-bg)?">([\s\S]*?)<\/span>/g;
+var SPACED_COLOR_REGEX = new RegExp(
   `%% ${MARKER_BRAND_RE}:color:(\\w+(?:_background)?) %%([\\s\\S]*?)%% ${MARKER_BRAND_RE}:end %%`,
   "g"
 );
-var HtmlAnnotationStripper = class {
-  name = "HtmlAnnotationStripper";
+var InlineAnnotationPreserver = class {
+  name = "InlineAnnotationPreserver";
   order = 5;
   process(input) {
     if (input.context.direction !== "push") {
       return { content: input.content, metadata: input.metadata };
     }
     let content = input.content;
-    content = content.replace(IM_NOBSIDIAN_COLOR_REGEX, (_m, _color, text) => text);
-    content = content.replace(UNDERLINE_REGEX, (_m, text) => text);
-    content = content.replace(COLOR_SPAN_REGEX, (_m, _color, text) => text);
+    content = content.replace(
+      SPACED_COLOR_REGEX,
+      (_m, color, text) => `${compactMarker(`color:${color}`)}${text}%%/color%%`
+    );
+    content = content.replace(
+      UNDERLINE_REGEX,
+      (_m, text) => `${compactMarker("underline")}${text}%%/underline%%`
+    );
+    content = content.replace(
+      COLOR_SPAN_REGEX,
+      (_m, base, bg, text) => {
+        const color = bg ? `${base}_background` : base;
+        return `${compactMarker(`color:${color}`)}${text}%%/color%%`;
+      }
+    );
     return { content, metadata: input.metadata };
   }
 };
 
-// src/converter/post-processors/mention-to-wikilink.ts
+// src/converter/link-restore.ts
 var NOTION_LINK_REGEX = /\[([^\]]+)\]\((?:https:\/\/(?:www\.)?notion\.so\/|notion:\/\/)([a-f0-9-]+)\)/g;
 var WIKILINK_PRESERVE_REGEX = new RegExp(`\\[([^\\]]+)\\]\\(${WIKILINK_PROTOCOL}([^)]+)\\)`, "g");
 var EMBED_PRESERVE_REGEX = new RegExp(`\\[([^\\]]+)\\]\\(${EMBED_PROTOCOL}([^)]+)\\)`, "g");
+function restoreLinkMarkers(text) {
+  let out = text.replace(NOTION_LINK_REGEX, (_match, display) => `[[${display}]]`);
+  out = out.replace(WIKILINK_PRESERVE_REGEX, (_match, display, encodedTarget) => {
+    const target = decodeURIComponent(encodedTarget);
+    return target === display ? `[[${target}]]` : `[[${target}|${display}]]`;
+  });
+  out = out.replace(EMBED_PRESERVE_REGEX, (_match, _display, encodedTarget) => {
+    const target = decodeURIComponent(encodedTarget);
+    return `![[${target}]]`;
+  });
+  return out;
+}
+function restoreLinkMarkersInValue(value) {
+  if (typeof value === "string") return restoreLinkMarkers(value);
+  if (Array.isArray(value)) return value.map((v) => restoreLinkMarkersInValue(v));
+  return value;
+}
+
+// src/converter/post-processors/mention-to-wikilink.ts
 var MentionToWikilink = class {
   name = "MentionToWikilink";
   order = 10;
   process(input) {
-    let content = input.content;
-    content = content.replace(NOTION_LINK_REGEX, (_match, display) => `[[${display}]]`);
-    content = content.replace(
-      WIKILINK_PRESERVE_REGEX,
-      (_match, display, encodedTarget) => {
-        const target = decodeURIComponent(encodedTarget);
-        return target === display ? `[[${target}]]` : `[[${target}|${display}]]`;
-      }
-    );
-    content = content.replace(
-      EMBED_PRESERVE_REGEX,
-      (_match, _display, encodedTarget) => {
-        const target = decodeURIComponent(encodedTarget);
-        return `![[${target}]]`;
-      }
-    );
-    return { content, metadata: input.metadata };
+    return { content: restoreLinkMarkers(input.content), metadata: input.metadata };
   }
 };
 
@@ -2382,9 +2637,12 @@ var PreserveMarkerInjector = class {
     if (missingMarkers.length === 0) {
       return { content, metadata: input.metadata };
     }
-    const markerLines = missingMarkers.map((m) => this.formatMarker(m));
-    const suffix = "\n\n" + markerLines.join("\n");
-    content = content.trimEnd() + suffix + "\n";
+    const sorted = [...missingMarkers].sort((a, b) => a.startIndex - b.startIndex);
+    for (const m of sorted) {
+      const markerText = this.formatMarker(m);
+      const at = Math.max(0, Math.min(m.startIndex, content.length));
+      content = content.slice(0, at) + markerText + content.slice(at);
+    }
     return { content, metadata: input.metadata };
   }
   formatMarker(marker) {
@@ -2465,6 +2723,8 @@ var ColorAnnotator = class {
     };
   }
 };
+
+// src/converter/post-processors/frontmatter-generator.ts
 var FrontmatterGenerator = class {
   name = "FrontmatterGenerator";
   order = 90;
@@ -2473,18 +2733,20 @@ var FrontmatterGenerator = class {
     if (!properties || Object.keys(properties).length === 0) {
       return { content: input.content, metadata: input.metadata };
     }
-    const normalized = normalizeProperties(properties);
-    const content = matter7.stringify(input.content, normalized);
+    const restoreMarkers = input.context.direction === "pull";
+    const normalized = normalizeProperties(properties, restoreMarkers);
+    const content = stringifyFrontmatter(input.content, normalized);
     return {
       content,
       metadata: input.metadata
     };
   }
 };
-function normalizeProperties(props) {
+function normalizeProperties(props, restoreMarkers) {
   const result = {};
   for (const [key, value] of Object.entries(props)) {
-    const normalized = normalizeValue(value);
+    const restored = restoreMarkers ? restoreLinkMarkersInValue(value) : value;
+    const normalized = normalizeValue(restored);
     if (normalized !== void 0) {
       result[key] = normalized;
     }
@@ -2567,7 +2829,7 @@ ${yamlContent}---
 `;
     let parsed;
     try {
-      const result = matter7(fakeDocument);
+      const result = matter(fakeDocument);
       parsed = result.data;
     } catch {
       return { content: input.content, metadata: input.metadata };
@@ -2638,7 +2900,7 @@ function stripQuotes(s) {
 // src/converter/pipeline-factory.ts
 function createDefaultPipeline(options) {
   const pipeline = new ConversionPipeline();
-  pipeline.registerPreProcessor(new HtmlAnnotationStripper());
+  pipeline.registerPreProcessor(new InlineAnnotationPreserver());
   pipeline.registerPreProcessor(new UnsupportedBlockStripper());
   pipeline.registerPreProcessor(new FrontmatterExtractor());
   pipeline.registerPreProcessor(new PropertiesTableInjector());
@@ -2656,30 +2918,8 @@ function createDefaultPipeline(options) {
   pipeline.registerPostProcessor(new FrontmatterGenerator());
   return pipeline;
 }
-var TRULY_UNSUPPORTED_BLOCK_TYPES = ["unsupported", "template"];
-var DIVIDER_PLACEHOLDER = "\u200B%%IM-NOBSIDIAN_DIVIDER%%\u200B";
-var VIDEO_URL_PATTERNS = [
-  /^https?:\/\/(www\.)?youtube\.com\/watch/,
-  /^https?:\/\/youtu\.be\//,
-  /^https?:\/\/(www\.)?vimeo\.com\//,
-  /^https?:\/\/(www\.)?dailymotion\.com\//,
-  /^https?:\/\/(www\.)?loom\.com\/share\//
-];
-var EMBED_URL_PATTERNS = [
-  /^https?:\/\/(www\.)?figma\.com\//,
-  /^https?:\/\/docs\.google\.com\//,
-  /^https?:\/\/drive\.google\.com\//,
-  /^https?:\/\/(www\.)?miro\.com\//,
-  /^https?:\/\/(www\.)?twitter\.com\//,
-  /^https?:\/\/(www\.)?x\.com\//,
-  /^https?:\/\/codepen\.io\//,
-  /^https?:\/\/gist\.github\.com\//,
-  /^https?:\/\/(www\.)?spotify\.com\//,
-  /^https?:\/\/(www\.)?soundcloud\.com\//
-];
-function escapeRegex2(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+
+// src/converter/rich-text-converter.ts
 function richTextToPlain(richText) {
   if (!richText) return "";
   return richText.map((t) => t.plain_text).join("");
@@ -2691,7 +2931,7 @@ function richTextToMarkdown(richText) {
       return `$${t.equation.expression}$`;
     }
     if (t.type === "mention" && t.mention) {
-      return formatMention(t.mention);
+      return formatMention(t.mention, t.plain_text);
     }
     let text = t.plain_text;
     const a = t.annotations;
@@ -2703,28 +2943,54 @@ function richTextToMarkdown(richText) {
     if (t.href) text = `[${text}](${t.href})`;
     const color = a?.color;
     if (color && color !== "default") {
-      text = `${spacedMarker(`color:${color}`)}${text}${SPACED_END}`;
+      text = `${compactMarker(`color:${color}`)}${text}%%/color%%`;
     }
     return text;
   }).join("");
 }
-function formatMention(mention) {
+function formatMention(mention, plainText) {
   switch (mention.type) {
     case "page":
-      return mention.page ? `[[${mention.page.id}]]` : "";
+      return mention.page ? `[[notion:${compactNotionId(mention.page.id)}]]` : plainText;
     case "date": {
-      if (!mention.date) return "";
+      if (!mention.date) return plainText;
       const start = mention.date.start;
       return mention.date.end ? `${start} \u2192 ${mention.date.end}` : start;
     }
     case "user":
-      return mention.user?.name ? `@${mention.user.name}` : "@user";
+      return mention.user?.name ? `@${mention.user.name}` : plainText || "@user";
     case "database":
-      return mention.database ? `[[${mention.database.id}]]` : "";
+      return mention.database ? `[[notion:${compactNotionId(mention.database.id)}]]` : plainText;
     default:
-      return "";
+      return plainText;
   }
 }
+
+// src/converter/block-converter.ts
+var TRULY_UNSUPPORTED_BLOCK_TYPES = ["unsupported", "template"];
+var DIVIDER_PLACEHOLDER = "\u200B%%IM-NOBSIDIAN_DIVIDER%%\u200B";
+var VIDEO_URL_PATTERNS = [
+  /^https?:\/\/(www\.)?youtube\.com\/watch/,
+  /^https?:\/\/youtu\.be\//,
+  /^https?:\/\/(www\.)?vimeo\.com\//,
+  /^https?:\/\/(www\.)?dailymotion\.com\//,
+  /^https?:\/\/(www\.)?loom\.com\/share\//
+];
+var EMBED_URL_PATTERNS = [
+  /^https?:\/\/(www\.)?figma\.com\//,
+  /^https?:\/\/docs\.google\.com\//,
+  /^https?:\/\/drive\.google\.com\//,
+  /^https?:\/\/(www\.)?miro\.com\//,
+  /^https?:\/\/(www\.)?twitter\.com\//,
+  /^https?:\/\/(www\.)?x\.com\//,
+  /^https?:\/\/codepen\.io\//,
+  /^https?:\/\/gist\.github\.com\//,
+  /^https?:\/\/(www\.)?spotify\.com\//,
+  /^https?:\/\/(www\.)?soundcloud\.com\//
+];
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var BlockConverter = class {
   n2m = null;
   client = null;
@@ -2762,6 +3028,37 @@ var BlockConverter = class {
     this.registerEmbedTransformer();
     this.registerCalloutTransformer();
     this.registerToggleHeadingTransformers();
+    this.registerNumberedListTransformer();
+  }
+  /**
+   * `numbered_list_item` 을 `1.` 마크다운으로 내보내 **번호 목록 타입을 보존**한다(I2 블록 라운드트립).
+   *
+   * notion-to-md 기본 렌더는 `md.bullet(text, block.numbered_list_item.number)` 를 쓰는데
+   * Notion API 는 list item 에 `.number` 를 채워주지 않아 `undefined` → 불릿(`- `)으로 **강등**된다.
+   * 그러면 블록 폴백 경로(notionBlocksToMarkdown)로 pull 한 뒤 다시 push 하면 numbered_list_item 이
+   * bulleted_list_item 으로 **타입 유실**된다(기본 markdown-api 경로는 영향 없음).
+   *
+   * 항상 `1.` 로 내보내면 마크다운이 시각적으로 자동 재번호하므로 표시는 동일하고, martian 이 다시
+   * numbered_list_item 으로 파싱해 타입이 보존된다. 커스텀 트랜스포머 등록은 notion-to-md 의 기본
+   * 자식 처리를 끄므로(라이브러리 설계), 자식은 toggle/callout 과 동일하게 직접 fetch·들여쓰기한다.
+   */
+  registerNumberedListTransformer() {
+    if (!this.n2m) return;
+    const n2m = this.n2m;
+    this.n2m.setCustomTransformer("numbered_list_item", async (block) => {
+      const b = block;
+      const text = richTextToMarkdown(b.numbered_list_item?.rich_text);
+      let result = `1. ${text}`;
+      if (b.has_children) {
+        const children = await n2m.pageToMarkdown(b.id);
+        const childMd = (Array.isArray(children) ? n2m.toMarkdownString(children).parent : "") ?? "";
+        if (childMd.trim()) {
+          const indented = childMd.split("\n").map((l) => l.trim() ? `    ${l}` : "").join("\n").trimEnd();
+          result += "\n" + indented;
+        }
+      }
+      return result;
+    });
   }
   registerToggleTransformer() {
     if (!this.n2m) return;
@@ -2922,7 +3219,7 @@ ${COLUMN_LIST_END}`;
   }
   registerBreadcrumbTransformer() {
     if (!this.n2m) return;
-    this.n2m.setCustomTransformer("breadcrumb", async () => "");
+    this.n2m.setCustomTransformer("breadcrumb", async () => BREADCRUMB_MARKER);
   }
   registerLinkPreviewTransformer() {
     if (!this.n2m) return;
@@ -3001,8 +3298,19 @@ ${COLUMN_LIST_END}`;
     processed = this.extractColumnBlocks(processed);
     processed = this.replaceDividers(processed);
     processed = processed.replace(/<unknown[^>]*\/>/g, "");
+    processed = this.stripInlineAnnotationMarkers(processed);
     return processed;
   }
+  /**
+   * compact underline/color 보존마커를 평문으로 강등 — block(martian) 폴백 경로 전용.
+   *
+   * 무손실 underline/color 복원은 기본 경로인 Markdown API({@link obsidianToNotionEnhanced})가
+   * 전담한다. martian 은 이 서식을 표현할 수 없으므로, Markdown API 가 실패해 이 폴백을 탈 때는
+   * 마커 텍스트가 본문에 리터럴로 새지 않도록 텍스트만 남기고 마커를 제거한다(서식 degrade).
+   */
+  stripInlineAnnotationMarkers(markdown) {
+    return markdown.replace(new RegExp(`%%${MARKER_BRAND}:underline%%([\\s\\S]*?)%%\\/underline%%`, "g"), "$1").replace(new RegExp(`%%${MARKER_BRAND}:color:[^%]+%%([\\s\\S]*?)%%\\/color%%`, "g"), "$1");
+  }
   replaceDividers(markdown) {
     const lines = markdown.split("\n");
     const result = [];
@@ -3074,12 +3382,18 @@ ${COLUMN_LIST_END}`;
         result.push(dividerConverted);
         continue;
       }
+      const markerConverted = this.convertSingleLineMarker(block);
+      if (markerConverted) {
+        result.push(markerConverted);
+        continue;
+      }
       const videoConverted = this.convertImageToVideoOrEmbed(block);
       if (videoConverted) {
         result.push(videoConverted);
         continue;
       }
-      const calloutConverted = this.convertQuoteToCallout(block);
+      const flattened = this.flattenMartianBlockquote(block);
+      const calloutConverted = this.convertQuoteToCallout(flattened);
       result.push(calloutConverted);
     }
     return result;
@@ -3127,12 +3441,33 @@ ${COLUMN_LIST_END}`;
     }
     return null;
   }
+  /**
+   * 단일 라인 보존 마커(목차·breadcrumb)를 원래 블록으로 복원한다.
+   * pull 시 마크다운 표현이 없는 블록을 `%%im-nobsidian:toc%%` /
+   * `%%im-nobsidian:breadcrumb%%` 마커 문단으로 남겨두므로, push 시 이 문단을
+   * 감지해 table_of_contents / breadcrumb 블록으로 되돌린다. 그러지 않으면
+   * 마커 텍스트가 일반 문단으로 Notion 에 기록되는 잠재 손실이 된다.
+   */
+  convertSingleLineMarker(block) {
+    if (block.type !== "paragraph") return null;
+    const para = block.paragraph;
+    const texts = para?.rich_text ?? [];
+    if (texts.length !== 1) return null;
+    const text = (texts[0]?.text?.content ?? "").trim();
+    if (text === TOC_MARKER) {
+      return NotionBlockBuilder.tableOfContents();
+    }
+    if (text === BREADCRUMB_MARKER) {
+      return NotionBlockBuilder.breadcrumb();
+    }
+    return null;
+  }
   convertImageToVideoOrEmbed(block) {
     let url = "";
     let caption;
     if (block.type === "image") {
       const img = block.image;
-      url = img?.external?.url ?? "";
+      url = img?.external?.url ?? img?.file?.url ?? "";
       caption = img?.caption?.[0]?.text?.content;
     } else if (block.type === "paragraph") {
       const para = block.paragraph;
@@ -3153,6 +3488,53 @@ ${COLUMN_LIST_END}`;
     }
     return null;
   }
+  /**
+   * `@tryfabric/martian` 의 blockquote 표현을 **평탄화**한다(I2/I3 무손실 push).
+   *
+   * martian 의 parseBlockquote 는 `notion.blockquote([], children)` 로 본문을 quote 의
+   * **자식 paragraph** 로 내려보내고 quote.rich_text 를 비운다(라이브러리 설계). 그 결과
+   * `> 인용문` 을 push 하면 Notion 에 "빈 인용 줄 + 들여쓴 자식 문단"이 만들어지고, 다시
+   * pull 하면 `> `(빈 줄) 아래에 자식 문단이 매달려 **원문과 구조가 갈라진다**(라운드트립 손실).
+   * 또한 quote.rich_text[0] 이 항상 비어 callout 이모지 감지({@link convertQuoteToCallout})도
+   * 무력화됐다.
+   *
+   * 선두의 연속된 paragraph 자식을 quote.rich_text 로 끌어올리고(문단 사이는 줄바꿈 rich_text
+   * 로 연결 — Notion 네이티브 멀티라인 인용 표현), paragraph 가 아닌 자식(중첩 리스트 등)은
+   * children 으로 남겨 구조를 보존한다. 이미 rich_text 에 본문이 있거나 끌어올릴 paragraph 가
+   * 없으면 원본을 그대로 반환한다(안전 no-op).
+   */
+  flattenMartianBlockquote(block) {
+    if (block.type !== "quote") return block;
+    const quote = block.quote;
+    if (!quote) return block;
+    const richText = quote.rich_text ?? [];
+    const hasText = richText.some((r) => {
+      const t = r;
+      return (t.text?.content ?? t.plain_text ?? "") !== "";
+    });
+    const children = quote.children ?? [];
+    if (hasText || children.length === 0) return block;
+    const hoisted = [];
+    let consumed = 0;
+    for (; consumed < children.length; consumed++) {
+      const child = children[consumed];
+      if (child.type !== "paragraph") break;
+      const para = child.paragraph;
+      const paraRt = para?.rich_text ?? [];
+      if (hoisted.length > 0) {
+        hoisted.push(
+          ...NotionBlockBuilder.richText("\n")
+        );
+      }
+      hoisted.push(...paraRt);
+    }
+    if (hoisted.length === 0) return block;
+    const remaining = children.slice(consumed);
+    const newQuote = { ...quote, rich_text: hoisted };
+    if (remaining.length > 0) newQuote.children = remaining;
+    else delete newQuote.children;
+    return { ...block, quote: newQuote };
+  }
   convertQuoteToCallout(block) {
     if (block.type !== "quote") return block;
     const quote = block.quote;
@@ -3204,6 +3586,22 @@ ${COLUMN_LIST_END}`;
     const result = this.n2m.toMarkdownString(mdBlocks);
     return result.parent ?? "";
   }
+  /**
+   * **in-memory** 블록 배열을 마크다운으로 변환한다(페이지 fetch 없음). notion-to-md 의
+   * blocksToMarkdown 을 직접 호출하므로, `has_children:false` 인 평면 블록은 Notion 클라이언트를
+   * 전혀 건드리지 않는다 → 고정 픽스처로 **오프라인 결정론** 블록 라운드트립(I2)을 잠글 수 있는
+   * 정식 테스트 시임. children 이 있는 블록(table 행·callout 자식 등)은 클라이언트를 호출하므로
+   * 호출 측이 평면 블록만 넣어야 오프라인이 보장된다.
+   */
+  async notionBlockArrayToMarkdown(blocks) {
+    if (!this.n2m) {
+      throw new Error(
+        "NotionToMarkdown\uC774 \uCD08\uAE30\uD654\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. initNotionToMd()\uB97C \uBA3C\uC800 \uD638\uCD9C\uD558\uC138\uC694."
+      );
+    }
+    const mdBlocks = await this.n2m.blocksToMarkdown(blocks);
+    return this.n2m.toMarkdownString(mdBlocks).parent ?? "";
+  }
 };
 var NOTION_MAX_TABLE_ROWS = 100;
 var NOTION_MAX_LIST_DEPTH = 3;
@@ -3331,10 +3729,11 @@ var EXTENSION_TO_MIME = {
   ".tiff": "image/tiff"
 };
 var ImageHandler = class {
-  constructor(vaultFs, attachmentFolder = "attachments", notionClient, customFetch, options) {
+  constructor(vaultFs, attachmentFolder = "attachments", notionClient, customFetch, options, stateDb) {
     this.vaultFs = vaultFs;
     this.attachmentFolder = attachmentFolder;
     this.notionClient = notionClient;
+    this.stateDb = stateDb;
     this.customFetch = customFetch;
     this.concurrency = options?.concurrency ?? 3;
     this.maxRetries = options?.maxRetries ?? 3;
@@ -3344,6 +3743,7 @@ var ImageHandler = class {
   vaultFs;
   attachmentFolder;
   notionClient;
+  stateDb;
   customFetch;
   concurrency;
   maxRetries;
@@ -3447,7 +3847,8 @@ var ImageHandler = class {
     const contentType = this.getContentTypeFromPath(filename);
     const blob = new Blob([buffer], { type: contentType });
     const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
-    return { localPath, fileUploadId };
+    const fileHash = createHash("sha256").update(buffer).digest("hex");
+    return { localPath, fileUploadId, fileHash, fileSize: buffer.length };
   }
   async uploadAndAppendImages(pageId, images) {
     if (!this.notionClient) return [];
@@ -3472,10 +3873,26 @@ var ImageHandler = class {
     }
     if (imageBlocks.length > 0) {
       await this.notionClient.appendChildren(pageId, imageBlocks);
-    }
-    return results;
-  }
-  async readImageFromVault(localPath) {
+      if (this.stateDb) {
+        for (const r of results) {
+          try {
+            this.stateDb.registerFile({
+              localPath: r.localPath,
+              notionPageId: pageId,
+              fileUploadId: r.fileUploadId,
+              fileType: "image",
+              fileHash: r.fileHash,
+              fileSize: r.fileSize
+            });
+          } catch (error) {
+            getLogger().warn(`\uC774\uBBF8\uC9C0 \uB808\uC9C0\uC2A4\uD2B8\uB9AC \uB4F1\uB85D \uC2E4\uD328 (${r.localPath}):`, error);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  async readImageFromVault(localPath) {
     try {
       return await this.vaultFs.readBinary(localPath);
     } catch {
@@ -3963,6 +4380,7 @@ function resolvePullConflict(input) {
 
 // src/utils/sanitize.ts
 var INVALID_CHARS = /[<>:"/\\|?*\x00-\x1f]/g;
+var WIKILINK_UNSAFE_CHARS = /[[\]]/g;
 var TRAILING_DOTS = /\.+$/;
 var RESERVED_NAMES = /* @__PURE__ */ new Set([
   "CON",
@@ -3989,7 +4407,7 @@ var RESERVED_NAMES = /* @__PURE__ */ new Set([
   "LPT9"
 ]);
 function sanitizeFileName(name) {
-  let sanitized = name.replace(INVALID_CHARS, "_").replace(TRAILING_DOTS, "").trim().slice(0, 200);
+  let sanitized = name.replace(INVALID_CHARS, "_").replace(WIKILINK_UNSAFE_CHARS, "_").replace(TRAILING_DOTS, "").trim().slice(0, 200);
   if (RESERVED_NAMES.has(sanitized.toUpperCase())) {
     sanitized = `_${sanitized}`;
   }
@@ -3999,6 +4417,36 @@ function sanitizeFileName(name) {
   return sanitized;
 }
 
+// src/utils/db-row-path.ts
+function selectDbRowFiles(files, localFolder) {
+  const prefix = localFolder.endsWith("/") ? localFolder : `${localFolder}/`;
+  return files.filter((file) => {
+    if (!file.path.startsWith(prefix)) return false;
+    const rel = file.path.slice(prefix.length);
+    return rel.length > 0 && !rel.includes("/");
+  });
+}
+function resolveDbRowPath(localFolder, safeName, pageId, lookupByPath) {
+  const ownedBySelf = (candidate) => {
+    const owner = lookupByPath(candidate);
+    if (!owner) return true;
+    return owner.notionPageId != null && notionIdsEqual(owner.notionPageId, pageId);
+  };
+  const natural = `${localFolder}/${safeName}.md`;
+  if (ownedBySelf(natural)) return natural;
+  const raw = pageId.replace(/-/g, "");
+  for (const len of [8, 16, 32]) {
+    const candidate = `${localFolder}/${safeName} (${raw.slice(0, len)}).md`;
+    if (ownedBySelf(candidate)) return candidate;
+  }
+  return `${localFolder}/${safeName} (${raw}).md`;
+}
+
+// src/utils/wikilink-title.ts
+function wikilinkTitleFromPath(obsidianPath) {
+  return obsidianPath.replace(/\.md$/i, "").split("/").pop() ?? "";
+}
+
 // src/view/base-file-generator.ts
 var NOTION_TO_BASES_VIEW = {
   table: "table",
@@ -4012,6 +4460,9 @@ var NOTION_TO_BASES_VIEW = {
   map: null,
   dashboard: null
 };
+function basesViewTypeOf(notionType) {
+  return NOTION_TO_BASES_VIEW[notionType] ?? null;
+}
 var BaseFileGenerator = class {
   generate(options) {
     const lines = [];
@@ -4060,6 +4511,7 @@ var BaseFileGenerator = class {
       lines.push("    name: Table");
       return;
     }
+    this.dedupeViewNames(basesViews);
     lines.push("views:");
     for (const view of basesViews) {
       lines.push(`  - type: ${view.type}`);
@@ -4089,6 +4541,23 @@ var BaseFileGenerator = class {
       }
     }
   }
+  /**
+   * 뷰 이름을 Bases 요구사항대로 유일화한다(in-place). 동명 충돌 시 ' 2',' 3'… 를 붙이되
+   * 이미 존재하는 이름과 다시 충돌하지 않을 때까지 증가시킨다.
+   */
+  dedupeViewNames(views) {
+    const used = /* @__PURE__ */ new Set();
+    for (const v of views) {
+      let name = v.name;
+      if (used.has(name)) {
+        let n = 2;
+        while (used.has(`${v.name} ${n}`)) n++;
+        name = `${v.name} ${n}`;
+      }
+      used.add(name);
+      v.name = name;
+    }
+  }
   convertView(view, schema) {
     const basesType = NOTION_TO_BASES_VIEW[view.type];
     if (!basesType) return null;
@@ -4181,10 +4650,156 @@ var BaseFileGenerator = class {
   }
 };
 
+// src/view/sidecar-generator.ts
+var DROPPED_SETTING_REASONS = {
+  filter: "Notion \uD544\uD130\uC2DD\uC740 .base \uB85C \uD45C\uD604\uB418\uC9C0 \uC54A\uC74C(\uD3F4\uB354 \uD544\uD130\uB9CC \uC801\uC6A9)",
+  coverSize: "\uAC24\uB7EC\uB9AC \uCEE4\uBC84 \uD06C\uAE30\uB294 Bases \uBBF8\uC9C0\uC6D0",
+  coverAspect: "\uAC24\uB7EC\uB9AC \uCEE4\uBC84 \uBE44\uC728\uC740 Bases \uBBF8\uC9C0\uC6D0",
+  viewRange: "\uCE98\uB9B0\uB354 \uD45C\uC2DC \uBC94\uC704(week/month)\uB294 Bases \uBBF8\uC9C0\uC6D0",
+  columnWidths: "\uCEEC\uB7FC \uB108\uBE44(width)\uB294 Bases \uBBF8\uC9C0\uC6D0",
+  columnWraps: "\uCEEC\uB7FC \uC904\uBC14\uAFC8(wrap)\uC740 Bases \uBBF8\uC9C0\uC6D0",
+  hideEmptyGroups: "\uBE48 \uADF8\uB8F9 \uC228\uAE40\uC740 Bases \uBBF8\uC9C0\uC6D0"
+};
+var SidecarGenerator = class {
+  /**
+   * 사이드카 객체를 빌드한다(순수 — I/O 없음). 직렬화는 {@link serialize} 가 담당.
+   */
+  build(options) {
+    const degraded = [];
+    const properties = this.buildProperties(options.schema);
+    const views = options.viewsConfig.views.map((v) => this.buildView(v, degraded));
+    degraded.sort(
+      (a, b) => a.view.localeCompare(b.view) || a.kind.localeCompare(b.kind) || a.detail.localeCompare(b.detail)
+    );
+    return {
+      generator: "im-nobsidian",
+      schemaVersion: 1,
+      databaseId: options.databaseId,
+      databaseName: options.databaseName,
+      properties,
+      views,
+      degraded
+    };
+  }
+  /**
+   * 사이드카를 결정적 JSON 문자열로 직렬화한다(키 재귀 정렬 + 말미 개행).
+   * 동일 입력 → 동일 바이트 → 멱등(drift/churn 0).
+   */
+  serialize(sidecar) {
+    return stableStringify(sidecar) + "\n";
+  }
+  buildProperties(schema) {
+    return Object.entries(schema).map(([name, prop]) => {
+      const options = prop.options?.map((o) => o.name).filter((n) => n.length > 0);
+      return {
+        name,
+        id: prop.id,
+        type: prop.type,
+        ...options && options.length > 0 ? { options } : {}
+      };
+    }).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  buildView(view, degraded) {
+    const basesType = basesViewTypeOf(view.type);
+    const viewName = view.name || view.type;
+    if (basesType === null) {
+      degraded.push({
+        view: viewName,
+        kind: "view-unrepresentable",
+        detail: `'${view.type}' \uBDF0\uB294 Obsidian Bases \uB300\uC751\uC774 \uC5C6\uC5B4 .base \uC5D0\uC11C \uB204\uB77D \u2014 \uC0AC\uC774\uB4DC\uCE74\uB85C\uB9CC \uBCF4\uC874`
+      });
+    }
+    const config = this.extractConfig(view, basesType, viewName, degraded);
+    return {
+      id: view.id,
+      name: viewName,
+      notionType: view.type,
+      basesType,
+      config
+    };
+  }
+  /**
+   * 뷰 설정 중 의미 있는 항목을 추출한다. `.base` 가 표현 못하는 항목(필터·커버크기 등)은
+   * config 에 보존하면서 동시에 degrade 리포트에 1줄씩 기록한다(표현되는 뷰에 한해 —
+   * 미표현 뷰는 이미 view-unrepresentable 로 통째 보고됨).
+   */
+  extractConfig(view, basesType, viewName, degraded) {
+    const config = {};
+    const noteDrop = (key) => {
+      if (basesType !== null && DROPPED_SETTING_REASONS[key]) {
+        degraded.push({
+          view: viewName,
+          kind: "setting-dropped",
+          detail: DROPPED_SETTING_REASONS[key]
+        });
+      }
+    };
+    if (view.filter !== void 0 && view.filter !== null) {
+      config["filter"] = view.filter;
+      noteDrop("filter");
+    }
+    if (view.sorts && view.sorts.length > 0) config["sorts"] = view.sorts;
+    if (view.groupBy) {
+      config["groupBy"] = view.groupBy;
+      if (view.groupBy.hideEmptyGroups) noteDrop("hideEmptyGroups");
+    }
+    if (view.cover) config["cover"] = view.cover;
+    if (view.coverSize) {
+      config["coverSize"] = view.coverSize;
+      noteDrop("coverSize");
+    }
+    if (view.coverAspect) {
+      config["coverAspect"] = view.coverAspect;
+      noteDrop("coverAspect");
+    }
+    if (view.datePropertyId) config["datePropertyId"] = view.datePropertyId;
+    if (view.datePropertyName) config["datePropertyName"] = view.datePropertyName;
+    if (view.viewRange) {
+      config["viewRange"] = view.viewRange;
+      noteDrop("viewRange");
+    }
+    if (view.properties && view.properties.length > 0) {
+      config["properties"] = view.properties;
+      if (view.properties.some((p) => p.width !== void 0)) noteDrop("columnWidths");
+      if (view.properties.some((p) => p.wrap !== void 0)) noteDrop("columnWraps");
+    }
+    return config;
+  }
+};
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value), null, 2);
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value !== null && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortKeys(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+
+// src/sync/stale-db-artifacts.ts
+var ARTIFACT_SUFFIXES = [".base", ".notion.json"];
+function selectStaleDbArtifacts(files, localFolder, keepPaths) {
+  const prefix = `${localFolder}/`;
+  const stale = [];
+  for (const file of files) {
+    const path = file.path;
+    if (!path.startsWith(prefix)) continue;
+    const rel = path.slice(prefix.length);
+    if (rel.includes("/")) continue;
+    if (!ARTIFACT_SUFFIXES.some((suffix) => rel.endsWith(suffix))) continue;
+    if (keepPaths.has(path)) continue;
+    stale.push(path);
+  }
+  return stale;
+}
+
 // src/converter/enhanced-md-converter.ts
 var NOTION_CALLOUT_RE = /^::: callout\n([\s\S]*?)\n:::/gm;
-var NOTION_CALLOUT_TAG_RE = /<callout[^>]*>\n?([\s\S]*?)<\/callout>/g;
-var NOTION_TOGGLE_RE = /[\t ]*<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gs;
 var NOTION_PAGE_MENTION_RE = /<mention-page id="([^"]+)">([\s\S]*?)<\/mention-page>/g;
 var NOTION_USER_MENTION_RE = /<mention-user id="[^"]*">([^<]*)<\/mention-user>/g;
 var NOTION_DATE_MENTION_RE = /<mention-date start="([^"]*)"(?: end="([^"]*)")?[^>]*\/>/g;
@@ -4195,13 +4810,12 @@ var NOTION_VIDEO_RE = /[\t ]*<video src="([^"]*)">([\s\S]*?)<\/video>/g;
 var NOTION_PDF_RE = /[\t ]*<pdf src="([^"]*)">([\s\S]*?)<\/pdf>/g;
 var NOTION_FILE_RE = /[\t ]*<file src="([^"]*)">([\s\S]*?)<\/file>/g;
 var NOTION_TAB_RE = /<tab title="([^"]*)">([\s\S]*?)<\/tab>/g;
-var NOTION_UNDERLINE_RE = /<span underline="true">([\s\S]*?)<\/span>/g;
 function notionEnhancedToObsidian(enhanced) {
   let result = enhanced;
   result = convertSyncedBlockRef(result);
   result = normalizeCodeBlockToggles(result);
-  result = convertToggles(result);
-  result = convertCallouts(result);
+  result = convertContainers(result);
+  result = convertFencedCallouts(result);
   result = convertPageMentions(result);
   result = convertPageLinks(result);
   result = convertUserMentions(result);
@@ -4211,9 +4825,7 @@ function notionEnhancedToObsidian(enhanced) {
   result = preserveUnknownBlocks(result);
   result = convertNotionMath(result);
   result = convertNotionTables(result);
-  result = convertColorSpans(result);
-  result = convertUnderlineSpans(result);
-  result = convertColumnBlocks(result);
+  result = convertSpans(result);
   result = convertDatabaseBlocks(result);
   result = cleanInlineColorAttrs(result);
   result = removeEmptyBlocks(result);
@@ -4260,35 +4872,136 @@ function restoreWikilinkPreserveLinks(content) {
     return target === label ? `[[${target}]]` : `[[${target}|${label}]]`;
   });
 }
+function fenceFor(body) {
+  let longest = 0;
+  const re = /`+/g;
+  let m;
+  while ((m = re.exec(body)) !== null) longest = Math.max(longest, m[0].length);
+  return "`".repeat(Math.max(3, longest + 1));
+}
+function dedentContainerBody(text) {
+  const lines = text.split("\n");
+  while (lines.length && lines[0].trim() === "") lines.shift();
+  while (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
+  const kinds = [];
+  let inCode = false;
+  let fenceChar = "";
+  let fenceLen = 0;
+  let inTable = false;
+  for (const line of lines) {
+    const fence = /^[\t ]*(`{3,}|~{3,})(.*)$/.exec(line);
+    if (inCode) {
+      if (fence && fence[1][0] === fenceChar && fence[1].length >= fenceLen && fence[2].trim() === "") {
+        inCode = false;
+        kinds.push("fence");
+      } else {
+        kinds.push("code");
+      }
+    } else if (inTable) {
+      const closes = /<\/table>/.test(line);
+      kinds.push(closes ? "fence" : "code");
+      if (closes) inTable = false;
+    } else if (fence) {
+      inCode = true;
+      fenceChar = fence[1][0];
+      fenceLen = fence[1].length;
+      kinds.push("fence");
+    } else if (/^[\t ]*<table[^>]*>/.test(line)) {
+      if (!/<\/table>/.test(line)) inTable = true;
+      kinds.push("fence");
+    } else {
+      kinds.push("prose");
+    }
+  }
+  let min = Infinity;
+  lines.forEach((l, i) => {
+    if (kinds[i] !== "prose" || l.trim() === "") return;
+    min = Math.min(min, /^[\t ]*/.exec(l)[0].length);
+  });
+  if (!Number.isFinite(min)) min = 0;
+  return lines.map((l, i) => {
+    if (l.trim() === "") return "";
+    if (kinds[i] === "code") return l;
+    if (kinds[i] === "fence") return l.replace(/^[\t ]+/, "");
+    return l.slice(min);
+  }).join("\n");
+}
 function normalizeCodeBlockToggles(content) {
   return content.replace(
-    /^- (.+)\n\t```(\w*)\n([\s\S]*?)\n\t```$/gm,
-    (_match, title, lang, body) => {
-      const langTag = lang ? lang : "";
+    /^[\t ]*- (.+)\n[\t ]*(`{3,})(\w*)\n([\s\S]*?)\n[\t ]*\2[\t ]*$/gm,
+    (_match, title, _open, lang, rawBody) => {
+      const body = dedentContainerBody(rawBody);
+      const fence = fenceFor(body);
       return `<details>
 <summary>${title.trim()}</summary>
-\`\`\`${langTag}
+${fence}${lang}
 ${body}
-\`\`\`
+${fence}
 </details>`;
     }
   );
 }
-function convertToggles(content) {
-  function replaceToggle(match) {
-    const m = /[\t ]*<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/s.exec(match);
-    if (!m) return match;
-    const title = m[1].trim();
-    let body = m[2].trim();
-    body = convertToggles(body);
-    const calloutBody = body.split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
-    return `> [!toggle]- ${title}
+var NO_CONTAINER_BODY = "(?:(?!<details>|<callout|<columns>)[\\s\\S])*?";
+var SUMMARY_TITLE = "((?:(?!<\\/summary>|<details>|<summary>)[\\s\\S])*?)";
+var INNERMOST_DETAILS_RE = new RegExp(
+  `([\\t ]*)<details>\\s*<summary>${SUMMARY_TITLE}<\\/summary>(${NO_CONTAINER_BODY})<\\/details>`,
+  "g"
+);
+var INNERMOST_CALLOUT_RE = new RegExp(
+  `([\\t ]*)<callout[^>]*>\\n?(${NO_CONTAINER_BODY})<\\/callout>`,
+  "g"
+);
+var INNERMOST_COLUMNS_RE = new RegExp(
+  `([\\t ]*)<columns>\\n?(${NO_CONTAINER_BODY})<\\/columns>`,
+  "g"
+);
+var COLUMN_WRAP_RE = /[\t ]*<column>\n?([\s\S]*?)[\t ]*<\/column>\n?/g;
+function reindentLines(text, indent) {
+  if (!indent) return text;
+  return text.split("\n").map((line) => line === "" ? line : indent + line).join("\n");
+}
+function toggleToCallout(title, rawBody) {
+  const body = dedentContainerBody(rawBody);
+  const calloutBody = body.split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n");
+  return `> [!toggle]- ${title.trim()}
 ${calloutBody}`;
+}
+function flattenColumns(body) {
+  const cols = [];
+  const re = new RegExp(COLUMN_WRAP_RE.source, COLUMN_WRAP_RE.flags);
+  let m;
+  let matched = false;
+  while ((m = re.exec(body)) !== null) {
+    matched = true;
+    const col = dedentContainerBody(m[1]);
+    if (col.trim() !== "") cols.push(col);
+  }
+  if (!matched) return dedentContainerBody(body);
+  return cols.join("\n\n");
+}
+function convertContainers(content) {
+  let result = content;
+  let safety = 0;
+  while (safety++ < 2e3 && (result.includes("<details>") || result.includes("<callout") || result.includes("<columns>"))) {
+    const before = result;
+    result = result.replace(
+      INNERMOST_DETAILS_RE,
+      (_m, indent, title, body) => reindentLines(toggleToCallout(title, body), indent)
+    );
+    result = result.replace(
+      INNERMOST_CALLOUT_RE,
+      (_m, indent, body) => reindentLines(calloutBodyToObsidian(body), indent)
+    );
+    result = result.replace(
+      INNERMOST_COLUMNS_RE,
+      (_m, indent, body) => reindentLines(flattenColumns(body), indent)
+    );
+    if (result === before) break;
   }
-  return content.replace(NOTION_TOGGLE_RE, replaceToggle);
+  return result;
 }
 function calloutBodyToObsidian(body) {
-  const lines = body.split("\n").map((l) => l.replace(/^\t/, "")).filter((l, i, arr) => !(i === 0 && l === "") && !(i === arr.length - 1 && l === ""));
+  const lines = dedentContainerBody(body).split("\n").filter((l, i, arr) => !(i === 0 && l === "") && !(i === arr.length - 1 && l === ""));
   const firstLine = lines[0] ?? "";
   const emojiMatch = /^([\p{Emoji}️‍]+)\s*(.*)/u.exec(firstLine);
   const type = emojiMatch ? emojiToCalloutType(emojiMatch[1]) : "note";
@@ -4298,13 +5011,8 @@ function calloutBodyToObsidian(body) {
   const calloutBody = rest ? "\n" + rest.split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n") : "";
   return calloutTitle + calloutBody;
 }
-function convertCallouts(content) {
-  let result = content.replace(
-    NOTION_CALLOUT_TAG_RE,
-    (_match, body) => calloutBodyToObsidian(body)
-  );
-  result = result.replace(NOTION_CALLOUT_RE, (_match, body) => calloutBodyToObsidian(body));
-  return result;
+function convertFencedCallouts(content) {
+  return content.replace(NOTION_CALLOUT_RE, (_match, body) => calloutBodyToObsidian(body));
 }
 function convertPageMentions(content) {
   let result = content.replace(NOTION_PAGE_MENTION_RE, (_match, _id, text) => {
@@ -4312,7 +5020,7 @@ function convertPageMentions(content) {
     return `[[${cleaned}]]`;
   });
   result = result.replace(
-    /<mention-page\s+url="https?:\/\/(?:www\.)?notion\.so\/([a-f0-9]{32})"[^>]*\/>/g,
+    /<mention-page\s+url="https?:\/\/(?:www\.)?notion\.so\/([a-f0-9]{32})"[^>]*?(?:\/>|>[\s\S]*?<\/mention-page>)/g,
     (_match, id) => `[[notion:${id}]]`
   );
   return result;
@@ -4383,10 +5091,19 @@ function convertTabBlocks(content) {
 ${indented}`;
   });
 }
-function convertUnderlineSpans(content) {
-  return content.replace(NOTION_UNDERLINE_RE, (_match, text) => {
-    return `${compactMarker("underline")}${text}%%/underline%%`;
-  });
+var INNERMOST_SPAN_RE = /<span (?:underline="true"|color="([^"]+)")>((?:(?!<span )[\s\S])*?)<\/span>/g;
+function convertSpans(content) {
+  let result = content;
+  let safety = 0;
+  while (safety++ < 1e3) {
+    const next = result.replace(
+      INNERMOST_SPAN_RE,
+      (_match, color, inner) => color !== void 0 ? `${compactMarker(`color:${color}`)}${inner}%%/color%%` : `${compactMarker("underline")}${inner}%%/underline%%`
+    );
+    if (next === result) break;
+    result = next;
+  }
+  return result;
 }
 function convertTogglesToHtml(content) {
   const calloutToggleRe = /^> \[!toggle\]-\s*(.+)\n((?:>.*\n?)*)/gm;
@@ -4502,7 +5219,6 @@ function escapeRegex3(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var NOTION_PAGE_LINK_RE = /<page url="[^"]*">([\s\S]*?)<\/page>/g;
-var NOTION_COLOR_SPAN_RE = /<span color="([^"]+)">([\s\S]*?)<\/span>/g;
 var NOTION_EMPTY_BLOCK_RE = /^(?:>[\t ]*)*[\t ]*<empty-block\/>\n?/gm;
 function convertPageLinks(content) {
   return content.replace(NOTION_PAGE_LINK_RE, (_match, text) => {
@@ -4510,12 +5226,6 @@ function convertPageLinks(content) {
     return `[[${cleaned}]]`;
   });
 }
-function convertColorSpans(content) {
-  return content.replace(
-    NOTION_COLOR_SPAN_RE,
-    (_match, color, text) => `${compactMarker(`color:${color}`)}${text}%%/color%%`
-  );
-}
 function convertDatabaseBlocks(content) {
   return content.replace(
     /<database[^>]*>([\s\S]*?)<\/database>/g,
@@ -4525,11 +5235,6 @@ function convertDatabaseBlocks(content) {
 function cleanInlineColorAttrs(content) {
   return content.replace(/\s*\{color="[^"]*"\}/g, "");
 }
-function convertColumnBlocks(content) {
-  return content.replace(/<columns>\n?([\s\S]*?)<\/columns>/g, (_match, inner) => {
-    return inner.replace(/\t?<column>\n?/g, "").replace(/\t?<\/column>\n?/g, "").trim();
-  });
-}
 function removeEmptyBlocks(content) {
   return content.replace(NOTION_EMPTY_BLOCK_RE, "\n");
 }
@@ -4691,7 +5396,12 @@ var DatabaseSyncer = class {
     this.imageHandler = imageHandler;
     this.propertyMapper.setWikilinkResolver({
       resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
-      resolvePageId: (pageId) => stateDb.resolvePageId(pageId)?.title ?? null
+      // M4: 후처리 패스(resolveNotionLinks)와 동일하게 파일 basename 으로 해소 — 원시 제목과
+      // sanitize 된 파일명의 불일치로 인한 깨진/이중 위키링크 차단.
+      resolvePageId: (pageId) => {
+        const entry = stateDb.resolvePageId(pageId);
+        return entry ? wikilinkTitleFromPath(entry.obsidianPath) : null;
+      }
     });
   }
   config;
@@ -4702,15 +5412,17 @@ var DatabaseSyncer = class {
   imageHandler;
   propertyMapper = new PropertyMapper();
   baseFileGenerator = new BaseFileGenerator();
+  sidecarGenerator = new SidecarGenerator();
   async pullAll() {
     const databases = this.config.notion.databases;
     if (!databases || databases.length === 0) {
-      return { created: 0, updated: 0, conflicts: [], failed: [] };
+      return { created: 0, updated: 0, conflicts: [], failed: [], writtenPaths: [] };
     }
     let created = 0;
     let updated = 0;
     const conflicts = [];
     const failed = [];
+    const writtenPaths = [];
     for (const dbConfig of databases) {
       try {
         const result = await this.pullDatabase(dbConfig);
@@ -4718,6 +5430,7 @@ var DatabaseSyncer = class {
         updated += result.updated;
         conflicts.push(...result.conflicts);
         failed.push(...result.failed);
+        writtenPaths.push(...result.writtenPaths);
       } catch (error) {
         getLogger().warn(`[DB Sync] DB ${dbConfig.databaseId} pull \uC2E4\uD328:`, error);
         failed.push({
@@ -4727,12 +5440,12 @@ var DatabaseSyncer = class {
         });
       }
     }
-    return { created, updated, conflicts, failed };
+    return { created, updated, conflicts, failed, writtenPaths };
   }
   async pushAll() {
     const databases = this.config.notion.databases;
     if (!databases || databases.length === 0) {
-      return { created: 0, updated: 0, conflicts: [], failed: [] };
+      return { created: 0, updated: 0, conflicts: [], failed: [], writtenPaths: [] };
     }
     let created = 0;
     let updated = 0;
@@ -4752,7 +5465,7 @@ var DatabaseSyncer = class {
         });
       }
     }
-    return { created, updated, conflicts: [], failed };
+    return { created, updated, conflicts: [], failed, writtenPaths: [] };
   }
   async pullDatabase(dbConfig) {
     const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
@@ -4768,6 +5481,7 @@ var DatabaseSyncer = class {
     let updated = 0;
     const conflicts = [];
     const failed = [];
+    const writtenPaths = [];
     for (const page of pages) {
       try {
         const record = this.stateDb.getByNotionId(page.id);
@@ -4776,12 +5490,16 @@ var DatabaseSyncer = class {
           const outcome = await this.pullDatabasePage(page, dbConfig);
           if (outcome.action === "written") {
             updated++;
+            writtenPaths.push(outcome.path);
           } else if (outcome.action === "conflict") {
             conflicts.push(outcome.conflict);
           }
         } else {
-          await this.pullDatabasePage(page, dbConfig);
+          const outcome = await this.pullDatabasePage(page, dbConfig);
           created++;
+          if (outcome.action === "written") {
+            writtenPaths.push(outcome.path);
+          }
         }
       } catch (error) {
         failed.push({
@@ -4794,7 +5512,7 @@ var DatabaseSyncer = class {
     getLogger().debug(
       `[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8, ${conflicts.length} \uCDA9\uB3CC`
     );
-    return { created, updated, conflicts, failed };
+    return { created, updated, conflicts, failed, writtenPaths };
   }
   async pullDatabaseViews(dbConfig, force = false) {
     try {
@@ -4830,25 +5548,76 @@ var DatabaseSyncer = class {
     try {
       const schemaFull = await this.notionClient.getDatabaseSchemaFull(dbConfig.databaseId);
       const dbName = viewsConfig?.databaseName || await this.notionClient.getDatabaseTitle(dbConfig.databaseId) || dbConfig.localFolder.split("/").pop() || "Database";
+      const resolvedViews = viewsConfig ?? {
+        databaseId: dbConfig.databaseId,
+        databaseName: dbName,
+        lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+        views: [{ id: "default", name: "Table", type: "table" }]
+      };
       const baseContent = this.baseFileGenerator.generate({
         databaseId: dbConfig.databaseId,
         databaseName: dbName,
         schema: schemaFull,
-        viewsConfig: viewsConfig ?? {
-          databaseId: dbConfig.databaseId,
-          databaseName: dbName,
-          lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
-          views: [{ id: "default", name: "Table", type: "table" }]
-        },
+        viewsConfig: resolvedViews,
         folderPath: dbConfig.localFolder
       });
-      const basePath = `${dbConfig.localFolder}/${sanitizeFileName(dbName)}.base`;
+      const safeName = sanitizeFileName(dbName);
+      const basePath = `${dbConfig.localFolder}/${safeName}.base`;
       await this.vaultFs.writeFile(basePath, baseContent);
       getLogger().debug(`[DB Sync] .base \uD30C\uC77C \uC0DD\uC131: ${basePath}`);
+      await this.generateSidecar(dbConfig, dbName, safeName, schemaFull, resolvedViews);
+      await this.cleanupStaleDbArtifacts(dbConfig.localFolder, safeName);
     } catch (error) {
       getLogger().warn(`[DB Sync] .base \uD30C\uC77C \uC0DD\uC131 \uC2E4\uD328 (\uACC4\uC18D \uC9C4\uD589):`, error);
     }
   }
+  /**
+   * DB 제목이 바뀌면 `.base`/`.notion.json` 파일명(safeName)이 바뀌어 옛 이름의 산출물이
+   * 같은 폴더에 고아로 잔존한다(drift·부활 원인). DB 폴더 **직속**의 산출물 중 현재 이름이
+   * 아닌 것을 삭제해 멱등을 보장한다. 하위 폴더(중첩 DB)의 산출물은 보호한다.
+   */
+  async cleanupStaleDbArtifacts(localFolder, safeName) {
+    try {
+      const keep = /* @__PURE__ */ new Set([
+        `${localFolder}/${safeName}.base`,
+        `${localFolder}/${safeName}.notion.json`
+      ]);
+      const files = await this.vaultFs.listNonMarkdownFiles();
+      const stale = selectStaleDbArtifacts(files, localFolder, keep);
+      for (const path of stale) {
+        await this.vaultFs.deleteFile(path);
+        getLogger().info(`[DB Sync] \uACE0\uC544 DB \uC0B0\uCD9C\uBB3C \uC0AD\uC81C(rename): ${path}`);
+      }
+    } catch (error) {
+      getLogger().warn(`[DB Sync] \uACE0\uC544 .base/.notion.json \uC815\uB9AC \uC2E4\uD328 (\uACC4\uC18D \uC9C4\uD589):`, error);
+    }
+  }
+  /**
+   * `.base` 가 표현하지 못하는 Notion DB 메타데이터(미지원 뷰·필터식·커버크기 등)를
+   * 사이드카 `<db>.notion.json` 으로 무손실 보존하고, degrade 된 항목을 정직하게 로그한다.
+   * 결정적 직렬화라 동일 DB 상태 → 동일 바이트 → 멱등(drift/churn 0).
+   */
+  async generateSidecar(dbConfig, dbName, safeName, schemaFull, resolvedViews) {
+    try {
+      const sidecar = this.sidecarGenerator.build({
+        databaseId: dbConfig.databaseId,
+        databaseName: dbName,
+        schema: schemaFull,
+        viewsConfig: resolvedViews
+      });
+      const sidecarPath = `${dbConfig.localFolder}/${safeName}.notion.json`;
+      await this.vaultFs.writeFile(sidecarPath, this.sidecarGenerator.serialize(sidecar));
+      if (sidecar.degraded.length > 0) {
+        const unrep = sidecar.degraded.filter((d) => d.kind === "view-unrepresentable").length;
+        const dropped = sidecar.degraded.length - unrep;
+        getLogger().info(
+          `[DB Sync] '${dbName}' degrade ${sidecar.degraded.length}\uAC74 (\uBBF8\uD45C\uD604 \uBDF0 ${unrep} \xB7 \uBBF8\uD45C\uD604 \uC124\uC815 ${dropped}) \u2192 ${safeName}.notion.json \uBCF4\uC874`
+        );
+      }
+    } catch (error) {
+      getLogger().warn(`[DB Sync] \uC0AC\uC774\uB4DC\uCE74 \uC0DD\uC131 \uC2E4\uD328 (\uACC4\uC18D \uC9C4\uD589):`, error);
+    }
+  }
   async pullDatabasePage(page, dbConfig) {
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
@@ -4864,9 +5633,9 @@ var DatabaseSyncer = class {
           `![cover](${cover.url})`,
           `${safeName}-cover`
         );
-        const localUrlMatch = coverResult.content.match(/!\[cover\]\((.+?)\)/);
-        if (localUrlMatch?.[1]) {
-          properties.cover = `[[${localUrlMatch[1]}]]`;
+        const resolved = coverResult.content.match(/!\[cover\]\((.+?)\)/)?.[1];
+        if (resolved && !/^https?:\/\//i.test(resolved)) {
+          properties.cover = `[[${resolved}]]`;
         } else {
           properties.cover = cover.url;
         }
@@ -4904,11 +5673,12 @@ var DatabaseSyncer = class {
     if (existingRecord?.obsidianPath) {
       filePath = existingRecord.obsidianPath;
     } else {
-      filePath = `${dbConfig.localFolder}/${safeName}.md`;
-      const existingByPath = this.stateDb.getByPath(filePath);
-      if (existingByPath && existingByPath.notionPageId !== page.id) {
-        filePath = `${dbConfig.localFolder}/${safeName} (${page.id.slice(0, 8)}).md`;
-      }
+      filePath = resolveDbRowPath(
+        dbConfig.localFolder,
+        safeName,
+        page.id,
+        (p) => this.stateDb.getByPath(p)
+      );
     }
     const finalContent = this.pipeline.convertToMarkdown(
       markdown,
@@ -4976,8 +5746,7 @@ var DatabaseSyncer = class {
     const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
     this.propertyMapper.loadSchema(schema);
     const allFiles = await this.vaultFs.listMarkdownFiles();
-    const prefix = dbConfig.localFolder.endsWith("/") ? dbConfig.localFolder : dbConfig.localFolder + "/";
-    const dbFiles = allFiles.filter((f) => f.path.startsWith(prefix));
+    const dbFiles = selectDbRowFiles(allFiles, dbConfig.localFolder);
     const livePaths = new Set(dbFiles.map((f) => f.path));
     const orphanByHash = this.buildOrphanHashIndex(dbConfig.databaseId, livePaths);
     let created = 0;
@@ -4989,7 +5758,7 @@ var DatabaseSyncer = class {
         const hash = computeHash(content);
         const record = this.stateDb.getByPath(file.path);
         if (record?.contentHash === hash) continue;
-        const parsed = matter7(content);
+        const parsed = matter(content);
         const frontmatter = parsed.data;
         const body = parsed.content;
         const title = frontmatter.title ?? extractTitleFromPath(file.path);
@@ -5079,7 +5848,7 @@ var DatabaseSyncer = class {
       }
     }
     getLogger().debug(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
-    return { created, updated, conflicts: [], failed };
+    return { created, updated, conflicts: [], failed, writtenPaths: [] };
   }
   /**
    * rename 감지를 위한 고아 레코드 인덱스(내용 해시 → 레코드)를 만든다.
@@ -5110,82 +5879,381 @@ function extractTitleFromPath(filePath) {
   return filename.replace(/\.md$/, "");
 }
 
-// src/utils/pool.ts
-async function runPool(items, worker, options) {
-  const total = items.length;
-  if (total === 0) return;
-  const workerCount = Math.max(1, Math.min(Math.floor(options.concurrency) || 1, total));
+// 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;
-  const runWorker = async () => {
-    for (; ; ) {
-      if (options.signal?.aborted) return;
-      const index = cursor++;
-      if (index >= total) return;
-      try {
-        await worker(items[index], index);
-      } catch {
-      }
+  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 group = [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);
+      group.push(next);
+      i++;
+    }
+    const baseRegion = baseLines.slice(regionStart, regionEnd);
+    const localRegion = applyHunks(baseLines, group, 0, regionStart, regionEnd);
+    const remoteRegion = applyHunks(baseLines, group, 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
   };
-  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
 }
-
-// src/sync/orchestrator.ts
-var SyncOrchestrator = class {
-  constructor(config, stateDb, notionClient, vaultFs, customFetch) {
-    this.config = config;
-    this.stateDb = stateDb;
-    this.notionClient = notionClient;
-    this.vaultFs = vaultFs;
-    this.changeDetector = new ChangeDetector(stateDb);
-    this.pipeline = createDefaultPipeline({
-      wikilinkResolver: (text) => stateDb.resolveWikilink(text)
-    });
-    this.blockConverter = new BlockConverter();
-    this.imageHandler = new ImageHandler(
-      vaultFs,
-      config.paths.attachments,
-      notionClient,
-      customFetch,
-      {
-        concurrency: config.advanced.mediaConcurrency,
-        maxRetries: config.advanced.mediaMaxRetries,
-        retryBaseMs: config.advanced.mediaRetryBaseMs,
-        maxFileSizeBytes: config.advanced.maxFileSizeBytes
-      }
-    );
-    this.fileHandler = new FileHandler(
-      vaultFs,
-      notionClient,
-      stateDb,
-      config.advanced.fileConcurrency
-    );
-    this.propertyMapper = new PropertyMapper();
-    this.databaseSyncer = new DatabaseSyncer(
-      config,
-      stateDb,
-      notionClient,
-      vaultFs,
-      this.pipeline,
-      this.imageHandler
-    );
-    this.propertyMapper.setWikilinkResolver({
-      resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
-      resolvePageId: (pageId) => stateDb.resolvePageId(pageId)?.title ?? null
-    });
-    this.blockConverter.initNotionToMd(this.notionClient.getInternalClient());
-  }
-  config;
-  stateDb;
-  notionClient;
-  vaultFs;
-  changeDetector;
-  pipeline;
-  blockConverter;
+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, group, side, regionStart, regionEnd) {
+  const out = [];
+  let b = regionStart;
+  for (const hunk of group) {
+    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/conflict/resolver.ts
+var ConflictResolver = class {
+  constructor(stateDb, vaultFs) {
+    this.stateDb = stateDb;
+    this.vaultFs = vaultFs;
+  }
+  stateDb;
+  vaultFs;
+  async resolve(conflict, choice) {
+    switch (choice) {
+      case "local":
+        return this.resolveLocal(conflict);
+      case "remote":
+        return this.resolveRemote(conflict);
+      case "merge":
+        return this.resolveMerge(conflict);
+      case "duplicate":
+        return this.resolveDuplicate(conflict);
+    }
+  }
+  async resolveByStrategy(conflict, strategy) {
+    switch (strategy) {
+      case "local-first":
+        return this.resolve(conflict, "local");
+      case "remote-first":
+        return this.resolve(conflict, "remote");
+      case "duplicate":
+        return this.resolve(conflict, "duplicate");
+      case "manual":
+        return this.resolve(conflict, "merge");
+    }
+  }
+  async resolveAll(conflicts, strategy) {
+    const results = [];
+    for (const conflict of conflicts) {
+      const result = await this.resolveByStrategy(conflict, strategy);
+      results.push(result);
+    }
+    return results;
+  }
+  async resolveLocal(conflict) {
+    const hash = computeHash(conflict.localContent);
+    this.stateDb.updateHash(
+      conflict.syncRecord.id,
+      hash,
+      Buffer.from(conflict.localContent, "utf-8")
+    );
+    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    return { path: conflict.syncRecord.obsidianPath, choice: "local", success: true };
+  }
+  async resolveRemote(conflict) {
+    await this.vaultFs.writeFile(conflict.syncRecord.obsidianPath, conflict.remoteContent);
+    const hash = computeHash(conflict.remoteContent);
+    this.stateDb.updateHash(
+      conflict.syncRecord.id,
+      hash,
+      Buffer.from(conflict.remoteContent, "utf-8")
+    );
+    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    return { path: conflict.syncRecord.obsidianPath, choice: "remote", success: true };
+  }
+  async resolveMerge(conflict) {
+    const base = conflict.baseContent ?? "";
+    const mergeResult = threeWayMerge(base, conflict.localContent, conflict.remoteContent);
+    await this.vaultFs.writeFile(conflict.syncRecord.obsidianPath, mergeResult.merged);
+    const hash = computeHash(mergeResult.merged);
+    this.stateDb.updateHash(conflict.syncRecord.id, hash, Buffer.from(mergeResult.merged, "utf-8"));
+    if (mergeResult.success) {
+      this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    }
+    return {
+      path: conflict.syncRecord.obsidianPath,
+      choice: "merge",
+      success: mergeResult.success,
+      mergeHadConflicts: !mergeResult.success
+    };
+  }
+  async resolveDuplicate(conflict) {
+    const originalPath = conflict.syncRecord.obsidianPath;
+    const ext = originalPath.endsWith(".md") ? ".md" : "";
+    const baseName = originalPath.replace(/\.md$/, "");
+    const conflictPath = `${baseName}.conflict${ext}`;
+    await this.vaultFs.writeFile(conflictPath, conflict.remoteContent);
+    const localHash = computeHash(conflict.localContent);
+    this.stateDb.updateHash(
+      conflict.syncRecord.id,
+      localHash,
+      Buffer.from(conflict.localContent, "utf-8")
+    );
+    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    return { path: originalPath, choice: "duplicate", success: true };
+  }
+  generateDiff(conflict) {
+    const localLines = conflict.localContent.split("\n");
+    const remoteLines = conflict.remoteContent.split("\n");
+    const lines = [];
+    lines.push(`--- local: ${conflict.syncRecord.obsidianPath}`);
+    lines.push(`+++ remote: Notion (${conflict.remoteChange.pageId})`);
+    lines.push("");
+    const maxLen = Math.max(localLines.length, remoteLines.length);
+    for (let i = 0; i < maxLen; i++) {
+      const localLine = localLines[i];
+      const remoteLine = remoteLines[i];
+      if (localLine === remoteLine) {
+        lines.push(`  ${localLine ?? ""}`);
+      } else {
+        if (localLine !== void 0) lines.push(`- ${localLine}`);
+        if (remoteLine !== void 0) lines.push(`+ ${remoteLine}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/utils/pool.ts
+async function runPool(items, worker, options) {
+  const total = items.length;
+  if (total === 0) return;
+  const workerCount = Math.max(1, Math.min(Math.floor(options.concurrency) || 1, total));
+  let cursor = 0;
+  const runWorker = async () => {
+    for (; ; ) {
+      if (options.signal?.aborted) return;
+      const index = cursor++;
+      if (index >= total) return;
+      try {
+        await worker(items[index], index);
+      } catch {
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$|^[0-9a-f]{32}$/i;
+function resolveFrontmatterRelations(content, idToTitle) {
+  if (!content.startsWith("---") || idToTitle.size === 0) {
+    return { content, count: 0 };
+  }
+  let parsed;
+  try {
+    parsed = matter(content);
+  } catch {
+    return { content, count: 0 };
+  }
+  const data = parsed.data;
+  if (!data || Object.keys(data).length === 0) {
+    return { content, count: 0 };
+  }
+  let count = 0;
+  const resolveValue = (value) => {
+    if (typeof value === "string") {
+      if (!UUID_RE.test(value)) return value;
+      const title = idToTitle.get(value.replace(/-/g, ""));
+      if (!title) return value;
+      count++;
+      return `[[${title}]]`;
+    }
+    if (Array.isArray(value)) return value.map(resolveValue);
+    return value;
+  };
+  const resolved = {};
+  for (const key of Object.keys(data)) {
+    resolved[key] = resolveValue(data[key]);
+  }
+  if (count === 0) return { content, count: 0 };
+  return { content: stringifyFrontmatter(parsed.content, resolved), count };
+}
+
+// src/sync/orchestrator.ts
+var INACCESSIBLE_DBS_META_KEY = "inaccessible_dbs";
+function strategyToChoice(strategy) {
+  switch (strategy) {
+    case "local-first":
+      return "local";
+    case "remote-first":
+      return "remote";
+    case "duplicate":
+      return "duplicate";
+    case "manual":
+      return "merge";
+  }
+}
+var SyncOrchestrator = class _SyncOrchestrator {
+  constructor(config, stateDb, notionClient, vaultFs, customFetch) {
+    this.config = config;
+    this.stateDb = stateDb;
+    this.notionClient = notionClient;
+    this.vaultFs = vaultFs;
+    this.changeDetector = new ChangeDetector(stateDb);
+    this.pipeline = createDefaultPipeline({
+      wikilinkResolver: (text) => stateDb.resolveWikilink(text)
+    });
+    this.blockConverter = new BlockConverter();
+    this.imageHandler = new ImageHandler(
+      vaultFs,
+      config.paths.attachments,
+      notionClient,
+      customFetch,
+      {
+        concurrency: config.advanced.mediaConcurrency,
+        maxRetries: config.advanced.mediaMaxRetries,
+        retryBaseMs: config.advanced.mediaRetryBaseMs,
+        maxFileSizeBytes: config.advanced.maxFileSizeBytes
+      },
+      stateDb
+    );
+    this.fileHandler = new FileHandler(
+      vaultFs,
+      notionClient,
+      stateDb,
+      config.advanced.fileConcurrency
+    );
+    this.propertyMapper = new PropertyMapper();
+    this.databaseSyncer = new DatabaseSyncer(
+      config,
+      stateDb,
+      notionClient,
+      vaultFs,
+      this.pipeline,
+      this.imageHandler
+    );
+    const wikilinkResolver = {
+      resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
+      resolvePageId: (pageId) => {
+        const entry = stateDb.resolvePageId(pageId);
+        return entry ? wikilinkTitleFromPath(entry.obsidianPath) : null;
+      }
+    };
+    this.propertyMapper.setWikilinkResolver(wikilinkResolver);
+    this.notionClient.setWikilinkResolver(wikilinkResolver);
+    this.blockConverter.initNotionToMd(this.notionClient.getInternalClient());
+    this.conflictResolver = new ConflictResolver(stateDb, vaultFs);
+  }
+  config;
+  stateDb;
+  notionClient;
+  vaultFs;
+  changeDetector;
+  pipeline;
+  blockConverter;
   imageHandler;
   fileHandler;
   databaseSyncer;
   propertyMapper;
+  conflictResolver;
   dbSchemaLoaded = false;
   _pullImageCount = 0;
   _pullFileCount = 0;
@@ -5194,6 +6262,16 @@ var SyncOrchestrator = class {
   // 블록 트리 재귀 없이 markdown 신호만으로 컬럼/synced_block 등 깊이 중첩된
   // child_database 까지 발견해 폴더+.base 동기화 대상으로 등록한다.
   _inlineDbRefs = /* @__PURE__ */ new Map();
+  // pull 발견 단계에서 모든 페이지의 부모를 해소하며 채우는 "자식을 가진 페이지" 집합
+  // (정규화된 page id). 폴더노트/폴더 판정의 단일 신뢰 원천 — 얕은 블록 검사로 callout·
+  // column 등 컨테이너에 중첩된 자식 페이지를 놓쳐 폴더노트를 file 로 오분류하던 결함
+  // (본문이 최상위로 밀려 ' (1).md' 로 분리)을 차단한다. detectRemoteChanges* 진입 시 재구성.
+  _childParentIds = /* @__PURE__ */ new Set();
+  // 서브트리 직접 순회(getChildPagesRecursive) 시간 예산. 초과하면 search 기반 디스커버리로
+  // 폴백한다. 분기점 근거: 워크스페이스 search 열거는 latency-bound 로 대략 이 수준(수천 페이지
+  // 워크스페이스에서 ~100s)이므로, 순회가 이 시간을 넘기면 search 가 더 저렴해진다. 작은 볼트는
+  // 이 예산 안에서 순회가 끝나 폴백 없이 빠르게 완료된다. (단위: ms)
+  static DISCOVERY_RECURSIVE_BUDGET_MS = 9e4;
   async push(options) {
     const startTime = Date.now();
     if (this.config.sync.direction === "pull") {
@@ -5201,6 +6279,7 @@ var SyncOrchestrator = class {
     }
     this.cleanupInterruptedSync();
     this.repairFolderRecords();
+    await this.recoverInterruptedPushOps();
     const stats = await this.vaultFs.listMarkdownFileStats();
     const changes = await this.changeDetector.detectLocalChangesFast(
       stats,
@@ -5271,10 +6350,11 @@ var SyncOrchestrator = class {
           await this.pushMove(change.path);
           counts.updated++;
           break;
-        case "deleted":
-          await this.pushDelete(change.path);
-          counts.deleted++;
+        case "deleted": {
+          const propagated = await this.pushDelete(change.path);
+          if (propagated) counts.deleted++;
           break;
+        }
       }
     };
     const retryQueue = [];
@@ -5338,6 +6418,7 @@ var SyncOrchestrator = class {
     this.stateDb.setMeta("last_push_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("push_in_progress", "");
+    this.stateDb.clearCompletedOperations();
     return {
       created: counts.created,
       updated: counts.updated,
@@ -5371,36 +6452,35 @@ var SyncOrchestrator = class {
     const conflicts = [];
     const writtenPaths = [];
     const failed = [];
-    const lastPull = this.stateDb.getMeta("last_pull_at") ?? this.stateDb.getMeta("last_sync_at");
-    const trackedCount = this.stateDb.getAll().length;
-    const remoteChanges = !this.isDatabaseMode && lastPull && trackedCount > 0 && !options?.force ? await this.detectRemoteChangesIncremental(lastPull) : await this.detectRemoteChanges();
-    const filtered = options?.paths ? remoteChanges.filter((c) => {
-      const record = this.stateDb.getByNotionId(c.pageId);
-      return record && options.paths.some((p) => record.obsidianPath.startsWith(p));
-    }) : remoteChanges;
-    if (filtered.length === 0 && (this.config.notion.databases?.length ?? 0) === 0) {
-      const hasDbResults = await this.pullDiscoveredDatabases(writtenPaths, failed, conflicts);
-      if (!hasDbResults.created && !hasDbResults.updated) {
-        this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
-        this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
-        this.stateDb.setMeta("pull_in_progress", "");
-        return emptyResult;
-      }
+    const finalize = async (created, updated, deleted) => {
+      const linkCount = writtenPaths.length > 0 ? await this.resolveNotionLinks(writtenPaths) : 0;
       this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
       this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
       this.stateDb.setMeta("pull_in_progress", "");
       return {
-        created: hasDbResults.created,
-        updated: hasDbResults.updated,
-        deleted: 0,
+        created,
+        updated,
+        deleted,
         conflicts,
         writtenPaths,
         failed,
         duration: Date.now() - startTime,
-        imageCount: 0,
-        fileCount: 0,
-        linkCount: 0
+        imageCount: this._pullImageCount,
+        fileCount: this._pullFileCount,
+        linkCount
       };
+    };
+    const lastPull = this.stateDb.getMeta("last_pull_at") ?? this.stateDb.getMeta("last_sync_at");
+    const trackedCount = this.stateDb.getAll().length;
+    const canUseIncremental = !this.isDatabaseMode && !!lastPull && trackedCount > 0 && !options?.force && !this.config.sync.deleteSync;
+    const remoteChanges = canUseIncremental ? await this.detectRemoteChangesIncremental(lastPull) : await this.detectRemoteChanges();
+    const filtered = options?.paths ? remoteChanges.filter((c) => {
+      const record = this.stateDb.getByNotionId(c.pageId);
+      return record && options.paths.some((p) => record.obsidianPath.startsWith(p));
+    }) : remoteChanges;
+    if (filtered.length === 0 && (this.config.notion.databases?.length ?? 0) === 0) {
+      const dbDiscovery = await this.pullDiscoveredDatabases(writtenPaths, failed, conflicts);
+      return finalize(dbDiscovery.created, dbDiscovery.updated, 0);
     }
     if (filtered.length === 0) {
       return emptyResult;
@@ -5453,7 +6533,7 @@ var SyncOrchestrator = class {
           const result = await this.pullUpdate(change);
           if (result.conflict) {
             conflicts.push(result.conflict);
-          } else if (result.path) {
+          } else if (result.path && !result.unchanged) {
             writtenPaths.push(result.path);
             counts.updated++;
           }
@@ -5520,10 +6600,7 @@ var SyncOrchestrator = class {
         counts.updated += dbResult.updated;
         conflicts.push(...dbResult.conflicts);
         failed.push(...dbResult.failed);
-        if (dbResult.created + dbResult.updated > 0) {
-          const dbPaths = this.stateDb.getByStatus("synced").filter((r) => r.fileType === "db-row").map((r) => r.obsidianPath);
-          writtenPaths.push(...dbPaths.slice(-dbResult.created - dbResult.updated));
-        }
+        writtenPaths.push(...dbResult.writtenPaths);
       } catch (error) {
         getLogger().warn("[Im-Nobsidian] DB Pull \uC911 \uC624\uB958:", error);
       }
@@ -5533,23 +6610,7 @@ var SyncOrchestrator = class {
       counts.created += dbDiscovery.created;
       counts.updated += dbDiscovery.updated;
     }
-    const linkTargetPaths = writtenPaths.length > 0 ? writtenPaths : [];
-    const linkCount = linkTargetPaths.length > 0 ? await this.resolveNotionLinks(linkTargetPaths) : 0;
-    this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
-    this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
-    this.stateDb.setMeta("pull_in_progress", "");
-    return {
-      created: counts.created,
-      updated: counts.updated,
-      deleted: counts.deleted,
-      conflicts,
-      writtenPaths,
-      failed,
-      duration: Date.now() - startTime,
-      imageCount: this._pullImageCount,
-      fileCount: this._pullFileCount,
-      linkCount
-    };
+    return finalize(counts.created, counts.updated, counts.deleted);
   }
   async sync(options) {
     const startTime = Date.now();
@@ -5570,7 +6631,7 @@ var SyncOrchestrator = class {
     const files = await this.vaultFs.listMarkdownFiles();
     const localChanges = this.changeDetector.detectLocalChanges(files);
     const lastSyncAt = this.stateDb.getMeta("last_sync_at");
-    const remoteChanges = lastSyncAt ? await this.detectRemoteChangesIncremental(lastSyncAt) : await this.detectRemoteChanges();
+    const remoteChanges = lastSyncAt && !this.config.sync.deleteSync ? await this.detectRemoteChangesIncremental(lastSyncAt) : await this.detectRemoteChanges();
     const conflictRecords = this.stateDb.getByStatus("conflict");
     const conflicts = await this.buildConflictsFromRecords(
       conflictRecords,
@@ -5681,37 +6742,57 @@ var SyncOrchestrator = class {
    * - 제목 취득 실패 시 부모 폴더명 기반 안전 이름으로 폴백
    */
   async buildDiscoveredDbConfig(dbId, parentPageId) {
+    let dbTitle;
     try {
-      const dbTitle = await this.notionClient.getDatabaseTitle(dbId);
-      const parentEntry = parentPageId ? this.stateDb.getByNotionId(parentPageId) : null;
-      let parentFolder = "";
-      if (parentEntry?.obsidianPath) {
-        const obsPath = parentEntry.obsidianPath;
-        if (obsPath.endsWith(".md")) {
-          const parts = obsPath.split("/");
-          parts.pop();
-          parentFolder = parts.length > 0 ? parts.join("/") : obsPath.replace(/\.md$/, "");
-        } else {
-          parentFolder = obsPath;
-        }
+      const info = await this.notionClient.getDatabaseSyncability(dbId);
+      if (!info.queryable) {
+        return { kind: "inaccessible" };
       }
-      let safeName;
-      if (dbTitle) {
-        safeName = dbTitle.replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-");
+      dbTitle = info.title;
+    } catch (error) {
+      if (isNotionObjectNotFound(error)) return { kind: "inaccessible" };
+      getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uC124\uC815 \uC0DD\uC131 \uC2E4\uD328:`, error);
+      return { kind: "error" };
+    }
+    const parentEntry = parentPageId ? this.stateDb.getByNotionId(parentPageId) : null;
+    let parentFolder = "";
+    if (parentEntry?.obsidianPath) {
+      const obsPath = parentEntry.obsidianPath;
+      if (obsPath.endsWith(".md")) {
+        const parts = obsPath.split("/");
+        parts.pop();
+        parentFolder = parts.length > 0 ? parts.join("/") : obsPath.replace(/\.md$/, "");
       } else {
-        const parentName = parentFolder.split("/").pop() || "";
-        safeName = parentName ? `${parentName}-DB` : `db-${dbId.replace(/-/g, "").slice(0, 8)}`;
+        parentFolder = obsPath;
       }
-      if (!safeName) safeName = `db-${dbId.replace(/-/g, "").slice(0, 8)}`;
-      if (!parentFolder) parentFolder = "databases";
-      return {
+    }
+    let safeName;
+    if (dbTitle) {
+      safeName = dbTitle.replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-");
+    } else {
+      const parentName = parentFolder.split("/").pop() || "";
+      safeName = parentName ? `${parentName}-DB` : `db-${dbId.replace(/-/g, "").slice(0, 8)}`;
+    }
+    if (!safeName) safeName = `db-${dbId.replace(/-/g, "").slice(0, 8)}`;
+    if (!parentFolder) parentFolder = "databases";
+    return {
+      kind: "ok",
+      config: {
         databaseId: dbId,
         localFolder: `${parentFolder}/${safeName}`,
         titleProperty: "Name"
-      };
-    } catch (error) {
-      getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uC124\uC815 \uC0DD\uC131 \uC2E4\uD328:`, error);
-      return null;
+      }
+    };
+  }
+  /** 접근 불가 DB denylist 를 상태 메타에서 로드한다(하이픈 정규화). */
+  loadInaccessibleDbIds() {
+    const raw = this.stateDb.getMeta(INACCESSIBLE_DBS_META_KEY);
+    if (!raw) return /* @__PURE__ */ new Set();
+    try {
+      const arr = JSON.parse(raw);
+      return new Set(arr.map((id) => id.replace(/-/g, "")));
+    } catch {
+      return /* @__PURE__ */ new Set();
     }
   }
   async pullDiscoveredDatabases(writtenPaths, failed, conflicts) {
@@ -5736,46 +6817,71 @@ var SyncOrchestrator = class {
         ...dbConfigs.map((c) => c.databaseId.replace(/-/g, ""))
       ]);
       let changed = false;
+      const inaccessibleIds = this.loadInaccessibleDbIds();
+      let inaccessibleChanged = false;
+      const degrade = (rawId) => {
+        const nohyph = rawId.replace(/-/g, "");
+        if (!inaccessibleIds.has(nohyph)) {
+          inaccessibleIds.add(nohyph);
+          inaccessibleChanged = true;
+        }
+        getLogger().info(
+          `[Im-Nobsidian] DB ${rawId}: \uC811\uADFC \uAC00\uB2A5\uD55C data source \uC5C6\uC74C(\uB9C1\uD06C\uB4DC/\uBBF8\uACF5\uC720/\uC0AD\uC81C \uCD94\uC815) \u2014 \uB3D9\uAE30\uD654 \uB300\uC0C1\uC5D0\uC11C \uC81C\uC678(\uC81C\uBAA9\uC740 \uBD80\uBAA8 \uD398\uC774\uC9C0\uC5D0 \uBCF4\uC874)`
+        );
+      };
       if (dbConfigs.length === 0) {
         const discovered = await this.discoverChildDatabases();
         for (const { dbId, parentPageId } of discovered) {
           const nohyph = dbId.replace(/-/g, "");
-          if (knownIds.has(nohyph)) continue;
-          const cfg = await this.buildDiscoveredDbConfig(dbId, parentPageId);
-          if (cfg) {
-            dbConfigs.push(cfg);
-            knownIds.add(nohyph);
+          if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) continue;
+          const outcome = await this.buildDiscoveredDbConfig(dbId, parentPageId);
+          knownIds.add(nohyph);
+          if (outcome.kind === "ok") {
+            dbConfigs.push(outcome.config);
             changed = true;
+          } else if (outcome.kind === "inaccessible") {
+            degrade(dbId);
           }
         }
       }
       for (const [nohyph, parentPageId] of this._inlineDbRefs) {
-        if (knownIds.has(nohyph)) continue;
-        const cfg = await this.buildDiscoveredDbConfig(normalizeNotionId(nohyph), parentPageId);
-        if (cfg) {
-          dbConfigs.push(cfg);
-          knownIds.add(nohyph);
+        if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) continue;
+        const dbId = normalizeNotionId(nohyph);
+        const outcome = await this.buildDiscoveredDbConfig(dbId, parentPageId);
+        knownIds.add(nohyph);
+        if (outcome.kind === "ok") {
+          dbConfigs.push(outcome.config);
           changed = true;
+        } else if (outcome.kind === "inaccessible") {
+          degrade(dbId);
         }
       }
-      if (changed && dbConfigs.length > 0) {
-        this.stateDb.setMeta("discovered_dbs", JSON.stringify(dbConfigs));
-      }
+      const stillSyncable = [];
       for (const dbConfig of dbConfigs) {
+        if (inaccessibleIds.has(dbConfig.databaseId.replace(/-/g, ""))) continue;
         try {
           const dbResult = await this.databaseSyncer.pullDatabase(dbConfig);
           created += dbResult.created;
           updated += dbResult.updated;
           conflicts.push(...dbResult.conflicts);
           failed.push(...dbResult.failed);
-          if (dbResult.created + dbResult.updated > 0) {
-            const dbPaths = this.stateDb.getByStatus("synced").filter((r) => r.fileType === "db-row").map((r) => r.obsidianPath);
-            writtenPaths.push(...dbPaths.slice(-dbResult.created - dbResult.updated));
-          }
+          writtenPaths.push(...dbResult.writtenPaths);
+          stillSyncable.push(dbConfig);
         } catch (error) {
-          getLogger().warn(`[Im-Nobsidian] DB ${dbConfig.databaseId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+          if (isNotionObjectNotFound(error)) {
+            degrade(dbConfig.databaseId);
+          } else {
+            getLogger().warn(`[Im-Nobsidian] DB ${dbConfig.databaseId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+            stillSyncable.push(dbConfig);
+          }
         }
       }
+      if (changed || inaccessibleChanged || stillSyncable.length !== dbConfigs.length) {
+        this.stateDb.setMeta("discovered_dbs", JSON.stringify(stillSyncable));
+      }
+      if (inaccessibleChanged) {
+        this.stateDb.setMeta(INACCESSIBLE_DBS_META_KEY, JSON.stringify([...inaccessibleIds]));
+      }
     } catch (error) {
       getLogger().warn("[Im-Nobsidian] child_database \uC790\uB3D9 \uBC1C\uACAC \uC2E4\uD328:", error);
     }
@@ -5787,7 +6893,7 @@ var SyncOrchestrator = class {
     const idToTitle = /* @__PURE__ */ new Map();
     for (const r of allRecords) {
       if (r.notionPageId && r.obsidianPath) {
-        const title = r.obsidianPath.replace(/\.md$/, "").split("/").pop() ?? "";
+        const title = wikilinkTitleFromPath(r.obsidianPath);
         const cleanId = r.notionPageId.replace(/-/g, "");
         idToTitle.set(cleanId, title);
         idToTitle.set(r.notionPageId, title);
@@ -5822,8 +6928,26 @@ var SyncOrchestrator = class {
           }
         );
         content = resolved2;
+        const fm = resolveFrontmatterRelations(content, idToTitle);
+        if (fm.count > 0) {
+          content = fm.content;
+          totalResolved += fm.count;
+          changed = true;
+        }
         if (changed) {
           await this.vaultFs.writeFile(filePath, content);
+          const record = this.stateDb.getByPath(filePath);
+          if (record) {
+            const stat2 = await this.vaultFs.getFileStat(filePath);
+            this.stateDb.transaction(() => {
+              this.stateDb.updateHash(
+                record.id,
+                computeHash(content),
+                Buffer.from(content, "utf-8")
+              );
+              if (stat2) this.stateDb.updateStatCache(record.id, stat2.mtime, stat2.size);
+            });
+          }
         }
       } catch {
       }
@@ -5869,6 +6993,27 @@ var SyncOrchestrator = class {
         title
       );
     }
+    const placeholder = this.stateDb.upsert({
+      obsidianPath: path,
+      notionPageId: null,
+      notionParentId: parentId,
+      contentHash: "",
+      notionLastEdited: null,
+      localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      syncDirection: "both",
+      fileType: this.isFolderNote(path) ? "folder-note" : "file",
+      status: "pending",
+      baseSnapshot: null,
+      localMtime: null,
+      localFileSize: null
+    });
+    const existingOp = this.stateDb.getIncompleteOpByState(placeholder.id, "create");
+    const walOpId = existingOp?.id ?? this.stateDb.recordPendingOperation({
+      syncStateId: placeholder.id,
+      operation: "create",
+      direction: "push",
+      payload: JSON.stringify({ path, parentId, title })
+    });
     const page = await this.pushCreatePage(
       effectiveParentId,
       effectiveParentType,
@@ -5917,6 +7062,7 @@ var SyncOrchestrator = class {
       });
       this.stateDb.storePreserveMarkers(path, conversionResult.preserveMarkers);
     });
+    this.stateDb.markPendingCompleted(walOpId);
   }
   async pushUpdate(path) {
     const content = await this.vaultFs.readFile(path);
@@ -5947,13 +7093,16 @@ var SyncOrchestrator = class {
         title: { title: [{ text: { content: titleStr } }] }
       };
     }
-    let lastEditedTime = (/* @__PURE__ */ new Date()).toISOString();
+    let lastEditedTime;
     if (propsToUpdate && Object.keys(propsToUpdate).length > 0) {
       const updatedPage = await this.notionClient.updatePageProperties(
         record.notionPageId,
         propsToUpdate
       );
       lastEditedTime = updatedPage.last_edited_time;
+    } else {
+      const refreshed = await this.notionClient.getPage(record.notionPageId);
+      lastEditedTime = refreshed.last_edited_time;
     }
     const hash = computeHash(content);
     const fileStat = await this.vaultFs.getFileStat(path);
@@ -5975,25 +7124,78 @@ var SyncOrchestrator = class {
       });
     });
   }
+  // ──────────────────────────────────────────────────────────────────────────
+  // 충돌 해소 (I8) — 해소 결과를 로컬에만 쓰지 않고 Notion 으로 재push + notionLastEdited
+  // 재조정까지 한 트랜잭션으로 묶는다. ConflictResolver 단독은 로컬 write + updateHash 만
+  // 수행하므로(merge 결과가 Notion 에 반영되지 않음) 다음 pull 이 원격으로 덮어써 영구
+  // 유실·충돌 루프가 발생한다. 해소 → 전파(propagate)를 오케스트레이터에서 봉합해 무손실
+  // 보장. 변환 파이프라인이 필요한 push 는 기존 엔터프라이즈 경로(pushUpdate)를 재사용한다.
+  // ──────────────────────────────────────────────────────────────────────────
+  /** 단일 충돌을 사용자가 고른 선택지(local/remote/merge/duplicate)로 해소 + Notion 전파. */
+  async resolveConflict(conflict, choice) {
+    const result = await this.conflictResolver.resolve(conflict, choice);
+    await this.propagateResolution(conflict, choice, result);
+    return result;
+  }
+  /** 단일 충돌을 전략(manual/local-first/remote-first/duplicate)으로 해소 + Notion 전파. */
+  async resolveConflictByStrategy(conflict, strategy) {
+    const result = await this.conflictResolver.resolveByStrategy(conflict, strategy);
+    await this.propagateResolution(conflict, strategyToChoice(strategy), result);
+    return result;
+  }
+  /** 여러 충돌을 동일 전략으로 일괄 해소 + Notion 전파. */
+  async resolveAllConflicts(conflicts, strategy) {
+    const results = [];
+    for (const conflict of conflicts) {
+      results.push(await this.resolveConflictByStrategy(conflict, strategy));
+    }
+    return results;
+  }
+  /** 충돌 미리보기용 통합 diff(원본 vs 로컬 vs 원격). 해소 없이 표시 전용. */
+  generateConflictDiff(conflict) {
+    return this.conflictResolver.generateDiff(conflict);
+  }
+  /**
+   * 해소 결과를 Notion 으로 전파해 로컬↔원격 일관성을 봉합한다.
+   * - remote 선택: 로컬이 원격으로 갱신됐을 뿐이므로 push 불필요. notionLastEdited 만
+   *   원격 변경의 lastEdited 로 재조정 → 다음 pull 이 같은 변경을 재충돌로 보지 않음.
+   * - merge 실패(충돌 마커 잔존): 사용자가 직접 풀어야 하므로 conflict 상태 유지·push 안 함.
+   * - local / merge(성공) / duplicate: 해소된 로컬 내용을 Notion 에 재push(pushUpdate 가
+   *   변환·이미지·속성·해시·notionLastEdited 를 한 트랜잭션으로 재조정) → 무손실 수렴.
+   */
+  async propagateResolution(conflict, choice, result) {
+    const record = conflict.syncRecord;
+    if (!record.notionPageId) return;
+    if (choice === "remote") {
+      this.stateDb.setNotionLastEdited(record.id, conflict.remoteChange.lastEdited);
+      return;
+    }
+    if (!result.success) return;
+    await this.pushUpdate(record.obsidianPath);
+  }
+  // 반환값: 실제로 원격(Notion) 삭제가 전파되었는지 여부.
+  // deleteSync=false 면 로컬 삭제를 pending 으로만 기록하고 Notion 은 보존하므로
+  // false 를 돌려준다 → 호출부가 deleted 카운트를 올리지 않아 보고가 정직해진다.
   async pushDelete(path) {
     const record = this.stateDb.getByPath(path);
-    if (!record?.notionPageId) return;
-    if (this.config.sync.deleteSync) {
-      try {
-        await this.notionClient.archivePage(record.notionPageId);
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes("archived ancestor")) ; else {
-          throw error;
-        }
-      }
-      this.stateDb.transaction(() => {
-        this.stateDb.delete(record.id);
-        this.stateDb.deleteWikilink(record.obsidianPath);
-      });
-    } else {
+    if (!record?.notionPageId) return false;
+    if (!this.config.sync.deleteSync) {
       this.stateDb.updateStatus(record.id, "pending");
+      return false;
+    }
+    try {
+      await this.notionClient.archivePage(record.notionPageId);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (msg.includes("archived ancestor")) ; else {
+        throw error;
+      }
     }
+    this.stateDb.transaction(() => {
+      this.stateDb.delete(record.id);
+      this.stateDb.deleteWikilink(record.obsidianPath);
+    });
+    return true;
   }
   async pushMove(path) {
     const record = this.stateDb.getByPath(path);
@@ -6013,6 +7215,7 @@ var SyncOrchestrator = class {
   }
   async detectRemoteChanges() {
     const changes = [];
+    this._childParentIds.clear();
     const lastPull = this.stateDb.getMeta("last_pull_at");
     const syncedRecords = this.stateDb.getAll();
     const trackedPageIds = new Set(
@@ -6033,11 +7236,32 @@ var SyncOrchestrator = class {
       } while (cursor);
       remotePages = allPages;
     } else {
-      const allAccessible = await this.notionClient.searchAllPages();
-      const underRoot = await this.filterPagesUnderRoot(allAccessible);
+      let underRoot;
+      try {
+        underRoot = await this.notionClient.getChildPagesRecursive(this.config.notion.rootPageId, {
+          deadlineMs: Date.now() + _SyncOrchestrator.DISCOVERY_RECURSIVE_BUDGET_MS
+        });
+      } catch (error) {
+        if (!(error instanceof DiscoveryTooLargeError)) throw error;
+        getLogger().info(
+          `[Im-Nobsidian] \uC11C\uBE0C\uD2B8\uB9AC\uAC00 \uD07C(${error.message}) \u2192 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 search \uAE30\uBC18 \uB514\uC2A4\uCEE4\uBC84\uB9AC\uB85C \uC804\uD658`
+        );
+        underRoot = await this.notionClient.getPagesUnderRootViaSearch(
+          this.config.notion.rootPageId
+        );
+      }
+      this._childParentIds.add(normalizeNotionId(this.config.notion.rootPageId));
+      for (const page of underRoot) {
+        const parentId = await this.extractParentId(page);
+        if (parentId) this._childParentIds.add(normalizeNotionId(parentId));
+      }
       remotePages = underRoot.map((p) => ({ id: p.id, last_edited_time: p.last_edited_time }));
     }
+    const seenRemoteIds = /* @__PURE__ */ new Set();
     for (const page of remotePages) {
+      const key = normalizeNotionId(page.id);
+      if (seenRemoteIds.has(key)) continue;
+      seenRemoteIds.add(key);
       const record = this.stateDb.getByNotionId(page.id);
       if (!record) {
         changes.push({
@@ -6071,8 +7295,16 @@ var SyncOrchestrator = class {
     }
     return changes;
   }
+  /**
+   * 증분 원격 변경 감지 — `since` 이후 수정된 페이지만 search 로 받아 created/modified 만
+   * 만든다. **삭제는 의도적으로 감지하지 않는다**: search API 는 in_trash/archived 페이지를
+   * 반환하지 않아(=사라진 것을 증분만으로는 구분 불가) 삭제 판정에는 전체 enumeration 이
+   * 필수다. 따라서 호출부는 `deleteSync` 가 켜진 경우 이 fast-path 를 쓰지 않고
+   * `detectRemoteChanges`(전체 스캔, 삭제 diff 포함)로 우회한다. (I10)
+   */
   async detectRemoteChangesIncremental(since) {
     const changes = [];
+    this._childParentIds.clear();
     const recentPages = await this.notionClient.searchRecentPages(since);
     for (const page of recentPages) {
       const record = this.stateDb.getByNotionId(page.id);
@@ -6080,6 +7312,7 @@ var SyncOrchestrator = class {
         try {
           const fullPage = await this.notionClient.getPage(page.id);
           const parentId = await this.extractParentId(fullPage);
+          if (parentId) this._childParentIds.add(normalizeNotionId(parentId));
           if (parentId && this.isTrackedParent(parentId)) {
             changes.push({
               pageId: page.id,
@@ -6107,85 +7340,12 @@ var SyncOrchestrator = class {
     if (notionIdsEqual(parentId, this.config.notion.rootPageId)) return true;
     return !!this.stateDb.getByNotionId(parentId);
   }
-  /**
-   * search API로 받은 전체 접근 가능 페이지 중 rootPageId 하위(자손)만 남긴다.
-   * 각 페이지의 parent 체인을 root에 닿을 때까지 거슬러 올라가며 판정한다.
-   * - 부모가 이미 받은 페이지면 추가 API 호출 없이 메모리에서 해석(공통 경로)
-   * - 부모가 검색 결과에 없으면(데이터베이스·미공유 조상 등) getPage로 1회 조회 후 캐시
-   * - 조회 불가/순환/깊이 초과 시 보수적으로 root 하위가 아님으로 판정
-   * 판정 결과는 체인 전체에 메모이즈해 형제 페이지 처리 시 재사용한다.
-   */
-  async filterPagesUnderRoot(allPages) {
-    const root = normalizeNotionId(this.config.notion.rootPageId);
-    const byId = /* @__PURE__ */ new Map();
-    for (const p of allPages) byId.set(normalizeNotionId(p.id), p);
-    const verdict = /* @__PURE__ */ new Map();
-    const isUnderRoot = async (start) => {
-      const chain = [];
-      let current = start;
-      let result = false;
-      while (current) {
-        const id = normalizeNotionId(current.id);
-        if (id === root) {
-          result = true;
-          break;
-        }
-        const memo = verdict.get(id);
-        if (memo !== void 0) {
-          result = memo;
-          break;
-        }
-        if (chain.includes(id)) {
-          result = false;
-          break;
-        }
-        chain.push(id);
-        const parentId = await this.extractParentId(current);
-        if (!parentId) {
-          result = false;
-          break;
-        }
-        const pid = normalizeNotionId(parentId);
-        if (pid === root) {
-          result = true;
-          break;
-        }
-        const memoParent = verdict.get(pid);
-        if (memoParent !== void 0) {
-          result = memoParent;
-          break;
-        }
-        let parentPage = byId.get(pid) ?? null;
-        if (!parentPage) {
-          try {
-            parentPage = await this.notionClient.getPage(parentId);
-            byId.set(pid, parentPage);
-          } catch {
-            result = false;
-            break;
-          }
-        }
-        current = parentPage;
-      }
-      for (const id of chain) verdict.set(id, result);
-      return result;
-    };
-    const out = [];
-    for (const p of allPages) {
-      if (normalizeNotionId(p.id) === root) continue;
-      if (await isUnderRoot(p)) out.push(p);
-    }
-    return out;
-  }
   async pullCreate(pageId) {
     const page = await this.notionClient.getPage(pageId);
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
     const parentPath = await this.resolveParentPath(page);
-    const firstChildren = await this.notionClient.listChildren(pageId, {
-      pageSize: this.config.advanced.pageSize
-    });
-    const hasChildPages = firstChildren.results.some((b) => "type" in b && b.type === "child_page");
+    const hasChildPages = await this.pageHasChildContainers(pageId);
     const markdown = await this.fetchPageMarkdown(pageId);
     const hasContent = markdown.trim().length > 0;
     let filePath;
@@ -6234,10 +7394,10 @@ var SyncOrchestrator = class {
       },
       { properties }
     );
+    const resolvedParentId = await this.extractParentId(page);
     await this.vaultFs.writeFile(filePath, finalContent);
     const hash = computeHash(finalContent);
     const pullStat = await this.vaultFs.getFileStat(filePath);
-    const resolvedParentId = await this.extractParentId(page);
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
         obsidianPath: filePath,
@@ -6263,6 +7423,28 @@ var SyncOrchestrator = class {
     });
     return filePath;
   }
+  /**
+   * 페이지가 폴더(자식 페이지·자식 DB 보유)인지 신뢰성 있게 판정한다.
+   *
+   * 결함(폴더노트 본문분리)의 근본 원인은 얕은 판정이었다 — 최상위 블록 첫 페이지에서
+   * child_page 만 검사하면 callout·column·toggle 안에 중첩된 자식 페이지나 child_database 를
+   * 놓쳐 폴더노트가 file 로 오분류되고, 본문이 폴더 밖 최상위로 밀려 resolveUniqueFilePath
+   * 충돌(' (1).md')로 쪼개졌다.
+   *
+   * 1차: 발견 단계(서브트리 순회/증분)에서 전 페이지의 부모를 해소하며 만든
+   *      _childParentIds 집합으로 O(1) 판정(추가 API 호출 0, 처리 순서 무관) — 전체 pull 경로.
+   * 폴백: 집합에 없을 때만(증분 pull 의 신규 폴더 등) fetchAllChildrenDeep 로 컨테이너를
+   *       재귀 탐색해 child_page·child_database 를 직접 확인한다.
+   */
+  async pageHasChildContainers(pageId) {
+    if (this._childParentIds.has(normalizeNotionId(pageId))) return true;
+    try {
+      const deep = await this.notionClient.fetchAllChildrenDeep(pageId);
+      return deep.some((b) => b.type === "child_page" || b.type === "child_database");
+    } catch {
+      return false;
+    }
+  }
   async pullUpdate(change) {
     const record = this.stateDb.getByNotionId(change.pageId);
     if (!record) return {};
@@ -6318,6 +7500,24 @@ var SyncOrchestrator = class {
       this.stateDb.updateStatus(record.id, "conflict");
       return { conflict: resolution.conflict };
     }
+    if (remoteContent === localContent) {
+      const stat2 = await this.vaultFs.getFileStat(record.obsidianPath);
+      this.stateDb.upsert({
+        obsidianPath: record.obsidianPath,
+        notionPageId: change.pageId,
+        notionParentId: record.notionParentId,
+        contentHash: computeHash(remoteContent),
+        notionLastEdited: page.last_edited_time,
+        localLastModified: record.localLastModified,
+        syncDirection: record.syncDirection,
+        fileType: record.fileType,
+        status: "synced",
+        baseSnapshot: Buffer.from(remoteContent, "utf-8"),
+        localMtime: stat2?.mtime ?? record.localMtime ?? null,
+        localFileSize: stat2?.size ?? record.localFileSize ?? null
+      });
+      return { path: record.obsidianPath, unchanged: true };
+    }
     await this.vaultFs.writeFile(record.obsidianPath, remoteContent);
     const updateStat = await this.vaultFs.getFileStat(record.obsidianPath);
     const newHash = computeHash(remoteContent);
@@ -6492,7 +7692,26 @@ var SyncOrchestrator = class {
     }
     return page;
   }
+  // 페이지에 살아있는(휴지통 아님) child page/database 가 직속 블록으로 존재하는가.
+  // 휴지통(in_trash) 자식은 children.list 에 잡히지 않으므로 "live" 는 암묵적이다.
+  async pageHasLiveChildren(pageId) {
+    try {
+      const children = await this.notionClient.fetchAllChildren(pageId);
+      return children.some((b) => b.type === "child_page" || b.type === "child_database");
+    } catch (error) {
+      getLogger().warn(
+        `[Im-Nobsidian] \uC790\uC2DD \uD398\uC774\uC9C0 \uC870\uD68C \uC2E4\uD328 \u2014 \uBCF8\uBB38 push \uBCF4\uC218\uC801 \uC0DD\uB7B5(\uC790\uC2DD \uBCF4\uD638): ${pageId} (${error instanceof Error ? error.message : String(error)})`
+      );
+      return true;
+    }
+  }
   async pushUpdatePage(pageId, markdownContent, _baseSnapshot) {
+    if (await this.pageHasLiveChildren(pageId)) {
+      getLogger().warn(
+        `[Im-Nobsidian] \uC790\uC2DD \uD398\uC774\uC9C0 \uBCF4\uC720 \u2014 \uBCF8\uBB38 push \uC0DD\uB7B5(\uC790\uC2DD \uC0AD\uC81C \uBC29\uC9C0): ${pageId}. \uC790\uC2DD \uD398\uC774\uC9C0\uB294 \uAC01\uC790 \uB3D9\uAE30\uD654\uB418\uBA70, \uC774 \uD398\uC774\uC9C0 \uBCF8\uBB38 \uD3B8\uC9D1\uC740 Notion \uC5D0 \uBC18\uC601\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`
+      );
+      return;
+    }
     if (this.config.conversion.preferMarkdownApi !== false) {
       const enhanced = obsidianToNotionEnhanced(markdownContent);
       await this.notionClient.replacePageMarkdown(pageId, enhanced);
@@ -6589,486 +7808,334 @@ var SyncOrchestrator = class {
       this.stateDb.setMeta("pull_in_progress", "");
     }
   }
-  async resolveUniqueFilePath(basePath) {
-    if (!await this.vaultFs.exists(basePath)) return basePath;
-    const dir = basePath.lastIndexOf("/") >= 0 ? basePath.slice(0, basePath.lastIndexOf("/")) : "";
-    const ext = ".md";
-    const name = basePath.slice(dir ? dir.length + 1 : 0, -ext.length);
-    for (let i = 1; i <= 99; i++) {
-      const candidate = dir ? `${dir}/${name} (${i})${ext}` : `${name} (${i})${ext}`;
-      if (!await this.vaultFs.exists(candidate)) return candidate;
-    }
-    return basePath;
-  }
-};
-function extractTitle(filePath) {
-  const parts = filePath.split("/");
-  const filename = parts[parts.length - 1] ?? "";
-  return filename.replace(/\.md$/, "");
-}
-function extractAliases2(properties) {
-  const raw = properties.aliases ?? properties.alias;
-  if (!raw) return [];
-  if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
-  if (typeof raw === "string")
-    return raw.split(",").map((s) => s.trim()).filter(Boolean);
-  return [];
-}
-var NodeVaultFS = class {
-  constructor(rootPath, pathConfig) {
-    this.rootPath = rootPath;
-    this.includePatterns = pathConfig?.include ?? [];
-    const configExclude = pathConfig?.exclude ?? [];
-    const ignorePatterns = this.loadImNobsidianIgnore();
-    this.excludePatterns = [...configExclude, ...ignorePatterns];
-  }
-  rootPath;
-  includePatterns;
-  excludePatterns;
-  loadImNobsidianIgnore() {
-    try {
-      const ignorePath = join(this.rootPath, IGNORE_FILE);
-      const content = readFileSync(ignorePath, "utf-8");
-      return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
-    } catch {
-      return [];
-    }
-  }
-  async readFile(path) {
-    const fullPath = join(this.rootPath, path);
-    return readFile(fullPath, "utf-8");
-  }
-  async readBinary(path) {
-    const fullPath = join(this.rootPath, path);
-    return readFile(fullPath);
-  }
-  async writeFile(path, content) {
-    const fullPath = join(this.rootPath, path);
-    await mkdir(dirname(fullPath), { recursive: true });
-    await writeFile(fullPath, content, "utf-8");
-  }
-  async writeBinary(path, data) {
-    const fullPath = join(this.rootPath, path);
-    await mkdir(dirname(fullPath), { recursive: true });
-    await writeFile(fullPath, data);
-  }
-  async deleteFile(path) {
-    const fullPath = join(this.rootPath, path);
-    await unlink(fullPath);
-  }
-  async moveFile(from, to) {
-    const fromPath = join(this.rootPath, from);
-    const toPath = join(this.rootPath, to);
-    await mkdir(dirname(toPath), { recursive: true });
-    await rename(fromPath, toPath);
-  }
-  async exists(path) {
-    try {
-      await stat(join(this.rootPath, path));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async ensureFolder(path) {
-    await mkdir(join(this.rootPath, path), { recursive: true });
-  }
-  async listMarkdownFiles() {
-    const files = [];
-    await this.walkDir(this.rootPath, files);
-    return files;
-  }
-  async listMarkdownFileStats() {
-    const stats = [];
-    await this.walkDirStats(this.rootPath, stats);
-    return stats;
-  }
-  async getFileStat(path) {
-    try {
-      const fullPath = join(this.rootPath, path);
-      const fileStat = await stat(fullPath);
-      return { path, mtime: fileStat.mtime.toISOString(), size: fileStat.size };
-    } catch {
-      return null;
-    }
-  }
-  async listNonMarkdownFiles() {
-    const files = [];
-    await this.walkDirNonMd(this.rootPath, files);
-    return files;
-  }
-  matchesPattern(relativePath, pattern) {
-    if (pattern === "**/*" || pattern === "**") return true;
-    if (pattern.endsWith("/**")) {
-      const dir = pattern.slice(0, -3);
-      return relativePath.startsWith(dir + "/") || relativePath === dir;
-    } else if (pattern.startsWith("*.")) {
-      const ext = pattern.slice(1);
-      return relativePath.endsWith(ext);
-    } else if (pattern.includes("*")) {
-      const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-      return new RegExp("^" + regexStr + "$").test(relativePath);
-    } else {
-      return relativePath === pattern || relativePath.startsWith(pattern + "/");
-    }
-  }
-  isExcluded(relativePath) {
-    if (this.includePatterns.length > 0) {
-      const included = this.includePatterns.some((p) => this.matchesPattern(relativePath, p));
-      if (!included) return true;
-    }
-    return this.excludePatterns.some((p) => this.matchesPattern(relativePath, p));
-  }
-  async walkDirNonMd(dir, result) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.name.startsWith(".")) continue;
-      const relativePath = relative(this.rootPath, fullPath);
-      if (this.isExcluded(relativePath)) continue;
-      if (entry.isDirectory()) {
-        await this.walkDirNonMd(fullPath, result);
-      } else if (entry.isFile() && !entry.name.endsWith(".md") && !entry.name.endsWith(".base")) {
-        const fileStat = await stat(fullPath);
-        result.push({
-          path: relativePath,
-          size: fileStat.size,
-          mtime: fileStat.mtime.toISOString()
-        });
+  /**
+   * I12 — 중단된 push create 작업 재개.
+   *
+   * pending_operations 에 미완료(create·push) 항목이 있으면:
+   *  - state 에 notion_page_id 가 이미 있으면 → 생성·매핑까지는 끝났고 markCompleted 직전에
+   *    중단된 것 → 완료 처리(잔여 본문/이미지는 다음 변경감지가 pushUpdate 로 마무리).
+   *  - notion_page_id 가 비어 있으면(Window A: 생성 적용됐으나 매핑 기록 전 중단) → 부모에서
+   *    제목으로 child_page 를 검색해 고아 페이지를 입양(중복 생성 차단). 없으면 자리표시
+   *    레코드를 제거(FK CASCADE 로 op 도 삭제)해 다음 push 가 새로 생성하게 한다.
+   *
+   * 한계(문서화): Notion 은 idempotency key 가 없어 "생성 요청 적용 직후 같은 호출 내 재시도"
+   * 로 인한 중복은 완전히 차단하지 못한다. 429 는 적용 전 거절이라 안전하고, 프로세스 재시작
+   * 후 재개는 본 검색-입양으로 중복을 막는다. DB 모드(부모가 database)는 child_page 검색이
+   * 불가하므로 자리표시 제거 후 재생성으로 폴백한다.
+   */
+  async recoverInterruptedPushOps() {
+    const ops = this.stateDb.getIncompletePendingOperations();
+    if (ops.length === 0) return;
+    for (const op of ops) {
+      if (op.direction !== "push" || op.operation !== "create") {
+        this.stateDb.markPendingFailed(op.id, "unsupported resume op");
+        continue;
       }
-    }
-  }
-  async walkDirStats(dir, result) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.name.startsWith(".")) continue;
-      const relativePath = relative(this.rootPath, fullPath);
-      if (this.isExcluded(relativePath)) continue;
-      if (entry.isDirectory()) {
-        await this.walkDirStats(fullPath, result);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const fileStat = await stat(fullPath);
-        result.push({
-          path: relativePath,
-          mtime: fileStat.mtime.toISOString(),
-          size: fileStat.size
-        });
+      let payload = {};
+      try {
+        payload = JSON.parse(op.payload ?? "{}");
+      } catch {
+        this.stateDb.markPendingFailed(op.id, "invalid payload json");
+        continue;
       }
-    }
-  }
-  async walkDir(dir, result) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.name.startsWith(".")) continue;
-      const relativePath = relative(this.rootPath, fullPath);
-      if (this.isExcluded(relativePath)) continue;
-      if (entry.isDirectory()) {
-        await this.walkDir(fullPath, result);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const content = await readFile(fullPath, "utf-8");
-        const fileStat = await stat(fullPath);
-        result.push({
-          path: relativePath,
-          content,
-          mtime: fileStat.mtime.toISOString()
+      const path = payload.path;
+      if (!path) {
+        this.stateDb.markPendingFailed(op.id, "missing payload.path");
+        continue;
+      }
+      const state = this.stateDb.getByPath(path);
+      if (state?.notionPageId) {
+        this.stateDb.markPendingCompleted(op.id);
+        continue;
+      }
+      const parentId = payload.parentId ?? state?.notionParentId ?? void 0;
+      const title = payload.title;
+      const adopted = parentId && title ? await this.findChildPageByTitle(parentId, title) : null;
+      if (adopted) {
+        this.stateDb.upsert({
+          obsidianPath: path,
+          notionPageId: adopted,
+          notionParentId: parentId ?? null,
+          contentHash: "",
+          notionLastEdited: state?.notionLastEdited ?? null,
+          localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+          syncDirection: state?.syncDirection ?? "both",
+          fileType: state?.fileType ?? (this.isFolderNote(path) ? "folder-note" : "file"),
+          status: "pending",
+          baseSnapshot: null,
+          localMtime: null,
+          localFileSize: null
         });
+        this.stateDb.markPendingCompleted(op.id);
+        getLogger().info(`[Im-Nobsidian] \uC911\uB2E8\uB41C create \uC7AC\uAC1C \u2014 \uACE0\uC544 \uD398\uC774\uC9C0 \uC785\uC591: ${path}`);
+      } else if (state) {
+        this.stateDb.delete(state.id);
+        getLogger().info(`[Im-Nobsidian] \uC911\uB2E8\uB41C create \uC7AC\uAC1C \u2014 \uBBF8\uC0DD\uC131 \uD655\uC778, \uC790\uB9AC\uD45C\uC2DC \uC81C\uAC70: ${path}`);
+      } else {
+        this.stateDb.markPendingCompleted(op.id);
       }
     }
   }
-};
-
-// src/converter/pre-processors/inline-db.ts
-var INLINE_DB_START = new RegExp(`%% ${MARKER_BRAND_RE}:inline-db:([^\\s]+) %%`, "g");
-var INLINE_DB_END = new RegExp(`%% ${MARKER_BRAND_RE}:end %%`, "g");
-var InlineDBParser = class {
-  name = "InlineDBParser";
-  order = 40;
-  process(input) {
-    const inlineDbBlocks = [];
-    const content = input.content;
-    const startMatches = [...content.matchAll(INLINE_DB_START)];
-    for (const match of startMatches) {
-      const startIdx = match.index;
-      const params = parseParams(match[1]);
-      const afterStart = content.indexOf("\n", startIdx) + 1;
-      const endMatch = INLINE_DB_END.exec(content.slice(afterStart));
-      if (endMatch) {
-        const tableContent = content.slice(afterStart, afterStart + endMatch.index);
-        inlineDbBlocks.push({
-          id: params["id"] ?? "",
-          title: params["title"] ?? "",
-          tableMarkdown: tableContent.trim(),
-          startIdx,
-          endIdx: afterStart + endMatch.index + endMatch[0].length
-        });
+  /** 부모 페이지의 직속 자식 중 제목이 일치하는(보관/휴지통 제외) child_page id 를 찾는다. */
+  async findChildPageByTitle(parentId, title) {
+    try {
+      const children = await this.notionClient.fetchAllChildren(parentId);
+      for (const b of children) {
+        if (b.type !== "child_page") continue;
+        const childTitle = b.child_page?.title;
+        if (childTitle !== title) continue;
+        try {
+          const page = await this.notionClient.getPage(b.id);
+          const inTrash = page.in_trash === true;
+          if (inTrash || page.archived) continue;
+        } catch {
+          continue;
+        }
+        return b.id;
       }
-      INLINE_DB_END.lastIndex = 0;
+    } catch (error) {
+      getLogger().warn(
+        `[Im-Nobsidian] \uACE0\uC544 \uD398\uC774\uC9C0 \uAC80\uC0C9 \uC2E4\uD328 (${parentId}): ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-    return {
-      content,
-      metadata: {
-        ...input.metadata,
-        inlineDbBlocks
-      }
-    };
+    return null;
   }
-};
-function parseParams(paramString) {
-  const params = {};
-  for (const pair of paramString.split("&")) {
-    const [key, value] = pair.split("=");
-    if (key && value) {
-      params[key] = decodeURIComponent(value);
+  async resolveUniqueFilePath(basePath) {
+    if (!await this.vaultFs.exists(basePath)) return basePath;
+    const dir = basePath.lastIndexOf("/") >= 0 ? basePath.slice(0, basePath.lastIndexOf("/")) : "";
+    const ext = ".md";
+    const name = basePath.slice(dir ? dir.length + 1 : 0, -ext.length);
+    for (let i = 1; i <= 99; i++) {
+      const candidate = dir ? `${dir}/${name} (${i})${ext}` : `${name} (${i})${ext}`;
+      if (!await this.vaultFs.exists(candidate)) return candidate;
     }
+    return basePath;
   }
-  return params;
+};
+function extractTitle(filePath) {
+  const parts = filePath.split("/");
+  const filename = parts[parts.length - 1] ?? "";
+  return filename.replace(/\.md$/, "");
 }
-
-// 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 group = [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);
-      group.push(next);
-      i++;
-    }
-    const baseRegion = baseLines.slice(regionStart, regionEnd);
-    const localRegion = applyHunks(baseLines, group, 0, regionStart, regionEnd);
-    const remoteRegion = applyHunks(baseLines, group, 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");
+function extractAliases2(properties) {
+  const raw = properties.aliases ?? properties.alias;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
+  if (typeof raw === "string")
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return [];
+}
+var NodeVaultFS = class {
+  constructor(rootPath, pathConfig) {
+    this.rootPath = rootPath;
+    this.includePatterns = pathConfig?.include ?? [];
+    const configExclude = pathConfig?.exclude ?? [];
+    const ignorePatterns = this.loadImNobsidianIgnore();
+    this.excludePatterns = [...configExclude, ...ignorePatterns];
+  }
+  rootPath;
+  includePatterns;
+  excludePatterns;
+  loadImNobsidianIgnore() {
+    try {
+      const ignorePath = join(this.rootPath, IGNORE_FILE);
+      const content = readFileSync(ignorePath, "utf-8");
+      return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    } catch {
+      return [];
     }
-    cursor = regionEnd;
   }
-  if (cursor < baseLines.length) {
-    merged.push(...baseLines.slice(cursor));
+  async readFile(path) {
+    const fullPath = join(this.rootPath, path);
+    return readFile(fullPath, "utf-8");
   }
-  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;
+  async readBinary(path) {
+    const fullPath = join(this.rootPath, path);
+    return readFile(fullPath);
   }
-  emitGap(base.length, modified.length);
-  return hunks;
-}
-function applyHunks(baseLines, group, side, regionStart, regionEnd) {
-  const out = [];
-  let b = regionStart;
-  for (const hunk of group) {
-    if (hunk.side !== side) continue;
-    if (hunk.baseStart > b) out.push(...baseLines.slice(b, hunk.baseStart));
-    out.push(...hunk.content);
-    b = hunk.baseEnd;
+  async writeFile(path, content) {
+    const fullPath = join(this.rootPath, path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
   }
-  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]);
+  async writeBinary(path, data) {
+    const fullPath = join(this.rootPath, path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, data);
+  }
+  async deleteFile(path) {
+    const fullPath = join(this.rootPath, path);
+    await unlink(fullPath);
+  }
+  async moveFile(from, to) {
+    const fromPath = join(this.rootPath, from);
+    const toPath = join(this.rootPath, to);
+    await mkdir(dirname(toPath), { recursive: true });
+    await rename(fromPath, toPath);
+  }
+  async exists(path) {
+    try {
+      await stat(join(this.rootPath, path));
+      return true;
+    } catch {
+      return false;
     }
   }
-  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++;
+  async ensureFolder(path) {
+    await mkdir(join(this.rootPath, path), { recursive: true });
+  }
+  async listMarkdownFiles() {
+    const files = [];
+    await this.walkDir(this.rootPath, files);
+    return files;
+  }
+  async listMarkdownFileStats() {
+    const stats = [];
+    await this.walkDirStats(this.rootPath, stats);
+    return stats;
+  }
+  async getFileStat(path) {
+    try {
+      const fullPath = join(this.rootPath, path);
+      const fileStat = await stat(fullPath);
+      return { path, mtime: fileStat.mtime.toISOString(), size: fileStat.size };
+    } catch {
+      return null;
     }
   }
-  return matches;
-}
-function arraysEqual(a, b) {
-  if (a.length !== b.length) return false;
-  return a.every((val, idx) => val === b[idx]);
-}
-
-// src/conflict/resolver.ts
-var ConflictResolver = class {
-  constructor(stateDb, vaultFs) {
-    this.stateDb = stateDb;
-    this.vaultFs = vaultFs;
+  async listNonMarkdownFiles() {
+    const files = [];
+    await this.walkDirNonMd(this.rootPath, files);
+    return files;
   }
-  stateDb;
-  vaultFs;
-  async resolve(conflict, choice) {
-    switch (choice) {
-      case "local":
-        return this.resolveLocal(conflict);
-      case "remote":
-        return this.resolveRemote(conflict);
-      case "merge":
-        return this.resolveMerge(conflict);
-      case "duplicate":
-        return this.resolveDuplicate(conflict);
+  matchesPattern(relativePath, pattern) {
+    if (pattern === "**/*" || pattern === "**") return true;
+    if (pattern.endsWith("/**")) {
+      const dir = pattern.slice(0, -3);
+      return relativePath.startsWith(dir + "/") || relativePath === dir;
+    } else if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      return relativePath.endsWith(ext);
+    } else if (pattern.includes("*")) {
+      const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+      return new RegExp("^" + regexStr + "$").test(relativePath);
+    } else {
+      return relativePath === pattern || relativePath.startsWith(pattern + "/");
     }
   }
-  async resolveByStrategy(conflict, strategy) {
-    switch (strategy) {
-      case "local-first":
-        return this.resolve(conflict, "local");
-      case "remote-first":
-        return this.resolve(conflict, "remote");
-      case "duplicate":
-        return this.resolve(conflict, "duplicate");
-      case "manual":
-        return this.resolve(conflict, "merge");
+  isExcluded(relativePath) {
+    if (this.includePatterns.length > 0) {
+      const included = this.includePatterns.some((p) => this.matchesPattern(relativePath, p));
+      if (!included) return true;
     }
+    return this.excludePatterns.some((p) => this.matchesPattern(relativePath, p));
   }
-  async resolveAll(conflicts, strategy) {
-    const results = [];
-    for (const conflict of conflicts) {
-      const result = await this.resolveByStrategy(conflict, strategy);
-      results.push(result);
+  async walkDirNonMd(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      const relativePath = relative(this.rootPath, fullPath);
+      if (this.isExcluded(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await this.walkDirNonMd(fullPath, result);
+      } else if (entry.isFile() && !entry.name.endsWith(".md") && !entry.name.endsWith(".base")) {
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          size: fileStat.size,
+          mtime: fileStat.mtime.toISOString()
+        });
+      }
     }
-    return results;
   }
-  async resolveLocal(conflict) {
-    const hash = computeHash(conflict.localContent);
-    this.stateDb.updateHash(
-      conflict.syncRecord.id,
-      hash,
-      Buffer.from(conflict.localContent, "utf-8")
-    );
-    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
-    return { path: conflict.syncRecord.obsidianPath, choice: "local", success: true };
+  async walkDirStats(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      const relativePath = relative(this.rootPath, fullPath);
+      if (this.isExcluded(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await this.walkDirStats(fullPath, result);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          mtime: fileStat.mtime.toISOString(),
+          size: fileStat.size
+        });
+      }
+    }
   }
-  async resolveRemote(conflict) {
-    await this.vaultFs.writeFile(conflict.syncRecord.obsidianPath, conflict.remoteContent);
-    const hash = computeHash(conflict.remoteContent);
-    this.stateDb.updateHash(
-      conflict.syncRecord.id,
-      hash,
-      Buffer.from(conflict.remoteContent, "utf-8")
-    );
-    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
-    return { path: conflict.syncRecord.obsidianPath, choice: "remote", success: true };
+  async walkDir(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      const relativePath = relative(this.rootPath, fullPath);
+      if (this.isExcluded(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await this.walkDir(fullPath, result);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const content = await readFile(fullPath, "utf-8");
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          content,
+          mtime: fileStat.mtime.toISOString()
+        });
+      }
+    }
   }
-  async resolveMerge(conflict) {
-    const base = conflict.baseContent ?? "";
-    const mergeResult = threeWayMerge(base, conflict.localContent, conflict.remoteContent);
-    await this.vaultFs.writeFile(conflict.syncRecord.obsidianPath, mergeResult.merged);
-    const hash = computeHash(mergeResult.merged);
-    this.stateDb.updateHash(conflict.syncRecord.id, hash, Buffer.from(mergeResult.merged, "utf-8"));
-    if (mergeResult.success) {
-      this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+};
+
+// src/converter/pre-processors/inline-db.ts
+var INLINE_DB_START = new RegExp(`%% ${MARKER_BRAND_RE}:inline-db:([^\\s]+) %%`, "g");
+var INLINE_DB_END = new RegExp(`%% ${MARKER_BRAND_RE}:end %%`, "g");
+var InlineDBParser = class {
+  name = "InlineDBParser";
+  order = 40;
+  process(input) {
+    const inlineDbBlocks = [];
+    const content = input.content;
+    const startMatches = [...content.matchAll(INLINE_DB_START)];
+    for (const match of startMatches) {
+      const startIdx = match.index;
+      const params = parseParams(match[1]);
+      const afterStart = content.indexOf("\n", startIdx) + 1;
+      const endMatch = INLINE_DB_END.exec(content.slice(afterStart));
+      if (endMatch) {
+        const tableContent = content.slice(afterStart, afterStart + endMatch.index);
+        inlineDbBlocks.push({
+          id: params["id"] ?? "",
+          title: params["title"] ?? "",
+          tableMarkdown: tableContent.trim(),
+          startIdx,
+          endIdx: afterStart + endMatch.index + endMatch[0].length
+        });
+      }
+      INLINE_DB_END.lastIndex = 0;
     }
     return {
-      path: conflict.syncRecord.obsidianPath,
-      choice: "merge",
-      success: mergeResult.success,
-      mergeHadConflicts: !mergeResult.success
+      content,
+      metadata: {
+        ...input.metadata,
+        inlineDbBlocks
+      }
     };
   }
-  async resolveDuplicate(conflict) {
-    const originalPath = conflict.syncRecord.obsidianPath;
-    const ext = originalPath.endsWith(".md") ? ".md" : "";
-    const baseName = originalPath.replace(/\.md$/, "");
-    const conflictPath = `${baseName}.conflict${ext}`;
-    await this.vaultFs.writeFile(conflictPath, conflict.remoteContent);
-    const localHash = computeHash(conflict.localContent);
-    this.stateDb.updateHash(
-      conflict.syncRecord.id,
-      localHash,
-      Buffer.from(conflict.localContent, "utf-8")
-    );
-    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
-    return { path: originalPath, choice: "duplicate", success: true };
-  }
-  generateDiff(conflict) {
-    const localLines = conflict.localContent.split("\n");
-    const remoteLines = conflict.remoteContent.split("\n");
-    const lines = [];
-    lines.push(`--- local: ${conflict.syncRecord.obsidianPath}`);
-    lines.push(`+++ remote: Notion (${conflict.remoteChange.pageId})`);
-    lines.push("");
-    const maxLen = Math.max(localLines.length, remoteLines.length);
-    for (let i = 0; i < maxLen; i++) {
-      const localLine = localLines[i];
-      const remoteLine = remoteLines[i];
-      if (localLine === remoteLine) {
-        lines.push(`  ${localLine ?? ""}`);
-      } else {
-        if (localLine !== void 0) lines.push(`- ${localLine}`);
-        if (remoteLine !== void 0) lines.push(`+ ${remoteLine}`);
-      }
+};
+function parseParams(paramString) {
+  const params = {};
+  for (const pair of paramString.split("&")) {
+    const [key, value] = pair.split("=");
+    if (key && value) {
+      params[key] = decodeURIComponent(value);
     }
-    return lines.join("\n");
   }
-};
+  return params;
+}
 
 // src/structure/tree-mapper.ts
 var TreeMapper = class {
@@ -7479,8 +8546,7 @@ var ViewDataProvider = class {
   }
   async collectEntries(folderPath) {
     const allFiles = await this.vaultFs.listMarkdownFiles();
-    const prefix = folderPath.endsWith("/") ? folderPath : folderPath + "/";
-    const dbFiles = allFiles.filter((f) => f.path.startsWith(prefix));
+    const dbFiles = selectDbRowFiles(allFiles, folderPath);
     const entries = [];
     for (const file of dbFiles) {
       try {
@@ -7542,11 +8608,11 @@ var ViewDataProvider = class {
 };
 function parseEntry(path, content) {
   try {
-    const parsed = matter7(content);
+    const parsed = matter(content);
     const fm = parsed.data;
-    const title = fm.title ?? extractTitleFromPath2(path);
-    const icon = fm.icon;
-    const cover = fm.cover;
+    const title = coerceString(fm.title) ?? extractTitleFromPath2(path);
+    const icon = coerceString(fm.icon);
+    const cover = coerceCover(fm.cover);
     const properties = {};
     for (const [key, value] of Object.entries(fm)) {
       if (key === "title" || key === "icon" || key === "cover") continue;
@@ -7557,6 +8623,36 @@ function parseEntry(path, content) {
     return null;
   }
 }
+function coerceCover(raw) {
+  const firstUrl = (v) => {
+    if (typeof v === "string") return v.trim() || void 0;
+    if (v && typeof v === "object") {
+      const o = v;
+      const url = o.url ?? o.external?.url;
+      if (typeof url === "string") return url.trim() || void 0;
+    }
+    return void 0;
+  };
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      const url = firstUrl(item);
+      if (url) return url;
+    }
+    return void 0;
+  }
+  return firstUrl(raw);
+}
+function coerceString(raw) {
+  if (typeof raw === "string") return raw.trim() || void 0;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      const s = coerceString(item);
+      if (s) return s;
+    }
+  }
+  return void 0;
+}
 function normalizePropertyValue(value) {
   if (value === null || value === void 0) return null;
   if (typeof value === "string") return value;
@@ -7600,16 +8696,16 @@ var EntryEditor = class {
   vaultFs;
   async updateProperty(entryPath, propertyName, newValue) {
     const content = await this.vaultFs.readFile(entryPath);
-    const parsed = matter7(content);
+    const parsed = matter(content);
     parsed.data[propertyName] = newValue;
-    const updated = matter7.stringify(parsed.content, parsed.data);
+    const updated = stringifyFrontmatter(parsed.content, parsed.data);
     await this.vaultFs.writeFile(entryPath, updated);
   }
   async createEntry(folderPath, title, properties) {
     const safeName = title.replace(/[\\/:*?"<>|]/g, "_").trim() || "Untitled";
     const filePath = `${folderPath}/${safeName}.md`;
     const frontmatter = { title, ...properties };
-    const content = matter7.stringify("", frontmatter);
+    const content = stringifyFrontmatter("", frontmatter);
     await this.vaultFs.ensureFolder(folderPath);
     await this.vaultFs.writeFile(filePath, content);
     return filePath;
@@ -7666,6 +8762,77 @@ ${lines.join("\n")}
 }`;
 }
 
-export { BaseFileGenerator, BlockConverter, CONFIG_FILE, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DB_VIEWS_FILE, DB_VIEWS_PATH, DEFAULT_CONFIG, DatabaseSyncer, EmbedResolver, EntryEditor, FileHandler, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, GITIGNORE_ENTRY, HtmlAnnotationStripper, IGNORE_FILE, INTERNAL_DIR, INTERNAL_DIR_GLOB, ImageHandler, InlineDBParser, LocalImageRestorer, MARKER_BRAND, MathNormalizer, MentionToWikilink, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, STATE_DB_FILE, STATE_DB_PATH, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, ViewDataProvider, WatchSyncService, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, isInternalPath, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, sortEntries, threeWayMerge };
+// src/audit/fidelity.ts
+var NOTION_ID_RE = /[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}/gi;
+var MD_LINK_RE = new RegExp(
+  `\\[[^\\]]*\\]\\((https?://[^)\\s]*notion\\.so/[^)\\s]*)\\)(\\s*%%\\s*${MARKER_BRAND}\\b)?`,
+  "gi"
+);
+var MENTION_PAGE_RE = /<mention-page\b[\s\S]*?(?:\/>|>[\s\S]*?<\/mention-page>)/gi;
+function lastNotionId(text) {
+  const matches = text.match(NOTION_ID_RE);
+  if (!matches || matches.length === 0) return null;
+  return compactNotionId(matches[matches.length - 1]);
+}
+function classifyBodyFidelity(body, ctx) {
+  const result = {
+    preservedMarkers: 0,
+    externalLinks: 0,
+    selfReferences: 0,
+    defects: []
+  };
+  const own = ctx.ownPageId ? compactNotionId(ctx.ownPageId) : null;
+  const titleOf = (id) => ctx.titleById?.get(id) ?? null;
+  const classifyId = (id, form, raw) => {
+    if (id === null) {
+      result.externalLinks += 1;
+      return;
+    }
+    if (own !== null && id === own) {
+      result.selfReferences += 1;
+      return;
+    }
+    if (ctx.knownPageIds.has(id)) {
+      result.defects.push({ form, targetPageId: id, targetTitle: titleOf(id), raw: raw.trim() });
+      return;
+    }
+    result.externalLinks += 1;
+  };
+  for (const m of body.matchAll(MD_LINK_RE)) {
+    const url = m[1] ?? "";
+    const hasMarker = Boolean(m[2]);
+    if (hasMarker) {
+      result.preservedMarkers += 1;
+      continue;
+    }
+    classifyId(lastNotionId(url), "md-link", m[0]);
+  }
+  for (const m of body.matchAll(MENTION_PAGE_RE)) {
+    classifyId(lastNotionId(m[0]), "mention-page", m[0]);
+  }
+  return result;
+}
+function summarizeFidelity(perFile) {
+  const summary = {
+    files: perFile.length,
+    preservedMarkers: 0,
+    externalLinks: 0,
+    selfReferences: 0,
+    defects: 0,
+    defectsByFile: {}
+  };
+  for (const { path, classification } of perFile) {
+    summary.preservedMarkers += classification.preservedMarkers;
+    summary.externalLinks += classification.externalLinks;
+    summary.selfReferences += classification.selfReferences;
+    summary.defects += classification.defects.length;
+    if (classification.defects.length > 0) {
+      summary.defectsByFile[path] = classification.defects;
+    }
+  }
+  return summary;
+}
+
+export { BaseFileGenerator, BlockConverter, CONFIG_FILE, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DB_VIEWS_FILE, DB_VIEWS_PATH, DEFAULT_CONFIG, DatabaseSyncer, EmbedResolver, EntryEditor, FileHandler, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, GITIGNORE_ENTRY, IGNORE_FILE, INTERNAL_DIR, INTERNAL_DIR_GLOB, ImageHandler, InlineAnnotationPreserver, InlineDBParser, LocalImageRestorer, MARKER_BRAND, MathNormalizer, MentionToWikilink, NOTION_TO_BASES_VIEW, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, STATE_DB_FILE, STATE_DB_PATH, SidecarGenerator, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, ViewDataProvider, WatchSyncService, WikilinkResolver, basesViewTypeOf, classifyBodyFidelity, compactNotionId, computeBufferHash, computeHash, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, isInternalPath, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, sortEntries, summarizeFidelity, threeWayMerge };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map