rootr-cli 0.20.0 → 0.22.0

package/README.ko.md

@@ -542,6 +542,26 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
    "steps": [{ "kind": "update_rows", "target": "selected", "values": { "오늘 할 일": true } }] }]
 ```
 
+**같은 행이 이미 있으면 잇기.** 마스터 표에 등록하는 규칙(투입확정 → 사업장 마스터)은 기존 고객이면
+이미 행이 있습니다. `add_row` 에 `match` 를 주면 만들기 전에 찾습니다 — 같은 이름이 **하나**면 새로
+만들지 않고 그 행에 잇고, **없으면** 만들고, **여럿**이면 아무것도 안 만들고 요청 행에 "후보 여러 곳"
+댓글을 남깁니다. 먼저 공백만 무시하고 똑같은 이름을 찾으므로 지점명까지 같으면 그 지점에 잇습니다.
+관계 칸은 `"{배정 매니저}"` 처럼 칸 하나만 적으면(받는 칸이 같은 표를 가리킬 때) 행 자체가 옮겨집니다.
+
+```json
+[{ "label": "투입확정 시 사업장 등록",
+   "when": [{ "property": "상태", "op": "changed_to", "value": "투입확정" },
+            { "property": "사업장", "op": "is_empty" }],
+   "steps": [{ "kind": "add_row", "database": "/사업장 마스터",
+     "values": { "업체명": "{요청 건}", "담당 매니저": "{배정 매니저}" },
+     "link": { "relation": "채용 요청", "from": "selected" },
+     "match": { "key": "{요청 건}", "on": "업체명",
+                "normalize": ["spaces", "parens", "suffix:의원", "trailingDigits"], "fill": "empty" } }] }]
+```
+
+`rootr db automations <표>` 는 규칙마다 "같은 행이 있으면 잇기"와 마지막 사유(후보 여러 곳·조건에 걸려
+비운 칸)를 함께 보여 줍니다.
+
 스캐폴드로 표를 지을 때도 `database.buttons` · `database.automations` 에 같은 모양을 넣으면
 **표와 함께** 달립니다.
 
@@ -789,9 +809,24 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
 `rootr_append_page_blocks`, `rootr_update_page`, `rootr_update_page_block`,
 `rootr_read_page_live_data`)로 저작합니다.
 
-HTML을 짜는 것이 아니라 **정해진 블록 14종을 골라 쌓습니다** — `hero` `text`
+HTML을 짜는 것이 아니라 **정해진 블록 15종을 골라 쌓습니다** — `hero` `text`
 `features` `gallery` `pricing` `testimonials` `faq` `timeline` `cta` `footer` +
-표에서 값을 끌어오는 `liveStats` `liveTable` `liveChart` + 신청을 받는 `form` + 자유 블록 `custom`.
+표에서 값을 끌어오는 `liveStats` `liveTable` `liveChart` + 신청을 받는 `form` +
+방문자가 시간을 잡는 `booking`(`{bookingNodeId, headline?, type?}` — 예약을 켜고 공개한 표의 노드 id) +
+자유 블록 `custom`.
+
+**랜딩 페이지**용으로 두 블록은 가운데 본문 기둥을 벗어나 화면 폭 전체를 쓸 수 있습니다.
+`hero`에 `size: "screen"`을 주면 화면 한 장을 채우는 큰 제목(화면 폭 전체·화면 높이·큰 글자)이 되고,
+`custom`에 `bleed: true`를 주면 좌우·위아래 여백 없이 화면 폭 전체를 써서 연달아 놓은 블록이
+틈 없는 색 띠로 이어집니다. `custom`에 `minHeight: "screen"`을 주면 어느 기기에서나 틀 높이가
+화면 한 장이 되고(숫자 `height`를 같이 주면 그 값이 하한), `bleed: true`와 함께 쓰면 화면을 꽉 채우는
+섹션이 됩니다. 맨 위 이름 줄은 `config.navEnabled: false`로 끕니다.
+
+**스크롤 등장 효과** — 어느 블록이나 `reveal: "fade"`(서서히) 또는 `"fade-up"`(아래에서 위로)을 주면
+(기본 `"none"`), 발행한 페이지에서 그 블록이 화면에 들어올 때 한 번 나타납니다(큰 제목은 제목 → 부제 →
+버튼 순서로). `custom`에 `reveal`을 주면 **틀 안의 CSS 애니메이션도 그 순간에 시작**합니다 — 틀을 블록이
+화면에 들어올 때 만들기 때문입니다. `@keyframes`는 `@media (prefers-reduced-motion: no-preference)` 안에
+적으세요. 움직임 줄이기를 켠 방문자에게는 효과 없이 바로 보입니다.
 
 `custom`은 **격리된 방**입니다: HTML/CSS를 마음대로 쓰되 `sandbox` 아이프레임 안에서만
 그려집니다(스크립트 없음·같은 출처 아님·바깥 통신 차단). 그래서 대담한 CSS도 바깥 화면을

package/README.md

@@ -11,7 +11,7 @@ citations back to the exact paragraph.
 *(한국어 문서: [README.ko.md](https://github.com/gwmage/rootr-cli/blob/main/README.ko.md))*
 
 - `rootr` CLI — documents, databases, forms, signed documents, publishing, permissions, memory
-- `rootr mcp` — stdio MCP server, **186 tools** (see [MCP tools](#mcp-tools))
+- `rootr mcp` — stdio MCP server, **192 tools** (see [MCP tools](#mcp-tools))
 
 Plain Node.js ESM, no build step. Node 18+ (uses the built-in `fetch`).
 
@@ -197,7 +197,13 @@ rootr db rows-new /projects/tasks --file rows.json    # many at once — all or
 rootr db rows-set /projects/tasks --ids r1,r2 --values '{"Status":"Done"}'
 rootr db rows-each /projects/tasks --json '[{"rowId":"r1","values":{"Score":3}}]'
 rootr db rows-rm  /projects/tasks --ids r1,r2 --yes
+rootr db duplicates /hr/applicants --row r9            # same person (dedupe column) + latest linked history
+rootr db merge /hr/applicants r9 --into r1             # merge a duplicate into the existing row
+rootr db keep-duplicate /hr/applicants r9 --from r1    # keep as a new row, link both
+rootr db history /hr/applicants --row r1               # who changed what, when, how
+rootr db restore /hr/applicants --at 2026-10-15T09:00:00+09:00 --yes  # rows + columns/views back to that time
 rootr db view /projects/tasks Calendar --scale month  # views: table, board, calendar, timeline
+rootr db view /hr/applicants Board --cards "Interview date,Phone"  # fields shown on board cards
 rootr db lock /projects/tasks --schema managers --rows own --locked "Approved,Score"
 rootr db notify  /projects/tasks --file rules.json    # notification rules
 rootr db buttons /projects/tasks --file buttons.json  # buttons that do work when pressed
@@ -215,6 +221,13 @@ add `on: ["schedule"]` with `schedule: { at: "09:00" }` for a daily job (Korean
 Prefer `changed_to` over `is`: `is` stays true on every later edit, so a rule that creates
 rows would create them again each time the row is saved.
 
+A rule that registers into a master table should not duplicate customers who are already
+there: give the `add_row` a `match: { key: "{Request}", on: "Company", normalize: ["spaces",
+"parens", "suffix:Clinic", "trailingDigits"], fill: "empty" }`. One matching row → linked
+instead of created; none → created; several → nothing is created and the request row gets a
+"several candidates" comment. A value that is exactly `"{Assigned manager}"` going into a
+relation to the same table copies the linked rows, not their titles.
+
 `--upsert-key` is what makes a migration or a sync safe to retry — without it, retrying
 after a partial failure silently double-loads (a real incident: 903 duplicate rows).
 
@@ -394,12 +407,12 @@ is refused and says when the grace was used.
 
 ## MCP tools
 
-`rootr mcp` speaks MCP over stdio. 186 tools:
+`rootr mcp` speaks MCP over stdio. 192 tools:
 
 | Group | Count | Tools |
 |---|---|---|
 | Documents | 22 | list, read, write, append, edit, search, comment, version history, commits & merges, publish, trash & restore |
-| Databases | 26 | create, columns, views, rows (single & bulk), row pages, permissions, notifications, buttons |
+| Databases | 32 | create, columns, views, rows (single & bulk), row pages, permissions, notifications, buttons, duplicates (find / merge / keep & link), history & point-in-time restore (row / whole table) |
 | CRM | 18 | companies, contacts, deals (incl. pipeline moves), activities, tasks, CSV import |
 | Signed documents & research notes | 14 | create, sign, revise, reject, reopen, approval lines, signing codes, ledger verification, research-note preset |
 | Forms | 10 | create, read, update, responses, share links, collectors |
@@ -451,9 +464,26 @@ signed-document, issue, CRM and LOG tools need `docs:read` / `docs:write`; `root
 ### Pages
 
 A PAGE is **a screen for people outside the workspace** — an event announcement, a product page,
-a sign-up. You do not write HTML: you stack **14 predefined block types** — `hero`, `text`,
+a sign-up. You do not write HTML: you stack **15 predefined block types** — `hero`, `text`,
 `features`, `gallery`, `pricing`, `testimonials`, `faq`, `timeline`, `cta`, `footer`, the
-table-backed `liveStats`, `liveTable`, `liveChart`, the `form` block, and the free-form `custom`.
+table-backed `liveStats`, `liveTable`, `liveChart`, the `form` block, the `booking` block
+(a visitor scheduling calendar: `{bookingNodeId, headline?, type?}` — the node id of a published
+table with visitor booking on) — plus the free-form `custom`.
+
+For a **landing page**, two options let a block use the whole page width instead of the centred
+text column: `hero` with `size: "screen"` is a full-screen hero (edge to edge, one viewport tall,
+large headline), and `custom` with `bleed: true` spans the full width with no gap around it, so
+consecutive bleed blocks read as seamless colour bands. `custom` with `minHeight: "screen"` is one
+viewport tall on every device (a numeric `height` given with it is the floor), so
+`bleed: true` + `minHeight: "screen"` is a section that fills the screen. Pair them with
+`config.navEnabled: false`.
+
+For **scroll-in animation**, any block takes `reveal: "fade"` or `"fade-up"` (default `"none"`): on
+the published page it appears once, when it scrolls into view (a hero staggers title → subtitle →
+button). On a `custom` block `reveal` also **starts the CSS animations inside the frame at that
+moment** — the frame is created only when the block scrolls in — so put your `@keyframes` there and
+wrap them in `@media (prefers-reduced-motion: no-preference)`. Visitors who ask for reduced motion
+see everything at once.
 
 `custom` is an **isolated room**: write any HTML/CSS you like, but it renders inside a `sandbox`
 iframe (no scripts, not same-origin, no outbound calls), so even bold CSS cannot leak onto the

package/bin/rootr.js

@@ -38,13 +38,18 @@ const USAGE_KO = `Rootr CLI v${pkg.version}
   rootr db button-run <path|id> <buttonId> [--rows id,id]     버튼 한 번 누르기 (행 만들기·값 채우기·AI 채우기)
   rootr db automations <path|id> [--file rules.json] [--clear] 자동 규칙 — "값이 이렇게 되면 이 일을 해라"·정해진 시각
   rootr db import-sheets <파일.xlsx> --ws <id> [--dry]         시트 수백 장짜리 엑셀을 표 하나로 접어 가져오기
-  rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름]  뷰 목록·달력 주/달/해 단위
+  rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름] [--cards "칸,칸"]  뷰 목록·달력 주/달/해 단위·보드 카드에 보일 칸
   rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
   rootr db row-body <path|id> <rowId> [--file <f>] 행의 상세 내용(본문 메모) 쓰기 — 없으면 표준입력
   rootr db rows-new <path|id> --json '[{…},…]' | --file <파일>   여러 행 한 번에 넣기 (하나라도 틀리면 전부 취소)
   rootr db rows-set <path|id> --ids <id,id> --values '<json>'  고른 행 전부에 같은 값 (날짜 일괄 변경 등)
   rootr db rows-each <path|id> --json '[{"rowId":…,"values":{…}},…]'  행마다 다른 값으로 한 번에 수정
   rootr db rows-rm <path|id> --ids <id,id> [--yes]  고른 행 한 번에 삭제 — 하나라도 막히면 통째로 거절
+  rootr db duplicates <path|id> (--row <rowId> | --values '<json>') [--json]  같은 사람(중복 감지 칸 값이 같은 행)과 그 이력
+  rootr db merge <path|id> <rowId> --into <기존 rowId>       중복 행을 기존 행에 합치기(빈 칸만 채움, rowId 행은 지움)
+  rootr db keep-duplicate <path|id> <rowId> --from <이전 rowId>  새 행으로 두되 이전 행과 서로 링크
+  rootr db history <path|id> [--row <rowId>] [--limit N] [--json]  행·표 변경 이력(누가·언제·어떻게·전후 값)
+  rootr db restore <path|id> --at <ISO 시각> [--yes]          표 전체(행+칸·보기·버튼·규칙)를 그 시각으로 — --yes 없으면 미리보기만
   rootr db row-page <rowId> [--type RECORDING]     이 행만 원하는 타입으로 상세 붙이기(녹음·스프레드시트·서명문서…)
   rootr db row-page <rowId> --node <path|id>       이미 있는 문서를 이 행에 잇기 (옮기지 않고 가리킴)
   rootr db row-page <rowId> --unlink               연결만 끊기 — 문서는 그대로 남음
@@ -146,6 +151,11 @@ usage:
   rootr db rows-set <path|id> --ids <id,id> --values '<json>'  same value on every chosen row (bulk date changes, …)
   rootr db rows-each <path|id> --json '[{"rowId":…,"values":{…}},…]'  a different value per row, in one call
   rootr db rows-rm <path|id> --ids <id,id> [--yes]  delete chosen rows at once — one blocked row rejects all
+  rootr db duplicates <path|id> (--row <rowId> | --values '<json>') [--json]  rows of the same person (same dedupe value) with history
+  rootr db merge <path|id> <rowId> --into <existing rowId>   merge a duplicate into the existing row (fills blanks, deletes rowId)
+  rootr db keep-duplicate <path|id> <rowId> --from <earlier rowId>  keep as a new row but link both rows
+  rootr db history <path|id> [--row <rowId>] [--limit N] [--json]  change history (who, when, how, before/after)
+  rootr db restore <path|id> --at <ISO time> [--yes]           restore the whole table (rows + columns/views/buttons/rules) — preview without --yes
   rootr db row-page <rowId> [--type RECORDING]     give this row a typed detail page (recording, spreadsheet, signed doc…)
   rootr db row-page <rowId> --node <path|id>       attach an existing document to this row (points at it, does not move it)
   rootr db row-page <rowId> --unlink               unlink only — the document stays
@@ -1361,11 +1371,24 @@ async function cmdDbAutomations(args) {
     if (a.when) console.log(`  ${tr('조건', `if`)}: ${a.when.property} ${a.when.op} ${a.when.value ?? ''}`);
     for (const [i, st] of (a.steps ?? []).entries()) {
       const where = st.database ? ` → ${st.database}` : '';
-      console.log(`  ${i + 1}. ${st.kind}${where}`);
+      console.log(`  ${i + 1}. ${st.kind}${where}${matchNote(st)}`);
     }
+    // AUTO-MATCH · AUTO-REL-COPY — 후보 여러 곳·조건에 걸려 비운 칸도 여기(사유 자리)에 남는다.
+    if (a.lastError?.message) console.log(`  ${tr('사유', `note`)}: ${a.lastError.message}`);
   }
 }
 
+/** AUTO-MATCH — `add_row.match` 가 있으면 "같은 행이 있으면 잇기"를 한 줄로. */
+function matchNote(st) {
+  if (st.kind !== 'add_row' || !st.match) return '';
+  const norm = st.match.normalize?.length ? ` [${st.match.normalize.join(', ')}]` : '';
+  const fill = st.match.fill === 'empty' ? tr(', 빈 칸 채움', `, fill blanks`) : '';
+  return tr(
+    ` · 같은 행이 있으면 잇기(${st.match.on} = ${st.match.key}${norm}${fill})`,
+    ` · link to an existing row if one matches (${st.match.on} = ${st.match.key}${norm}${fill})`,
+  );
+}
+
 /**
  * XLSX-FOLD — 시트가 수백 장인 엑셀을 **표 하나로 접어** 가져온다.
  *
@@ -1544,6 +1567,111 @@ async function cmdDbRowsRm(args) {
   console.log(tr(`${res.deleted}개 행을 지웠습니다.`, `${res.deleted} rows deleted.`));
 }
 
+/**
+ * DEDUPE(F5) — `rootr db duplicates <표> --row <rowId>` 또는 `--values '{"연락처":"010-…"}'`.
+ * 같은 사람(중복 감지 칸 값이 같은 행)마다 보일 칸과 이어진 행 최근 5건(연락 이력)을 보인다.
+ */
+async function cmdDbDuplicates(args) {
+  const target = args._[1];
+  if (!target || (typeof args.row !== 'string' && typeof args.values !== 'string')) {
+    throw new Error(usage(`rootr db duplicates <path|id> (--row <rowId> | --values '<json>') [--json]`));
+  }
+  let values;
+  if (typeof args.values === 'string') {
+    try {
+      values = JSON.parse(args.values);
+    } catch {
+      throw new Error(tr('--values 를 JSON 으로 읽을 수 없습니다.', 'Could not read --values as JSON.'));
+    }
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const res = await client.findDuplicates(id, { rowId: typeof args.row === 'string' ? args.row : undefined, values });
+  if (args.json) return console.log(JSON.stringify(res, null, 2));
+  if (!res.matches.length) return console.log(tr('같은 값의 기존 행이 없습니다.', 'No existing row has the same value.'));
+  for (const m of res.matches) {
+    console.log(tr(`「${m.propName}」 ${m.value} 같은 행:`, `Rows with ${m.propName} = ${m.value}:`));
+    for (const r of m.rows) {
+      console.log(`- ${r.title || '(제목 없음)'}\t${r.id}`);
+      for (const p of r.preview) console.log(`    ${p.name}: ${p.value}`);
+      for (const h of r.history ?? []) {
+        console.log(`    ${h.propName} ${h.total}${tr('건', '')}`);
+        for (const x of h.rows) console.log(`      · ${[x.title, ...x.fields.map((f) => f.value)].filter(Boolean).join(' · ')}`);
+      }
+    }
+  }
+}
+
+/** DEDUPE — `rootr db merge <표> <rowId> --into <기존 rowId>` */
+async function cmdDbMerge(args) {
+  const [, target, rowId] = args._;
+  if (!target || !rowId || typeof args.into !== 'string') throw new Error(usage(`rootr db merge <path|id> <rowId> --into <rowId>`));
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const res = await client.mergeRows(id, rowId, args.into);
+  console.log(
+    tr(
+      `합쳤습니다 → ${res.into} (빈 칸 채움: ${res.filled.join(', ') || '없음'}). ${rowId} 행은 지웠습니다.`,
+      `Merged into ${res.into} (filled: ${res.filled.join(', ') || 'none'}). Row ${rowId} was deleted.`,
+    ),
+  );
+}
+
+/** ROW-HISTORY — `rootr db history <표> [--row <rowId>] [--limit N] [--json]` */
+async function cmdDbHistory(args) {
+  const target = args._[1];
+  if (!target) throw new Error(usage(`rootr db history <path|id> [--row <rowId>] [--limit N] [--json]`));
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const res = await client.databaseHistory(id, { rowId: typeof args.row === 'string' ? args.row : undefined, limit: args.limit ? Number(args.limit) : 50 });
+  if (args.json) return console.log(JSON.stringify(res, null, 2));
+  for (const c of res.changes) {
+    const cols = [...new Set([...Object.keys(c.before ?? {}), ...Object.keys(c.after ?? {})])];
+    console.log(`${c.at}\t${c.kind}\t${c.rowId}\t${c.actor?.name ?? '-'}${c.via ? ` (${c.via})` : ''}\t${cols.join(',')}\t${c.id}`);
+  }
+}
+
+/** ROW-RESTORE — `rootr db restore <표> --at <ISO> [--yes]` (--yes 없으면 미리보기) */
+async function cmdDbRestore(args) {
+  const target = args._[1];
+  if (!target || typeof args.at !== 'string') throw new Error(usage(`rootr db restore <path|id> --at <ISO time> [--yes]`));
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const preview = await client.restoreDatabase(id, args.at, { dryRun: true });
+  const sc = preview.schema ?? {};
+  console.log(
+    tr(
+      `고칠 행 ${preview.updates} · 되살릴 행 ${preview.creates} · 지울 행 ${preview.deletes}` +
+        (sc.restorable ? (sc.differs ? ` · 표 정의: 되살릴 칸 ${sc.propsAdded}, 뺄 칸 ${sc.propsRemoved}, 바뀌는 칸 ${sc.propsChanged}${sc.views ? ', 보기' : ''}${sc.buttons ? ', 버튼' : ''}${sc.automations ? ', 자동 규칙' : ''}` : ' · 표 정의는 같음') : ' · 그 시각의 표 정의 기록 없음(행만)'),
+      `rows to edit ${preview.updates} · revive ${preview.creates} · delete ${preview.deletes}` +
+        (sc.restorable ? (sc.differs ? ` · definition: ${sc.propsAdded} column(s) back, ${sc.propsRemoved} removed, ${sc.propsChanged} changed${sc.views ? ', views' : ''}${sc.buttons ? ', buttons' : ''}${sc.automations ? ', automations' : ''}` : ' · definition unchanged') : ' · no definition record at that time (rows only)'),
+    ),
+  );
+  if (!args.yes) return console.log(tr('미리보기입니다. 되돌리려면 --yes 를 붙이세요.', 'Preview only. Add --yes to restore.'));
+  const res = await client.restoreDatabase(id, args.at);
+  if (res.job) {
+    let job = { done: 0, total: res.job.total, state: 'running' };
+    while (job.state !== 'done') {
+      await new Promise((r) => setTimeout(r, 2000));
+      job = await client.restoreJob(id, res.job.id);
+      process.stderr.write(`\r${job.done}/${job.total}`);
+    }
+    process.stderr.write('\n');
+    if (job.failed) console.log(tr(`되돌리지 못한 행 ${job.failed}개 — 같은 시각으로 다시 실행하세요.`, `${job.failed} row(s) failed — run the same restore again.`));
+  }
+  console.log(tr('되돌렸습니다.', 'Restored.'));
+}
+
+/** DEDUPE-KEEP — `rootr db keep-duplicate <표> <rowId> --from <이전 rowId>` */
+async function cmdDbKeepDuplicate(args) {
+  const [, target, rowId] = args._;
+  if (!target || !rowId || typeof args.from !== 'string') throw new Error(usage(`rootr db keep-duplicate <path|id> <rowId> --from <rowId>`));
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  await client.keepDuplicate(id, rowId, args.from);
+  console.log(tr(`새 행으로 두고 ${args.from} 행과 서로 링크를 남겼습니다.`, `Kept as a new row and linked with ${args.from}.`));
+}
+
 /**
  * PUBLIC-ANY — `rootr publish <노드> [--children|--off|--status]`
  *
@@ -2161,6 +2289,11 @@ async function cmdDb(args) {
   if (sub === 'rows-each') return cmdDbRowsEach(args);
   if (sub === 'rows-set') return cmdDbRowsSet(args);
   if (sub === 'rows-rm') return cmdDbRowsRm(args);
+  if (sub === 'duplicates') return cmdDbDuplicates(args);
+  if (sub === 'merge') return cmdDbMerge(args);
+  if (sub === 'keep-duplicate') return cmdDbKeepDuplicate(args);
+  if (sub === 'history') return cmdDbHistory(args);
+  if (sub === 'restore') return cmdDbRestore(args);
   if (sub === 'row-page') return cmdDbRowPage(args);
   if (sub === 'row-page-type') return cmdDbRowPageType(args);
   if (sub === 'lock') return cmdDbLock(args);
@@ -2172,7 +2305,7 @@ async function cmdDb(args) {
   if (sub === 'view') return cmdDbView(args);
   if (sub !== 'create') {
     throw new Error(
-      usage(tr(`rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify|buttons|button-run|automations|import-sheets|view … (자세한 건 rootr --help)`, `rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify|buttons|button-run|view … (see rootr --help)`)),
+      usage(tr(`rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|duplicates|merge|keep-duplicate|history|restore|row-page|row-page-type|lock|notify|buttons|button-run|automations|import-sheets|view … (자세한 건 rootr --help)`, `rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|duplicates|merge|keep-duplicate|history|restore|row-page|row-page-type|lock|notify|buttons|button-run|view … (see rootr --help)`)),
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
@@ -2295,7 +2428,7 @@ async function cmdDbNotify(args) {
  */
 async function cmdDbView(args) {
   const target = args._[1];
-  if (!target) throw new Error(usage(tr(`rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름] [--json]`, `rootr db view <path|id> [view name] [--scale week|month|year] [--name <new name>] [--json]`)));
+  if (!target) throw new Error(usage(tr(`rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름] [--cards "칸,칸"] [--json]`, `rootr db view <path|id> [view name] [--scale week|month|year] [--name <new name>] [--cards "field,field"] [--json]`)));
 
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
@@ -2329,8 +2462,13 @@ async function cmdDbView(args) {
     patch.calendarScale = scale;
   }
   if (typeof args.name === 'string') patch.name = args.name;
+  // CARD-PROPS — 보드 카드에 보일 칸(이름 또는 id, 쉼표로). "" 이면 기본으로.
+  if (typeof args.cards === 'string') {
+    const cards = args.cards.split(',').map((c) => c.trim()).filter(Boolean);
+    patch.cardProps = cards.length ? cards : null;
+  }
   if (!Object.keys(patch).length) {
-    throw new Error(tr('바꿀 것을 주세요: --scale week|month|year 또는 --name 새이름', `Give something to change: --scale week|month|year, or --name <new name>`));
+    throw new Error(tr('바꿀 것을 주세요: --scale week|month|year, --name 새이름 또는 --cards "칸,칸"', `Give something to change: --scale week|month|year, --name <new name>, or --cards "field,field"`));
   }
 
   const view = await client.updateDatabaseView(id, viewRef, patch);
@@ -2410,7 +2548,7 @@ async function cmdDbButtons(args) {
           : st.values
             ? ' · ' + Object.entries(st.values).map(([k, v]) => `${k}=${v}`).join(', ')
             : '';
-      console.log(`  ${i + 1}. ${what}${where}${detail}`);
+      console.log(`  ${i + 1}. ${what}${where}${detail}${matchNote(st)}`);
     }
   }
   if (myLevel && myLevel !== 'MANAGE' && myLevel !== 'FULL') {
@@ -2448,6 +2586,9 @@ async function cmdDbButtonRun(args) {
   if (madeCount) parts.push(tr(`행 ${madeCount}개 만듦`, `${madeCount} rows created`));
   if (r.updated) parts.push(tr(`행 ${r.updated}개 고침`, `${r.updated} rows changed`));
   if (r.filled) parts.push(tr(`AI로 칸 ${r.filled}개 채움`, `${r.filled} columns filled by AI`));
+  // AUTO-MATCH — 새로 만들지 않고 있던 행에 이은 것 / 후보가 여럿이라 멈춘 것.
+  if (r.matched?.linked) parts.push(tr(`있던 행 ${r.matched.linked}개에 이음`, `${r.matched.linked} linked to existing rows`));
+  if (r.matched?.ambiguous) parts.push(tr(`후보 여러 곳이라 멈춤 ${r.matched.ambiguous}건(행 댓글 확인)`, `${r.matched.ambiguous} stopped — several candidates (see the row comment)`));
   console.log(parts.length ? parts.join(' · ') : tr('바뀐 것이 없습니다.', `Nothing changed.`));
   if (r.openRowId) console.log(tr(`열 행: ${r.openRowId}`, `Row to open: ${r.openRowId}`));
   // AI가 못 채워도 버튼은 계속 돈다 — 조용히 넘어가면 사람이 왜 빈칸인지 모른다.
@@ -2458,6 +2599,8 @@ async function cmdDbButtonRun(args) {
         `${r.aiFailed} columns the AI could not fill${r.aiError ? ` — ${r.aiError}` : ''}`,
       ),
     );
+  for (const n of r.notes ?? []) console.log(`· ${n}`);
+  if (r.linkWarning) console.log(`· ${r.linkWarning}`);
 }
 
 

package/lib/client.js

@@ -1221,13 +1221,74 @@ export class RootrClient {
     });
   }
 
-  async updateColumn(databaseId, propertyId, { name, options, formula, rollup, prefix, reverseName, searchExcluded } = {}) {
+  async updateColumn(
+    databaseId,
+    propertyId,
+    { name, options, optionRenames, formula, rollup, prefix, reverseName, searchExcluded, dedupe, dedupeShow, relationFilter } = {},
+  ) {
     return this.request(
       `/databases/${encodeURIComponent(databaseId)}/columns/${encodeURIComponent(propertyId)}`,
-      { method: 'PATCH', body: { name, options, formula, rollup, prefix, reverseName, searchExcluded } },
+      {
+        method: 'PATCH',
+        body: { name, options, optionRenames, formula, rollup, prefix, reverseName, searchExcluded, dedupe, dedupeShow, relationFilter },
+      },
     );
   }
 
+  /**
+   * DEDUPE(F5) — 중복 감지 칸 값이 같은 기존 행. `rowId` 를 주면 그 행의 지금 값으로(그 행은 빠진다), 아니면 `values`
+   * ({칸 id 또는 이름: 값})로 찾는다. 기존 행마다 보일 칸(preview)과 이어진 행 최근 5건(history)이 함께 온다.
+   */
+  async findDuplicates(databaseId, { rowId, values } = {}) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/duplicates`, {
+      method: 'POST',
+      body: rowId ? { rowId } : { values: values ?? {} },
+    });
+  }
+
+  /** DEDUPE — `rowId` 행을 `into` 행에 합친다(빈 칸만 채우고 "재지원" 댓글, `rowId` 행은 지운다). */
+  async mergeRows(databaseId, rowId, into) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/rows/${encodeURIComponent(rowId)}/merge`, {
+      method: 'POST',
+      body: { into },
+    });
+  }
+
+  /** ROW-HISTORY(F6) — 표(또는 한 행)의 변경 이력, 최신부터. `before`+`beforeId` 로 이어 읽는다. */
+  async databaseHistory(databaseId, { rowId, before, beforeId, limit } = {}) {
+    const q = new URLSearchParams();
+    if (rowId) q.set('rowId', rowId);
+    if (before) q.set('before', before);
+    if (beforeId) q.set('beforeId', beforeId);
+    if (limit) q.set('limit', String(limit));
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/history${q.toString() ? `?${q}` : ''}`);
+  }
+
+  /** ROW-RESTORE(F7) — 행 하나를 그 변경의 전(`before`)/후(`after`) 모습으로. 지운 행도 되살린다. */
+  async restoreRow(databaseId, rowId, changeId, side = 'after') {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/rows/${encodeURIComponent(rowId)}/restore`, {
+      method: 'POST',
+      body: { changeId, side },
+    });
+  }
+
+  /** ROW-RESTORE(F7·G3) — 표 전체(행 + 칸·보기·버튼·자동 규칙)를 그 시각으로. `dryRun` 이면 미리보기만. 큰 표는 `job` 이 온다. */
+  async restoreDatabase(databaseId, at, { dryRun } = {}) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/restore`, { method: 'POST', body: { at, dryRun: dryRun === true } });
+  }
+
+  async restoreJob(databaseId, jobId) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/restore/${encodeURIComponent(jobId)}`);
+  }
+
+  /** DEDUPE-KEEP — 새 행으로 두되 같은 사람의 이전 행(`from`)과 서로 링크 댓글을 남긴다. */
+  async keepDuplicate(databaseId, rowId, from) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/rows/${encodeURIComponent(rowId)}/keep-duplicate`, {
+      method: 'POST',
+      body: { from },
+    });
+  }
+
   // DB-VECTOR — 에이전트용 벡터 칸(칸 id 또는 이름).
   async putVectors(databaseId, column, items) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/vectors/${encodeURIComponent(column)}`, {

package/lib/mcp-tools/databases.js

@@ -412,6 +412,30 @@ export function registerDatabaseTools(server) {
               'Default month. The year view shows twelve mini-months at once (darker = more rows that day). ' +
               'Saved on the view, so everyone who opens it sees that span.',
           ),
+        cardProps: z
+          .array(z.string())
+          .nullable()
+          .optional()
+          .describe(
+            'board view only: the fields shown on each card, in this order (names or ids, up to 12). Rollups and formulas ' +
+              'work here (e.g. an interview date rolled up from a linked table) — only the picked ones are computed. ' +
+              'null or [] goes back to the default (the first 3 stored fields that have a value).',
+          ),
+        rowColors: z
+          .array(
+            z.object({
+              propId: z.string(),
+              op: z.enum(['is', 'is_not_empty']),
+              values: z.array(z.string()).optional(),
+              color: z.string(),
+            }),
+          )
+          .nullable()
+          .optional()
+          .describe(
+            'Tint rows/cards by value: the first matching rule wins. e.g. [{propId:"진행상태",op:"is",values:["채용불가"],color:"red"}, ' +
+              '{propId:"면접예정일",op:"is_not_empty",color:"yellow"}]. Colors: gray, brown, orange, yellow, green, blue, purple, pink, red. null or [] turns it off.',
+          ),
       },
     },
     async ({
@@ -426,6 +450,8 @@ export function registerDatabaseTools(server) {
       sort,
       colWidths,
       calendarScale,
+      cardProps,
+      rowColors,
     }) => {
       try {
         const client = makeClient();
@@ -440,6 +466,8 @@ export function registerDatabaseTools(server) {
           sort,
           colWidths,
           calendarScale,
+          cardProps,
+          rowColors,
         });
         return jsonResult({ view });
       } catch (err) {
@@ -1055,9 +1083,57 @@ export function registerDatabaseTools(server) {
               'chat, button AI-fill steps, formula/rollup columns and MCP reads still see the values; to hide values from ' +
               'people, use an "own rows only" table or a private node. Table managers only. false puts the column back into the index.',
           ),
+        optionRenames: z
+          .array(z.object({ from: z.string(), to: z.string() }))
+          .optional()
+          .describe(
+            'select/multi_select/status with `options`: rename choices and move every row that used the old name ' +
+              '(e.g. [{from:"신규접수",to:"접수 완료"}]). A choice left out of `options` and not renamed is DELETED and the rows using it are emptied.',
+          ),
+        dedupe: z
+          .boolean()
+          .optional()
+          .describe(
+            'title/text/phone/email/url only: warn when another row has the same value (phone numbers compare digits only, ' +
+              'other text ignores case and spaces). People get a choose-merge-or-keep dialog; forms filled inside Rootr warn before submit; ' +
+              'public forms leave a "possible duplicate" comment. See rootr_find_duplicates.',
+          ),
+        dedupeShow: z
+          .array(z.string())
+          .nullable()
+          .optional()
+          .describe(
+            'With dedupe on: which fields of the EXISTING row the duplicate dialog shows, in order (column ids). A relation column ' +
+              'shows the latest 5 linked rows (contact history) and the total. Names or ids; an unknown name is refused (400), not dropped. ' +
+              'null/[] = automatic (status, notes, dates, rollups; relations as history).',
+          ),
+        relationFilter: z
+          .array(z.object({ propId: z.string(), op: z.enum(['is', 'is_not_empty']), values: z.array(z.string()).optional() }))
+          .nullable()
+          .optional()
+          .describe(
+            'relation only: which rows of the linked table may be linked (all rules must match; propId is a column of the LINKED table). ' +
+              'e.g. [{propId:"진행상태",op:"is",values:["채용"]}]. The picker hides others and the server refuses new links that fail. null turns it off.',
+          ),
       },
     },
-    async ({ databaseId, propertyId, name, options, formula, rollup, prefix, reverseName, searchExcluded, type, dimensions }) => {
+    async ({
+      databaseId,
+      propertyId,
+      name,
+      options,
+      formula,
+      rollup,
+      prefix,
+      reverseName,
+      searchExcluded,
+      optionRenames,
+      dedupe,
+      dedupeShow,
+      relationFilter,
+      type,
+      dimensions,
+    }) => {
       // 조용히 무시하지 않는다 — 못 바꾸는 것을 넘기면 까닭과 할 일을 말한다(벡터 차원을 바꾸면 저장된 벡터가 전부 틀려진다).
       if (type !== undefined || dimensions !== undefined) {
         return errorResult(
@@ -1078,6 +1154,10 @@ export function registerDatabaseTools(server) {
           prefix,
           reverseName,
           searchExcluded,
+          optionRenames,
+          dedupe,
+          dedupeShow,
+          relationFilter,
         });
         return jsonResult({ property });
       } catch (err) {
@@ -1086,6 +1166,190 @@ export function registerDatabaseTools(server) {
     },
   );
 
+  // ── DEDUPE(F5) — 같은 사람 찾기·합치기·새 행으로 두기 ─────────────────────
+  //
+  // 화면의 중복 창과 같은 일을 에이전트도 할 수 있어야 한다. 그렇지 않으면 "지원자 붙여 넣으면서 이미 있는 사람은 합쳐 줘"
+  // 같은 부탁에서 에이전트가 표 전체를 읽어 전화번호를 손으로 견주게 된다(9천 행이면 수 MB).
+
+  server.registerTool(
+    'rootr_find_duplicates',
+    {
+      title: 'Find existing rows that duplicate a row (same phone/email/name)',
+      description:
+        'Find rows of a Rootr (루터) DATABASE whose duplicate-detection columns (rootr_update_column dedupe:true — e.g. a phone ' +
+        'column) hold the same value. Phone numbers compare digits only (010-1234-5678 = 01012345678); other text ignores case ' +
+        'and spaces. Give `rowId` to check an existing row (it is excluded from the result) or `values` ({column name or id: value}) ' +
+        'to check before adding. Each match comes with the fields the duplicate dialog shows (`preview`: status, notes, dates, rollups ' +
+        '— or the column\'s dedupeShow list) and `history`: the latest 5 linked rows per relation column (e.g. call log) with the total. ' +
+        'Only rows the caller can see are returned. Then use rootr_merge_rows or rootr_keep_duplicate.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().optional().describe('Check this existing row (its current values).'),
+        values: z.record(z.any()).optional().describe('Or check these values before adding a row: { "연락처": "010-1234-5678" }'),
+      },
+    },
+    async ({ databaseId, rowId, values }) => {
+      try {
+        if (!rowId && !values) return errorResult(new Error('rowId 나 values 중 하나를 주세요.'));
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.findDuplicates(id, { rowId, values }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_merge_rows',
+    {
+      title: 'Merge a duplicate row into an existing row',
+      description:
+        'Merge row `rowId` into row `into` of the same Rootr (루터) DATABASE — the "same person applied again" case. Empty cells of ' +
+        '`into` are filled from `rowId` (existing values are kept), relation/multi-select/people/files are unioned (so a call log linked ' +
+        'to the new row moves to the old one), a "🔁 재지원" comment listing the new values is left on `into`, and `rowId` is DELETED ' +
+        '(row history records it as merged into `into`). Both rows must be editable by the caller. Not reversible except by the table history.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().describe('The newer/duplicate row — it is deleted after merging'),
+        into: z.string().describe('The existing row to keep'),
+      },
+    },
+    async ({ databaseId, rowId, into }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.mergeRows(id, rowId, into));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_keep_duplicate',
+    {
+      title: 'Keep a duplicate as a new row but link it to the earlier row',
+      description:
+        'The "keep as new row" choice: leaves row `rowId` as it is and writes a 🔗 comment on BOTH rows pointing at each other, so the ' +
+        'earlier history follows the new row. Use when the same person really should have a separate row (e.g. a new application period).',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().describe('The new row to keep'),
+        from: z.string().describe('The earlier row of the same person'),
+      },
+    },
+    async ({ databaseId, rowId, from }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.keepDuplicate(id, rowId, from));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  // ── ROW-HISTORY / RESTORE(F6·F7·G3) — 행·표 이력과 되돌리기 ─────────────────
+
+  server.registerTool(
+    'rootr_database_history',
+    {
+      title: 'Read the change history of a database (or one row)',
+      description:
+        'Newest-first change history of a Rootr (루터) DATABASE — every create/update/delete with who, when, how (via: button, ' +
+        'automation, form, restore, option-edit, merge:<rowId>, link…) and the before/after values of the changed columns. Give `rowId` ' +
+        'for one row. Page with `before` + `beforeId` (the `at` and `id` of the last item you got). Use the change `id`s with ' +
+        'rootr_restore_row, or an `at` with rootr_restore_database.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().optional(),
+        before: z.string().optional().describe('ISO time — only changes before it (the `at` of the last item of the previous page)'),
+        beforeId: z.string().optional().describe('The `id` of the last item of the previous page (needed when many changes share a time)'),
+        limit: z.number().int().min(1).max(500).optional(),
+      },
+    },
+    async ({ databaseId, rowId, before, beforeId, limit }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.databaseHistory(id, { rowId, before, beforeId, limit }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_restore_row',
+    {
+      title: 'Restore one row to how it was at a change',
+      description:
+        'Put ONE row of a Rootr (루터) DATABASE back to its state right after (`side: "after"`, default) or right before (`"before"`) ' +
+        'the change `changeId` from rootr_database_history. A deleted row comes back with the same id (links on the other side are ' +
+        'restored too). The restore itself is recorded in the history, so it can be undone the same way.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string(),
+        changeId: z.string().describe('The history item id'),
+        side: z.enum(['after', 'before']).optional(),
+      },
+    },
+    async ({ databaseId, rowId, changeId, side }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.restoreRow(id, rowId, changeId, side ?? 'after'));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_restore_database',
+    {
+      title: 'Restore a whole database to a point in time',
+      description:
+        'Put a whole Rootr (루터) DATABASE back to how it was at `at` (ISO time): rows created after it are deleted, rows deleted after ' +
+        'it come back, edited values go back — and the table definition too (columns incl. deleted ones and their values, select ' +
+        'choices, views, buttons, automations) when it was recorded at that time. ALWAYS call with `dryRun: true` first and show ' +
+        'the person the counts (`updates/creates/deletes`, `schema`). Table managers only. Big restores (over 300 rows) run in the ' +
+        'background: the reply has `job`, and this tool waits up to ~2 minutes for it, then returns the progress — call ' +
+        'rootr_restore_database again with `jobId` to keep checking. Automations do not fire while restoring.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        at: z.string().optional().describe('ISO time to go back to'),
+        dryRun: z.boolean().optional().describe('true = only count what would change'),
+        jobId: z.string().optional().describe('Check a running background restore instead of starting one'),
+      },
+    },
+    async ({ databaseId, at, dryRun, jobId }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        if (jobId) return jsonResult({ job: await client.restoreJob(id, jobId) });
+        if (!at) return errorResult(new Error('at(ISO 시각)을 주세요.'));
+        const res = await client.restoreDatabase(id, at, { dryRun });
+        if (!res.job) return jsonResult(res);
+        let job = { ...res.job, done: 0, state: 'running' };
+        for (let i = 0; i < 60 && job.state !== 'done'; i++) {
+          await new Promise((r) => setTimeout(r, 2000));
+          job = await client.restoreJob(id, res.job.id);
+        }
+        return jsonResult({ ...res, job });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   // ── DB-PERM-001 / DB-WATCH — 노션에 없는 두 가지: 자물쇠와 알림 ────────────
   //
   // 표를 만들 수 있으면 잠글 수도, 누구에게 알릴지 정할 수도 있어야 한다. 이게 없으면
@@ -1286,12 +1550,27 @@ export function registerDatabaseTools(server) {
         'row the person pressed on, where `relation` is the relation column IN THE TARGET table that points back ' +
         'here. That pair is how "press 전화 on an applicant → a call row already linked to them" becomes one ' +
         'press instead of switching tables and searching the person again.\n' +
+        '  add_row also takes `match: { key: "{요청 건}", on: "업체명", normalize?: ["spaces","parens","suffix:의원",' +
+        '"trailingDigits","case"], fill?: "empty" }` — FIND-OR-LINK instead of always creating: `key` (filled from the ' +
+        'pressed row) is compared with the target column `on` — first exactly (spaces ignored, so "다라치과(홍대점)" ' +
+        'picks that branch), then after `normalize` (parens drops "(긴급)"·"(소독)", suffix:X drops a trailing X, ' +
+        'trailingDigits drops a trailing number). ONE match → no new row, the pressed row is ADDED to that row\'s `link` ' +
+        'relation (fill:"empty" also fills its blank cells from `values`); NONE → created as usual; TWO OR MORE → ' +
+        'nothing is created and the pressed row gets a "후보 여러 곳: A, B" comment so a person picks. The result ' +
+        'says `matched: { linked, created, ambiguous }`.\n' +
         '· {kind:"update_rows", target:"created"|"selected", values} — set values on the rows this button just ' +
         'made, or on the rows the person ticked in the table.\n' +
         '· {kind:"ai_fill", target, propId, prompt} — let AI write ONE cell. The prompt may quote the row with ' +
         '{칸이름}, e.g. "{제목}과 {메모}를 한 문장으로 요약해". If the AI fails the button keeps going.\n' +
         '· {kind:"open_row"} — open the row this button made (UI only; over the API it just reports the id).\n' +
-        'Values accept @today, @today+7 and @me — the server fills them in at press time, not now.\n' +
+        'Values accept @today, @today+7 and @me — the server fills them in at press time, not now. A text value ' +
+        'may also quote the pressed row with {칸이름}, e.g. "{이름} {통화 건수+1}차": computed columns (rollup, ' +
+        'formula) are read too, {칸이름+N} / {칸이름-N} adds to a numeric value, and when several rows are ' +
+        'selected each new row is filled from its own source row. A relation column resolves to the linked row: ' +
+        '{지원자} is its TITLE (not the id) and {지원자.통화 건수} reads one of its columns — EXCEPT when the value ' +
+        'is exactly "{관계 칸}" and the column it goes into is a relation to the SAME table: then the row ids are ' +
+        'copied (e.g. 담당 매니저: "{배정 매니저}"). Ids the receiving column\'s relationFilter rejects are left out ' +
+        'of that cell only (the rest still runs), commented on the row and reported in `notes`.\n' +
         'A button never grants permission: it runs as whoever presses it — writing into another table needs ' +
         'write access there too.',
       annotations: { readOnlyHint: false, destructiveHint: true },
@@ -1333,7 +1612,9 @@ export function registerDatabaseTools(server) {
         'Returns `created` (the ARRAY of row ids it made, not a count), `updated` and `filled` counts, the ' +
         '`openRowId` a final "open_row" step points at (with `openDatabaseId` when that row is in another ' +
         'table), `createdIn` telling which table each new row landed in, and — if the AI could not write a cell — `aiFailed` ' +
-        'with the reason (the rest of the button still ran). ' +
+        'with the reason (the rest of the button still ran). `aiSkipped` counts rows where the AI answered but the ' +
+        'answer could not go in the cell (e.g. not one of a select\'s options), with one sample in `aiSkippedAnswer`; ' +
+        '`aiUnchanged` counts rows whose AI answer equals the current value (left as is, not counted in `filled`). ' +
         'It runs with YOUR permissions: a button that writes a locked column stops there if you cannot edit it.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
@@ -1400,7 +1681,11 @@ export function registerDatabaseTools(server) {
         '부재 3회 초과 → set the applicant to 보류; every morning at 09:00 → flag rows whose 재통화 예정일 is today.\n' +
         'Rules run as the person who SAVED them, never with more permission than that. A rule that a computed ' +
         'column (rollup/formula) triggers must use a value comparison, not changed/changed_to — the server ' +
-        'refuses those instead of quietly never firing.',
+        'refuses those instead of quietly never firing.\n' +
+        'add_row `match` (find-or-link, see rootr_set_database_buttons) is how "투입확정 → 사업장 마스터에 등록" ' +
+        'stops making duplicates for existing customers: one matching 사업장 → linked, none → created, several → a ' +
+        '"후보 여러 곳" comment on the request row. Those notes, and relation ids skipped by a relationFilter, are ' +
+        'written to the rule\'s lastError (with the row) — read them with rootr_list_database_automations.',
       annotations: { readOnlyHint: false, destructiveHint: true },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),

package/lib/mcp-tools/forms.js

@@ -31,6 +31,10 @@ const fieldShape = z
       .boolean()
       .optional()
       .describe('Not shown; filled from the URL (?이름=값). Use to record where a signup came from.'),
+    range: z
+      .boolean()
+      .optional()
+      .describe('date only: false = a single date (no end-date input). Omitted/true = start + optional end.'),
     showIf: z
       .object({ fieldId: z.string(), equals: z.string() })
       .optional()
@@ -45,7 +49,8 @@ const FIELDS_GUIDE =
   'Also: time (HH:MM) and file (uploaded on the published page only). ' +
   'select/multi_select/matrix/ranking need `options` ({name,color}[]); matrix also needs `rows`. ' +
   'Per-field extras: `help` (a hint line), `placeholder`, `page` (split into multiple pages), `hidden` + URL ' +
-  'params (record the traffic source), `showIf` (show only when an earlier answer matches). ' +
+  'params (record the traffic source), `showIf` (show only when an earlier answer matches), `range: false` on a ' +
+  'date field (ask for ONE date — by default a date field also shows an optional end date). ' +
   'Read the form first (rootr_read_form) before updating so ' +
   'you keep each field\'s `id` stable — response values are keyed by field id, so renaming/dropping an id orphans ' +
   'past responses\' answers for that field.';

package/lib/mcp-tools/pages.js

@@ -26,7 +26,9 @@ import {
 const BLOCK_GUIDE =
   'A page is `blocks[]` (ordered, max 200) + `config`. Each block is {id?, type, props}. ' +
   'You assemble a page from these block types:\n' +
-  '· hero {title, subtitle?, align?:"left"|"center", background?:{kind:"color",color}|{kind:"image",attachmentId}, button?:{label,target}} — the opening banner\n' +
+  '· hero {title, subtitle?, align?:"left"|"center", size?:"normal"|"screen", background?:{kind:"color",color}|{kind:"image",attachmentId}, button?:{label,target}} — the opening banner. ' +
+  'size:"screen" makes it a FULL-SCREEN landing hero: edge to edge and one viewport tall (minus the top name bar, capped at 1200px), big headline, content centred vertically ' +
+  '(default "normal" = a compact banner inside the text column)\n' +
   '· text {body (markdown), title?} — prose section; markdown is sanitized when rendered\n' +
   '· features {columns?:1|2|3, items:[{title, body, icon?(emoji)}]} — "what it does" grid\n' +
   '· gallery {images:[{attachmentId, caption?}]} — images must be workspace attachments (no external image URLs)\n' +
@@ -40,12 +42,35 @@ const BLOCK_GUIDE =
   '· liveTable {source:{nodeId}, columns?:[name], rowLimit?(1-200), orderBy?:{column, dir:"asc"|"desc"}}\n' +
   '· liveChart {source:{nodeId, sheet?, range?}, chart, labelColumn, valueColumn?, agg?, …} — a LIVE chart (46 kinds, see CHARTS below)\n' +
   '· form {formNodeId(FORM node), headline?, submitLabel?} — visitors submit right on the page\n' +
-  '· custom {html, height?(40-4000, default 260)} — free HTML/CSS, rendered inside a locked-down sandboxed iframe ' +
+  '· booking {bookingNodeId(DATABASE node id — a table that is published with visitor booking turned on, see rootr_set_booking), headline?, type?} — ' +
+  'a visitor scheduling calendar right on the page; `type` shows only one of the table\'s booking types. ' +
+  'bookingNodeId must be the node ID (names/paths are not resolved here); a table that is not published or has booking off renders as "not taking bookings"\n' +
+  '· custom {html, height?(40-4000, default 260), minHeight?:"none"|"screen", bleed?:boolean} — free HTML/CSS, rendered inside a locked-down sandboxed iframe ' +
   '(no scripts, no same-origin, no network). Use it for a look the other blocks cannot make. Page theme colors are ' +
   'available inside as var(--pg-bg|text|muted|faint|card|line|accent|on-accent) and var(--pg-font). Scripts and ' +
-  'on*= handlers are stripped on save — do not put behaviour here, only markup and CSS.\n' +
+  'on*= handlers are stripped on save — do not put behaviour here, only markup and CSS. ' +
+  'bleed:true makes the frame span the FULL page width with no gap or padding around it, so consecutive bleed blocks ' +
+  'stack into seamless edge-to-edge colour bands (the sandbox is unchanged). Inside a bleed block paint your own ' +
+  'full-width background and keep the content in a centred max-width wrapper; still set `height` (the frame does not auto-size). ' +
+  'minHeight:"screen" makes the frame ONE VIEWPORT TALL on every device (same rule as hero size:"screen": minus the top name bar, capped at 1200px); ' +
+  'a numeric `height` given with it becomes the FLOOR — frame height = max(one screen, height) — so give the height your content ' +
+  'needs on a short phone and nothing is clipped. Inside, take the frame height with `height:100%` (html and body already are 100%) ' +
+  'and centre the content with flexbox. bleed:true + minHeight:"screen" = a full-screen section; stack several for a ' +
+  'section-per-screen landing page.\n' +
   'LAYOUT: any block takes `width:"full"|"twoThirds"|"half"|"third"` — neighbouring blocks sit side by side (phones stack them). ' +
-  'That is how a page becomes a DASHBOARD: a row of `chart:"kpi"` blocks at width "third", then charts at width "half".\n' +
+  'That is how a page becomes a DASHBOARD: a row of `chart:"kpi"` blocks at width "third", then charts at width "half". ' +
+  'A hero with size:"screen" and a custom block with bleed:true always take the whole row — `width` is ignored (not stored) on them.\n' +
+  'REVEAL (scroll-in animation): any block takes `reveal:"fade"|"fade-up"` (default "none" = always visible). On the published page ' +
+  'the block appears ONCE when it scrolls into view (its top passes ~85% of the viewport height; blocks already on the first screen ' +
+  'play right after load): "fade" fades in, "fade-up" also rises a little. A hero staggers title → subtitle → button while its ' +
+  'background stays put. On a custom block, reveal ALSO starts the CSS animations inside the frame at that moment — the sandboxed ' +
+  'frame is created only when the block scrolls in, so `@keyframes`/`animation` in your html run from 0s exactly when the visitor ' +
+  'sees the section (without reveal they start at page load and are over before anyone scrolls down). Write those animations so ' +
+  'the content is still fine without them and wrap them in `@media (prefers-reduced-motion: no-preference)`. Visitors who ask ' +
+  'for reduced motion, and browsers without IntersectionObserver, simply see everything at once; nothing shifts layout. The editor ' +
+  'always shows blocks (the effect plays in its preview mode and on the published page).\n' +
+  'LANDING PAGE: start with hero size:"screen", follow with custom bleed:true bands (add minHeight:"screen" where a section should fill the screen), and set config.navEnabled:false so the hero owns the first screen. ' +
+  'All other blocks stay in the centred text column.\n' +
   'CHARTS (liveChart): chart ∈ bar|barH|stackedBar|stackedBarH|percentBar|lollipop|dumbbell|bullet|waterfall|pareto|radar|polarBar|line|step|area|stackedArea|percentArea|combo|slope|stream|calendar|pie|donut|halfDonut|rose|funnel|treemap|sunburst|waffle|histogram|boxplot|heatmap|scatter|bubble|sankey|chord|network|tree|kpi|gauge|progress|ring|candlestick|gantt|wordCloud|pivot. ' +
   'source = a DATABASE, SPREADSHEET or LOG node (sheet: {nodeId, sheet?(name), range?:"A1:F200"} — first row = column names, formula results are read). ' +
   'Category charts: labelColumn (dates are bucketed: dateBucket day|week|month|quarter|year|weekday|hour, empty periods filled with 0) + ' +

package/lib/mcp-tools/workspaces.js

@@ -41,6 +41,11 @@ const ACCESS_HINT =
   'lock) and `database.notifications` (who to notify on row changes). A database property may carry ' +
   '`searchExcluded: true` (values stay out of the search index behind ask / AI explore / similar rows — not a read permission) and a `type: "vector"` ' +
   'property needs `dimensions` (an embedding column agents fill with rootr_set_row_vectors). ' +
+  'A phone/email/name property may carry `dedupe: true` (warn when the same person is entered again) with ' +
+  '`dedupeShow: ["진행상태","특이사항","콜 이력"]` (fields of the existing row the warning shows — a relation shows its latest 5 rows); ' +
+  'a relation property may carry `relationFilter: [{ propId, op: "is"|"is_not_empty", values? }]` (which linked rows may be picked). ' +
+  'A board view config may carry `cardProps: ["면접예정일","연락처"]` (fields on each card, rollups too) and any view `rowColors` ' +
+  '(`[{ propId, op: "is"|"is_not_empty", values?, color }]`). ' +
   'A DOCUMENT\'s `content` may embed a live ' +
   'table/sheet/deck with a line `[[embed:<name of a node in this same tree>]]` or `[[embed:/absolute/path]]` — it is ' +
   'linked to the real node after the whole tree is built (an unknown name rolls the whole tree back).';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Official Rootr CLI + MCP server — read, write, edit and search Rootr documents from the shell or from an AI agent.",
   "type": "module",
   "bin": {