rootr-cli 0.17.3 → 0.18.0

package/README.ko.md

@@ -221,6 +221,22 @@ rootr config                       # 등록된 키 목록 확인
 업그레이드 링크가 담긴 안내가 나옵니다. 응답 헤더로도 확인할 수 있습니다
 (`X-RateLimit-Remaining`, `X-RateLimit-Reset`, `X-RateLimit-Window`).
 
+#### 처음 옮겨 올 때: 이관 유예 72시간
+
+옮겨 오는 일은 한 번뿐인데 하루 한도와 맞지 않습니다 — 2만 행짜리 표는 500행씩
+나눠 읽어도 한 번 훑는 데 42회가 듭니다. 그래서 **워크스페이스당 한 번, 72시간**
+동안 조회 한도를 풉니다.
+
+워크스페이스 **설정 → 요금제**에서 켜거나, 관리자 키로 이렇게 켤 수 있습니다:
+
+```bash
+curl -X POST https://rootr.io/api/v1/workspaces/<워크스페이스 id>/billing/migration-grace \
+  -H "x-api-key: $ROOTR_API_KEY"
+```
+
+같은 주소에 `GET` 하면 언제 켰는지·언제 끝나는지를 돌려줍니다. 한 번 쓴 뒤에는
+거절되고 "언제 썼는지"를 함께 알려 줍니다.
+
 ### 서명문서 · 연구노트 (sign)
 
 서명문서는 마크다운 문서인데 **올리는 순간 본문이 얼고**, 결재라인에 적힌 사람들이
@@ -429,6 +445,11 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 | `rootr_list_database_buttons` | 표 위 **버튼** 목록 보기(고칠 수 있는지 `myLevel`도 함께) |
 | `rootr_set_database_buttons` | 버튼 만들고 고치기 — **목록 통째로 교체**(남길 것도 같이 보내야 함) |
 | `rootr_run_database_button` | 버튼 누르기 — 행 만들기·값 채우기·AI로 칸 채우기가 순서대로 |
+| `rootr_list_database_automations` | 표의 **자동 규칙** 목록 보기 |
+| `rootr_set_database_automations` | 자동 규칙 저장 — "값이 이렇게 되면 이 일을 해라"·정해진 시각(목록 통째로 교체) |
+| `rootr_import_folded_sheets` | 시트가 수백 장인 엑셀을 **표 하나로 접어** 가져오기(먼저 `dryRun`) |
+| `rootr_form_mapping` | 폼 질문이 표의 **어느 칸**으로 가는지 + 짝 없는 질문(값이 버려짐) |
+| `rootr_set_form_mapping` | 질문↔칸 짝을 손으로 정하기 — 이름이 달라도 값이 안 사라지게 |
 | `rootr_list_document_commits` | 공개 문서에 온 변경 제안 목록 |
 | `rootr_merge_document_commit` | 변경 제안 반영(세 벌 병합 — 덮어쓰기 아님) |
 | `rootr_reject_document_commit` | 변경 제안 거절(사유는 제안자에게 전달) |
@@ -451,6 +472,7 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 rootr db buttons <표>                      # 지금 달린 버튼 보기
 rootr db buttons <표> --file buttons.json  # 목록 통째로 저장(남길 것도 같이)
 rootr db button-run <표> <버튼id>           # 한 번 누르기 (--rows id,id 로 고른 행 지정)
+rootr db automations <표> --file rules.json # 자동 규칙 — 사람이 안 눌러도 도는 것
 rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해 중에서
 ```
 
@@ -462,7 +484,38 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
 ] }]
 ```
 
-스캐폴드로 표를 지을 때도 `database.buttons` 에 같은 모양을 넣으면 **표와 함께** 달립니다.
+**다른 표에 행 만들기.** `add_row` 에 `database`(표 id 또는 트리 경로)와
+`link: { "relation": "<대상 표의 관계 칸>", "from": "selected" }` 를 주면, **누른 행이 이미
+연결된 행**이 그 표에 생깁니다. 지원자 행에서 전화 버튼을 누르면 콜 이력에 그 지원자가 붙은
+행이 생기는 식입니다 — 이게 없으면 표를 오가며 같은 사람을 두 번 찾습니다.
+
+```json
+[{ "label": "부재 기록", "icon": "📞", "steps": [
+    { "kind": "add_row", "database": "/01. 채용 파이프라인/콜 이력",
+      "values": { "결과": "부재", "통화일시": "@today", "재통화 예정일": "@today+1" },
+      "link": { "relation": "지원자", "from": "selected" } }
+] }]
+```
+
+**사람이 기억해서 눌러야 하는 일**은 버튼이 아니라 **자동 규칙**으로 겁니다 — 버튼은 안 누른
+날 그 일이 그냥 빠집니다. 단계 문법은 버튼과 똑같고, 조건은 거의 언제나 `changed_to` 입니다
+(`is` 는 그 뒤로 그 행을 고칠 때마다 계속 참이라 행이 몇 벌씩 생깁니다).
+
+```json
+[{ "label": "투입확정 해피콜 3건", "on": ["updated"],
+   "when": { "property": "상태", "op": "changed_to", "value": "투입확정" },
+   "steps": [
+     { "kind": "add_row", "database": "/03. 투입·운영/해피콜",
+       "values": { "차수": "1차", "예정일": "@today+7" },
+       "link": { "relation": "지원자", "from": "selected" } }
+   ] },
+ { "label": "아침 재통화 대기열", "on": ["schedule"], "schedule": { "at": "09:00" },
+   "when": { "property": "재통화 예정일", "op": "is", "value": "@today" },
+   "steps": [{ "kind": "update_rows", "target": "selected", "values": { "오늘 할 일": true } }] }]
+```
+
+스캐폴드로 표를 지을 때도 `database.buttons` · `database.automations` 에 같은 모양을 넣으면
+**표와 함께** 달립니다.
 
 **행에 댓글 달기.** 표의 한 행에 댓글을 달려면 `rootr_comment_document` 에 **표**를
 `target` 으로, **행 id**를 `blockId` 으로 줍니다(읽기는 `rootr_list_document_comments`,
@@ -479,6 +532,10 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
 명령줄에서는 `rootr access <경로|id> --private`, `--grant <userId> --level READ`,
 `--revoke <userId>` 입니다. (웹에 공개하는 것과는 다릅니다 — 그건 `rootr_set_document_public`.)
 
+질문이 표의 어느 칸으로 가는지는 `rootr form mapping <폼>` 으로 봅니다. 질문 이름과 칸 이름이
+같아야 값이 넘어가므로, 다르면 **아무 경고 없이 그 답이 버려집니다** — 표를 직접 만들어 연결한
+직후에는 반드시 한 번 확인하세요. 짝을 손으로 정하려면 `--set '{"질문id":"칸id"}'` 입니다.
+
 응답 모을 곳은 `rootr form collect <폼> --to db|sheet`로 **만들면서** 연결합니다 —
 표로 만들면 폼 질문 그대로 칸이 생기므로, 표를 미리 만들고 칸 이름을 맞출 필요가 없습니다
 (이름이 하나라도 어긋나면 그 칸은 영영 빈 칸으로 남습니다). 스캐폴드 트리에서는 폼 노드에

package/README.md

@@ -193,9 +193,26 @@ rootr db lock /projects/tasks --schema managers --rows own --locked "Approved,Sc
 rootr db notify  /projects/tasks --file rules.json    # notification rules
 rootr db buttons /projects/tasks --file buttons.json  # buttons that do work when pressed
 rootr db button-run /projects/tasks fill-summary --rows r1,r2
+rootr db automations /projects/tasks --file rules.json # "when a value becomes X, do Y" (also: at a set time)
+rootr db rows-new /projects/tasks --file rows.json --upsert-key 외부키  # idempotent load: retries cannot duplicate
+rootr db import-sheets sites.xlsx --ws <id> --dry     # fold a one-sheet-per-record workbook into ONE table
 rootr db row-page <rowId> --type RECORDING            # give one row a typed detail page
 ```
 
+`db automations` takes the same step syntax as `db buttons`, so there is nothing new to
+learn — the difference is that nobody has to press it. A rule is
+`{ label, on: ["updated"], when: { property, op: "changed_to", value }, steps: [...] }`;
+add `on: ["schedule"]` with `schedule: { at: "09:00" }` for a daily job (Korean time).
+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.
+
+`--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).
+
+`db import-sheets` always deserves a `--dry` first: it prints the shape it read, the
+columns it will make and the first rows, and creates nothing. Folding hundreds of sheets
+the wrong way costs far more to undo than to check.
+
 ### Forms
 
 ```bash
@@ -204,10 +221,17 @@ rootr form new /intake/request --collect db \
 rootr form show /intake/request                       # read the questions before changing them
 rootr form set  /intake/request --fields '[...]'      # replaces the question set
 rootr form collect /intake/request --to sheet         # create and wire a destination
+rootr form mapping /intake/request                    # which column each question feeds
+rootr form mapping /intake/request --set '{"f_name":"p_title"}'
 rootr form responses /intake/request --latest         # --latest = newest one per person
 rootr form response-edit <responseId> --values '{"Email":"a@b.com"}'
 ```
 
+Run `form mapping` right after pointing a form at a hand-built table. Answers reach the
+table by matching the question name to the column name, so a question the table has no
+column for is **dropped with no error anywhere** — this command is the only place that
+says so, and `--set` pins the pairs by hand when the wording differs ("성함" vs "이름").
+
 `--fields` takes a JSON array as a **string**, not a file path.
 
 18 question types, including `text`, `email`, `phone`, `url`, `rating`, `scale`, `time`, `file`,
@@ -341,6 +365,22 @@ At 80% of the limit, MCP tool responses append a note with the remaining count.
 get a 429 with an upgrade link. The response headers carry the same information
 (`X-RateLimit-Remaining`, `X-RateLimit-Reset`, `X-RateLimit-Window`).
 
+#### First migration: a 72-hour grace period
+
+Moving your data in happens once, but it does not fit a daily cap — a 20,000-row
+table costs 42 calls to read through even in 500-row pages. So each workspace can
+lift the read limit **once, for 72 hours**.
+
+Turn it on in **Settings → Plan**, or with an admin key:
+
+```bash
+curl -X POST https://rootr.io/api/v1/workspaces/<workspace id>/billing/migration-grace \
+  -H "x-api-key: $ROOTR_API_KEY"
+```
+
+`GET` on the same path tells you when it started and when it ends. A second request
+is refused and says when the grace was used.
+
 ## MCP tools
 
 `rootr mcp` speaks MCP over stdio. 167 tools:

package/bin/rootr.js

@@ -35,6 +35,8 @@ const USAGE_KO = `Rootr CLI v${pkg.version}
   rootr db notify <path|id> [--file rules.json] [--clear]  표 알림 규칙 보기·저장
   rootr db buttons <path|id> [--file buttons.json] [--clear]  표 위 "누르면 일하는 버튼" 보기·저장
   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 row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
   rootr db row-body <path|id> <rowId> [--file <f>] 행의 상세 내용(본문 메모) 쓰기 — 없으면 표준입력
@@ -62,6 +64,7 @@ const USAGE_KO = `Rootr CLI v${pkg.version}
   rootr form show <path|id> [--json]               질문·설정 보기 (고치기 전에 먼저)
   rootr form set <path|id> --fields '<json>' | --config '<json>'  질문·설정 고치기 (설정은 준 칸만 바뀜)
   rootr form collect <path|id> --to db|sheet             응답 모을 곳을 새로 만들어 연결 (표는 질문 그대로 칸 생성)
+  rootr form mapping <path|id> [--set '<{"질문id":"칸id"}>']  질문이 표의 어느 칸으로 가는지 보기·정하기 (짝 없으면 값이 버려짐)
   rootr form responses <path|id> [--latest] [--json]  폼에 들어온 응답 보기 (--latest: 사람마다 최신 1건만)
   rootr form response-edit <응답id> --values '<json>'  이미 낸 응답 고치기 (폼 검사 규칙 다시 통과)
   rootr form response-rm <응답id> [--yes]           응답 한 건 삭제 (되돌릴 수 없음)
@@ -126,6 +129,8 @@ usage:
   rootr db notify <path|id> [--file rules.json] [--clear]  view/save notification rules
   rootr db buttons <path|id> [--file buttons.json] [--clear]  view/save buttons that do work when pressed
   rootr db button-run <path|id> <buttonId> [--rows id,id]     press a button once (create rows, fill values, AI fill)
+  rootr db automations <path|id> [--file rules.json] [--clear] automatic rules — "when a value becomes X, do Y", or at a set time
+  rootr db import-sheets <file.xlsx> --ws <id> [--dry]        fold a one-sheet-per-record workbook into ONE table
   rootr db view <path|id> [view name] [--scale week|month|year] [--name <new name>]  list views; calendar week/month/year
   rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  add a row (with its body)
   rootr db row-body <path|id> <rowId> [--file <f>] write a row's body — reads stdin if no file
@@ -908,6 +913,7 @@ async function cmdForm(args) {
   if (sub === 'show') return cmdFormShow(args);
   if (sub === 'set') return cmdFormSet(args);
   if (sub === 'collect') return cmdFormCollect(args);
+  if (sub === 'mapping') return cmdFormMapping(args);
   if (sub === 'responses') return cmdFormResponses(args);
   if (sub === 'response-edit') return cmdFormResponseEdit(args);
   if (sub === 'response-rm') return cmdFormResponseRm(args);
@@ -1067,6 +1073,64 @@ async function cmdFormCollect(args) {
   );
 }
 
+/**
+ * FORM-MAP — 질문이 표의 **어느 칸으로** 가는지 보고, 손으로 정한다.
+ *
+ * 폼 응답은 질문 이름과 칸 이름이 같아야 넘어간다. 다르면 **아무 경고 없이** 빠져서,
+ * "응답은 들어오는데 행이 안 생긴다"가 며칠씩 이어진다(2026-09-18 클린베테랑 신고 6번).
+ *
+ *   rootr form mapping <path|id>
+ *   rootr form mapping <path|id> --set '{"f_name":"p_title"}'
+ */
+async function cmdFormMapping(args) {
+  const target = args._[1];
+  if (!target) throw new Error(usage(`rootr form mapping <path|id> [--set '<{"질문id":"칸id"}>'] [--json]`));
+  const client = makeClient();
+  const id = await resolveNodeId(client, target);
+  let result;
+  if (args.set) {
+    let fieldMap;
+    try {
+      fieldMap = JSON.parse(args.set);
+    } catch {
+      throw new Error(tr('--set 은 {"질문id":"칸id"} 모양의 JSON이어야 합니다.', `--set must be JSON shaped like {"fieldId":"columnId"}.`));
+    }
+    result = await client.setFormMapping(id, fieldMap);
+  } else {
+    result = await client.formMapping(id);
+  }
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.targetDatabaseId) {
+    console.log(tr('이 폼은 표에 연결돼 있지 않습니다 — rootr form collect 로 먼저 연결하세요.', `This form is not linked to a table — link one with "rootr form collect" first.`));
+    return;
+  }
+  const HOW = {
+    manual: tr('손으로 정함', `set by hand`),
+    auto: tr('이름이 같아서', `matched by name`),
+    none: tr('✗ 짝 없음 — 값이 버려집니다', `✗ no column — this answer is dropped`),
+  };
+  for (const f of result.fields) {
+    console.log(`${f.label}  →  ${f.propertyName ?? '—'}   (${HOW[f.how] ?? f.how})`);
+  }
+  if (result.unmatched?.length) {
+    console.log('');
+    console.log(
+      tr(
+        `표로 안 넘어가는 질문 ${result.unmatched.length}개: ${result.unmatched.join(', ')}`,
+        `${result.unmatched.length} questions never reach the table: ${result.unmatched.join(', ')}`,
+      ),
+    );
+    console.log(tr('--set 으로 칸을 정해 주거나, 표에 같은 이름의 칸을 만드세요.', `Pin them with --set, or add columns with the same names to the table.`));
+  }
+  if (result.lastError) {
+    console.log('');
+    console.log(tr(`마지막 옮기기 실패: ${result.lastError.message}`, `Last mirror failure: ${result.lastError.message}`));
+  }
+}
+
 async function cmdFormResponses(args) {
   const target = args._[1];
   if (!target) throw new Error(usage(`rootr form responses <path|id> [--latest] [--json]`));
@@ -1169,10 +1233,149 @@ async function cmdDbRowsNew(args) {
   if (!rows.length) throw new Error(tr('넣을 행이 없습니다.', `No rows to insert.`));
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
-  const res = await client.bulkCreateRows(id, rows);
+  // BULK-UPSERT — 열쇠 칸을 주면 **다시 보내도 행이 두 벌이 안 된다**. 이관·동기화는
+  // 중간에 끊기고 재시도되기 마련이고, 그때 중복이 조용히 쌓이는 것이 가장 나쁘다
+  // (2026-09-18 클린베테랑: 재시도 한 번에 903건 중복).
+  const upsertKey = args['upsert-key'] ?? args.upsertKey;
+  const res = await client.bulkCreateRows(id, rows, upsertKey);
+  if (upsertKey) {
+    console.log(
+      tr(
+        `${res.created}개 행을 넣고 ${res.updated ?? 0}개는 이미 있어서 고쳤습니다(열쇠 칸: ${upsertKey}).`,
+        `${res.created} rows inserted, ${res.updated ?? 0} already existed and were updated (key column: ${upsertKey}).`,
+      ),
+    );
+    return;
+  }
   console.log(tr(`${res.created}개 행을 넣었습니다.`, `${res.created} rows inserted.`));
 }
 
+/**
+ * DB-AUTO — 표의 **자동 규칙**(값이 이렇게 되면 이 일을 해라).
+ *
+ *   rootr db automations <path|id>                지금 걸린 규칙 보기
+ *   rootr db automations <path|id> --file a.json  규칙 목록을 통째로 갈아끼우기
+ *   rootr db automations <path|id> --clear        규칙 전부 없애기
+ *
+ * 파일 모양(단계는 버튼과 같다):
+ * [{ "label":"투입확정 해피콜", "on":["updated"],
+ *    "when":{"property":"상태","op":"changed_to","value":"투입확정"},
+ *    "steps":[{"kind":"add_row","database":"/03. 투입·운영/해피콜",
+ *              "values":{"차수":"1차","예정일":"@today+7"},
+ *              "link":{"relation":"지원자","from":"selected"}}] }]
+ */
+async function cmdDbAutomations(args) {
+  const target = args._[1];
+  if (!target) throw new Error(usage(`rootr db automations <path|id> [--file rules.json] [--clear] [--json]`));
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+
+  if (args.clear) {
+    const cleared = await client.setDatabaseAutomations(id, []);
+    console.log(tr('자동 규칙을 모두 지웠습니다.', `All automatic rules cleared.`));
+    if (args.json) console.log(JSON.stringify(cleared, null, 2));
+    return;
+  }
+  if (args.file) {
+    let rules;
+    try {
+      rules = JSON.parse(readFileSync(args.file, 'utf8'));
+    } catch {
+      throw new Error(
+        tr(
+          '규칙 파일을 JSON으로 읽을 수 없습니다. [{ "label": "...", "when": {...}, "steps": [...] }] 형태여야 합니다.',
+          `Could not read the rules file as JSON. It must look like [{ "label": "...", "when": {...}, "steps": [...] }].`,
+        ),
+      );
+    }
+    if (!Array.isArray(rules)) {
+      throw new Error(tr('규칙 파일은 배열이어야 합니다(규칙 목록 전체).', `The rules file must be an array (the whole rule list).`));
+    }
+    const saved = await client.setDatabaseAutomations(id, rules);
+    console.log(tr(`자동 규칙 ${saved.automations.length}개를 저장했습니다.`, `Saved ${saved.automations.length} automatic rules.`));
+    if (args.json) console.log(JSON.stringify(saved, null, 2));
+    return;
+  }
+
+  const { automations } = await client.listDatabaseAutomations(id);
+  if (args.json) {
+    console.log(JSON.stringify(automations, null, 2));
+    return;
+  }
+  if (!automations.length) {
+    console.log(tr('자동 규칙이 없습니다.', `No automatic rules.`));
+    return;
+  }
+  const WHEN = {
+    created: tr('행이 생기면', `when a row is created`),
+    updated: tr('값이 바뀌면', `when a value changes`),
+    schedule: tr('정해진 시각에', `at a set time`),
+  };
+  for (const a of automations) {
+    const state = a.enabled === false ? tr(' (꺼짐)', ` (paused)`) : '';
+    console.log(`${a.label}${state}  (${a.id})`);
+    const when = (a.on ?? []).map((e) => WHEN[e] ?? e).join(', ');
+    const at = a.schedule ? ` ${a.schedule.at}` : '';
+    console.log(`  ${tr('언제', `when`)}: ${when}${at}`);
+    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}`);
+    }
+  }
+}
+
+/**
+ * XLSX-FOLD — 시트가 수백 장인 엑셀을 **표 하나로 접어** 가져온다.
+ *
+ *   rootr db import-sheets <파일.xlsx> --ws <id> --dry        먼저 써 보기(아무것도 안 만듦)
+ *   rootr db import-sheets <파일.xlsx> --ws <id> --name "사업장"
+ *   rootr db import-sheets <파일.xlsx> --ws <id> --db <표>    이미 있는 표에 넣기
+ */
+async function cmdDbImportSheets(args) {
+  const file = args._[1];
+  if (!file) throw new Error(usage(`rootr db import-sheets <파일.xlsx> --ws <workspaceId> [--dry] [--mode vertical|header] [--name "표 이름"] [--db <path|id>] [--upsert-key <칸>] [--skip "시트1,시트2"] [--header-row 2] [--sheet-column "사업장"]`));
+  const ws = args.ws ?? args.workspace;
+  if (!ws) throw new Error(tr('--ws 로 워크스페이스 id를 알려 주세요.', `Pass --ws with the workspace id.`));
+  const client = makeClient();
+  const body = {
+    xlsx: readFileSync(file).toString('base64'),
+    dryRun: Boolean(args.dry ?? args.dryRun),
+    ...(args.mode ? { mode: args.mode } : {}),
+    ...(args.name ? { name: args.name } : {}),
+    ...(args['sheet-column'] ? { sheetNameColumn: args['sheet-column'] } : {}),
+    ...(args.skip ? { skipSheets: String(args.skip).split(',').map((x) => x.trim()).filter(Boolean) } : {}),
+    ...(args['header-row'] ? { headerRow: Number(args['header-row']) } : {}),
+    ...(args['upsert-key'] ? { upsertKey: args['upsert-key'] } : {}),
+    ...(args.parent ? { parentId: args.parent } : {}),
+  };
+  if (args.db) body.databaseId = await resolveDatabaseId(client, args.db);
+  const res = await client.importFoldedSheets(ws, body);
+  if (args.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  const MODE = { vertical: tr('시트 한 장이 행 하나', `one sheet = one row`), header: tr('시트마다 같은 머리글', `same header in every sheet`) };
+  if (res.dryRun) {
+    console.log(tr(`써 보기 — 아무것도 만들지 않았습니다.`, `Dry run — nothing was created.`));
+    console.log(`${tr('읽은 모양', `detected shape`)}: ${MODE[res.mode] ?? res.mode} · ${tr('시트', `sheets`)} ${res.sheets} → ${tr('행', `rows`)} ${res.rowCount}`);
+    console.log(`${tr('칸', `columns`)}: ${res.columns.join(', ')}`);
+    for (const line of res.notes ?? []) console.log(`  · ${line}`);
+    console.log(tr('맞으면 --dry 를 빼고 다시 실행하세요.', `Run it again without --dry if that looks right.`));
+    return;
+  }
+  console.log(
+    tr(
+      `표에 ${res.created}행을 넣었습니다${res.updated ? ` (${res.updated}행은 고쳤습니다)` : ''}. ${res.url ?? res.databaseId}`,
+      `Inserted ${res.created} rows${res.updated ? ` (updated ${res.updated})` : ''}. ${res.url ?? res.databaseId}`,
+    ),
+  );
+  for (const line of res.notes ?? []) console.log(`  · ${line}`);
+  if (res.skippedColumns?.length) {
+    console.log(tr(`표에 없어서 버린 칸: ${res.skippedColumns.join(', ')}`, `Columns dropped (not in the table): ${res.skippedColumns.join(', ')}`));
+  }
+}
+
 /**
  * DB-BULK — `rootr db rows-each <표> --json '[{"rowId":"…","values":{…}},…]'`
  *
@@ -1500,10 +1703,12 @@ async function cmdDb(args) {
   if (sub === 'notify') return cmdDbNotify(args);
   if (sub === 'buttons') return cmdDbButtons(args);
   if (sub === 'button-run') return cmdDbButtonRun(args);
+  if (sub === 'automations') return cmdDbAutomations(args);
+  if (sub === 'import-sheets') return cmdDbImportSheets(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|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|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)`)),
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();

package/lib/client.js

@@ -511,6 +511,65 @@ export class RootrClient {
     );
   }
 
+  // ── DB-AUTO — "값이 이렇게 되면 이 일을 해라" 규칙 ───────────────────────
+  //
+  // 버튼과 같은 단계 문법을 쓰되 사람이 안 눌러도 돈다. 2026-09-18 클린베테랑 요청
+  // 4번: 투입 확정 시 해피콜 3건을 사람이 버튼으로 잡고 있었고, 안 누르면 빠졌다.
+
+  /** 이 표의 자동 규칙 목록. */
+  async listDatabaseAutomations(databaseId) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/automations`);
+  }
+
+  /** 자동 규칙을 **통째로** 갈아끼운다(MANAGE 필요). 남길 규칙도 같이 보내야 한다. */
+  async setDatabaseAutomations(databaseId, automations) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/automations`, {
+      method: 'PUT',
+      body: { automations },
+    });
+  }
+
+  // ── FORM-MAP — 폼 질문이 표의 어느 칸으로 가는가 ───────────────────────
+
+  /** 질문마다 어느 칸으로 들어가는지 + 짝 없는 질문(값이 버려진다). */
+  async formMapping(formId) {
+    return this.request(`/forms/${encodeURIComponent(formId)}/mapping`);
+  }
+
+  /** 질문↔칸 짝을 손으로 정한다. `{ 질문id: 칸id }`, 값이 null이면 자동으로 되돌린다. */
+  async setFormMapping(formId, fieldMap) {
+    return this.request(`/forms/${encodeURIComponent(formId)}/mapping`, {
+      method: 'PUT',
+      body: { fieldMap },
+    });
+  }
+
+  // ── XLSX-FOLD — 시트 복제형 엑셀을 표 하나로 접기 ──────────────────────
+
+  /**
+   * 시트가 수백 장인 엑셀을 표 한 개로 접어 가져온다(2026-09-18 요청 7번).
+   * `dryRun: true`면 아무것도 만들지 않고 어떻게 접히는지만 돌려준다.
+   */
+  async importFoldedSheets(workspaceId, body) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/databases/import/sheets`, {
+      method: 'POST',
+      body,
+    });
+  }
+
+  // ── MIGRATION-GRACE — 초기 이관 동안 하루 조회 한도 풀기 ────────────────
+
+  async startMigrationGrace(workspaceId) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/billing/migration-grace`, {
+      method: 'POST',
+      body: {},
+    });
+  }
+
+  async migrationGrace(workspaceId) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/billing/migration-grace`);
+  }
+
   // ── PUBLIC-DOCS — 발행한 문서에 올라온 변경 제안 ────────────────────────
 
   async listDocumentCommits(documentId, status = 'OPEN') {
@@ -927,10 +986,12 @@ export class RootrClient {
    * DB-BULK — 여러 행을 **한 번에 넣는다**. 전부 아니면 전무다.
    * 칸은 이름으로도 id로도 적을 수 있다.
    */
-  async bulkCreateRows(databaseId, rows) {
+  async bulkCreateRows(databaseId, rows, upsertKey) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/rows/bulk`, {
       method: 'POST',
-      body: { rows },
+      // BULK-UPSERT — 열쇠 칸을 주면 이미 있는 행은 고치고 없는 것만 만든다.
+      // 재시도가 안전해야 외부 시스템 동기화를 만들 수 있다(2026-09-18 요청 5번).
+      body: { rows, ...(upsertKey ? { upsertKey } : {}) },
     });
   }
 
@@ -1018,18 +1079,22 @@ export class RootrClient {
   // PATCH /databases/:id replaces the whole properties array, so rebuilding it
   // client-side drops any column left out. These merge server-side instead.
 
-  async addColumn(databaseId, { name, type, options, relationDatabaseId, formula, rollup, prefix } = {}) {
+  async addColumn(
+    databaseId,
+    { name, type, options, relationDatabaseId, reverseName, formula, rollup, prefix } = {},
+  ) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/columns`, {
       method: 'POST',
       // 계산 칸(수식·롤업·번호)은 설정이 곧 그 칸이라 같이 보내야 한다.
-      body: { name, type, options, relationDatabaseId, formula, rollup, prefix },
+      // reverseName 은 상대 표에 짝 칸을 만든다(양방향 관계).
+      body: { name, type, options, relationDatabaseId, reverseName, formula, rollup, prefix },
     });
   }
 
-  async updateColumn(databaseId, propertyId, { name, options } = {}) {
+  async updateColumn(databaseId, propertyId, { name, options, formula, rollup, prefix, reverseName } = {}) {
     return this.request(
       `/databases/${encodeURIComponent(databaseId)}/columns/${encodeURIComponent(propertyId)}`,
-      { method: 'PATCH', body: { name, options } },
+      { method: 'PATCH', body: { name, options, formula, rollup, prefix, reverseName } },
     );
   }
 

package/lib/mcp-tools/databases.js

@@ -198,9 +198,32 @@ export function registerDatabaseTools(server) {
                     'show_original',
                     'percent_checked',
                   ]),
+                  where: z
+                    .array(
+                      z.object({
+                        property: z.string(),
+                        op: z.enum([
+                          'is',
+                          'is_not',
+                          'contains',
+                          'not_contains',
+                          'is_empty',
+                          'is_not_empty',
+                          'gt',
+                          'gte',
+                          'lt',
+                          'lte',
+                        ]),
+                        value: z.string().optional(),
+                      }),
+                    )
+                    .optional()
+                    .describe(
+                      'Filter the LINKED rows before aggregating, e.g. [{ property: "결과", op: "is", value: "부재" }]',
+                    ),
                 })
                 .optional()
-                .describe('rollup only: what to gather through which relation'),
+                .describe('rollup only: what to gather through which relation (where? filters the linked rows first)'),
               prefix: z.string().optional().describe('unique_id only: e.g. "TASK" → "TASK-42"'),
             }),
           )
@@ -564,20 +587,32 @@ export function registerDatabaseTools(server) {
         'Add MANY rows to a Rootr (루터) DATABASE in one call. Use this instead of calling rootr_add_row in a ' +
         'loop — a loop leaves a half-filled table when one call fails, and burns the read quota. ' +
         'All-or-nothing: if any row fails validation nothing is created, and the error says which index broke. ' +
-        'Column keys may be property NAMES or ids. Up to 500 rows per call.',
+        'Column keys may be property NAMES or ids. Up to 500 rows per call.\n' +
+        'Pass `upsertKey` (a column name or id) to make the call IDEMPOTENT: a row whose key already exists is ' +
+        'UPDATED instead of duplicated, so a retried or replayed batch cannot double-load. Use it for every ' +
+        'migration and every sync from an outside system — without it a retry after a partial failure silently ' +
+        'creates duplicates (a real 903-row incident). The key column must be a plain stored column ' +
+        '(text/number/date/select), not a formula, rollup or relation. Returns `created` and `updated`.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
         rows: z
           .array(z.record(z.any()))
           .describe('Each entry is one row: { "칸 이름 또는 id": 값, … }'),
+        upsertKey: z
+          .string()
+          .optional()
+          .describe(
+            'Column (name or id) holding an external id. Rows whose key already exists are updated, not duplicated — ' +
+              'makes the call safe to retry.',
+          ),
       },
     },
-    async ({ databaseId, rows }) => {
+    async ({ databaseId, rows, upsertKey }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
-        return jsonResult(await client.bulkCreateRows(id, rows));
+        return jsonResult(await client.bulkCreateRows(id, rows, upsertKey));
       } catch (err) {
         return errorResult(err);
       }
@@ -813,10 +848,20 @@ export function registerDatabaseTools(server) {
         'relation | formula | rollup | created_time | last_edited_time | created_by | last_edited_by | unique_id ' +
         '("title" is not allowed: a database already has exactly one title column). ' +
         'For select/multi_select/status pass options: [{ name, color, group? }] (group ∈ todo|in_progress|done, status only). ' +
-        'For relation pass relationDatabaseId (the node id of the table it points at). ' +
+        'For relation pass relationDatabaseId (the node id of the table it points at), and reverseName to make it ' +
+        'TWO-WAY: the other table gets a matching column with that name, and filling either side fills the other. ' +
+        'Use it whenever both tables need the link (calls↔applicants) — a one-way column means aggregates on the ' +
+        'other side are silently wrong until someone backfills them by hand. ' +
         'For formula pass formula, e.g. "{수량} * {단가}" or "if({금액} >= 5000, \\"큰 건\\", \\"작은 건\\")" — ' +
         'available functions: if, concat, length, upper, lower, contains, abs, round, floor, ceil, min, max, dateBetween, now, empty. ' +
-        'For rollup pass rollup: { relation, property?, function } (function ∈ count|count_values|sum|average|min|max|show_original|percent_checked). ' +
+        'For rollup pass rollup: { relation, property?, function, where? } ' +
+        '(function ∈ count|count_values|sum|average|min|max|show_original|percent_checked). ' +
+        '`where` filters the LINKED rows before aggregating — [{ property, op, value? }] with ' +
+        'op ∈ is|is_not|contains|not_contains|is_empty|is_not_empty|gt|gte|lt|lte. That is how you build ' +
+        '"how many of this applicant\'s calls were no-answer": { relation: "콜", function: "count", ' +
+        'where: [{ property: "결과", op: "is", value: "부재" }] }. ' +
+        'A rollup may also read a FORMULA column in the linked table, and min/max work on date columns ' +
+        '(that is how "last call date" is built). ' +
         'For unique_id pass prefix to get "TASK-42" style ids. ' +
         'created_time / last_edited_time / created_by / last_edited_by / unique_id / formula / rollup are filled in by the server — ' +
         'they take no value and rootr_update_row will refuse to set them. ' +
@@ -857,6 +902,13 @@ export function registerDatabaseTools(server) {
           .string()
           .optional()
           .describe('relation only: the node id of the database this column points at'),
+        reverseName: z
+          .string()
+          .optional()
+          .describe(
+            'relation only: make it TWO-WAY — the linked table gets a matching column with this name, and filling ' +
+              'one side fills the other. Needs write access to that table too.',
+          ),
         formula: z
           .string()
           .optional()
@@ -875,6 +927,29 @@ export function registerDatabaseTools(server) {
               'show_original',
               'percent_checked',
             ]),
+            where: z
+              .array(
+                z.object({
+                  property: z.string(),
+                  op: z.enum([
+                    'is',
+                    'is_not',
+                    'contains',
+                    'not_contains',
+                    'is_empty',
+                    'is_not_empty',
+                    'gt',
+                    'gte',
+                    'lt',
+                    'lte',
+                  ]),
+                  value: z.string().optional(),
+                }),
+              )
+              .optional()
+              .describe(
+                'Filter the LINKED rows before aggregating, e.g. [{ property: "결과", op: "is", value: "부재" }]',
+              ),
           })
           .optional()
           .describe('rollup only: what to gather through which relation'),
@@ -906,9 +981,14 @@ export function registerDatabaseTools(server) {
     {
       title: 'Rename a column / set its options',
       description:
-        'Rename ONE column of a Rootr (루터) DATABASE, and/or replace the choices of a select/multi_select column. ' +
+        'Rename ONE column of a Rootr (루터) DATABASE, replace the choices of a select/multi_select column, edit a ' +
+        'formula or rollup config, or turn an existing relation column TWO-WAY. ' +
         'The column TYPE cannot be changed — that would rewrite every row — so add a new column and move the values instead. ' +
-        'Call rootr_read_database first to get the exact propertyId.',
+        'Call rootr_read_database first to get the exact propertyId.\n' +
+        '`reverseName` on a relation column pairs it with the linked table: that table gets a matching column with ' +
+        'this name and filling either side fills the other. Pass an empty string to unpair (neither column is deleted). ' +
+        'Use it to make an existing one-way link two-way rather than rebuilding the table — a one-way column leaves ' +
+        'every aggregate on the other side wrong until somebody backfills it by hand.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
@@ -918,13 +998,30 @@ export function registerDatabaseTools(server) {
           .array(z.object({ name: z.string(), color: z.string() }))
           .optional()
           .describe('select/multi_select only: REPLACES the full choice list'),
+        formula: z.string().optional().describe('formula only: the new expression'),
+        rollup: z
+          .record(z.any())
+          .optional()
+          .describe('rollup only: { relation, property?, function, where? } — replaces the whole config'),
+        prefix: z.string().optional().describe('unique_id only: the new prefix'),
+        reverseName: z
+          .string()
+          .optional()
+          .describe('relation only: pair it two-way under this name in the linked table; "" unpairs'),
       },
     },
-    async ({ databaseId, propertyId, name, options }) => {
+    async ({ databaseId, propertyId, name, options, formula, rollup, prefix, reverseName }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
-        const property = await client.updateColumn(id, propertyId, { name, options });
+        const property = await client.updateColumn(id, propertyId, {
+          name,
+          options,
+          formula,
+          rollup,
+          prefix,
+          reverseName,
+        });
         return jsonResult({ property });
       } catch (err) {
         return errorResult(err);
@@ -1123,14 +1220,20 @@ export function registerDatabaseTools(server) {
         'dropped. Up to 12 buttons, 8 steps each.\n' +
         'Steps run in order and the row a step created is what the NEXT step works on, which is how ' +
         '"add a row → have AI write its summary → open it" becomes one press:\n' +
-        '· {kind:"add_row", values?} — make a row, optionally pre-filled. Column keys may be NAMES or ids.\n' +
+        '· {kind:"add_row", values?, database?, link?} — make a row, optionally pre-filled. Column keys may be ' +
+        'NAMES or ids. `database` (a table id or tree path like "/01. 채용/콜 이력") puts the row in ANOTHER ' +
+        'table — omit it for this one. `link: { relation, from: "selected"|"created" }` wires the new row to the ' +
+        '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' +
         '· {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' +
-        'A button never grants permission: it runs as whoever presses it.',
+        '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 },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
@@ -1168,7 +1271,8 @@ export function registerDatabaseTools(server) {
         'Pass `rowIds` only when a step targets "selected" — that is the set of rows the person would have ' +
         'ticked in the table; without it such a step reaches no rows and the server says so. ' +
         '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, and — if the AI could not write a cell — `aiFailed` ' +
+        '`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). ' +
         'It runs with YOUR permissions: a button that writes a locked column stops there if you cannot edit it.',
       annotations: { readOnlyHint: false, destructiveHint: false },
@@ -1191,4 +1295,149 @@ export function registerDatabaseTools(server) {
       }
     },
   );
+
+  // ---- DB-AUTO: "값이 이렇게 되면 이 일을 해라" ----------------------------
+  // 2026-09-18 클린베테랑 요청 4번. 버튼과 같은 단계 문법을 쓰되 사람이 안 눌러도 돈다.
+
+  server.registerTool(
+    'rootr_list_database_automations',
+    {
+      title: 'List the automatic rules on a database',
+      description:
+        'Show the automatic rules of a Rootr (루터) DATABASE — "when a value becomes X, do Y". Call this before ' +
+        'rootr_set_database_automations, which replaces the whole list.',
+      annotations: { readOnlyHint: true },
+      inputSchema: { databaseId: z.string().describe(DATABASE_TARGET_DESC) },
+    },
+    async ({ databaseId }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.listDatabaseAutomations(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_database_automations',
+    {
+      title: 'Create or edit the automatic rules on a database',
+      description:
+        'Replace the WHOLE automatic-rule list of a Rootr (루터) DATABASE (needs MANAGE). Full replace, not a ' +
+        'merge — send back the rules you want to KEEP. Up to 10 rules, 8 steps each.\n' +
+        'A rule is { label, enabled?, on, when?, schedule?, steps } and the steps are the SAME ones a button ' +
+        'uses (add_row / update_rows / ai_fill), so there is nothing new to learn. The row that woke the rule ' +
+        'arrives in the steps as target "selected".\n' +
+        '· on: ["updated"] | ["created"] | ["schedule"] (one or more).\n' +
+        '· when: { property, op, value? } — op ∈ changed_to|changed|is|is_not|contains|gt|gte|lt|lte|is_empty|is_not_empty. ' +
+        'Prefer `changed_to` for state transitions: "is" is true on EVERY later edit too, so a rule that creates ' +
+        'follow-up rows would create them again and again.\n' +
+        '· schedule: { at: "09:00", days?: [1,2,3,4,5] } — required when on includes "schedule". Korean time, ' +
+        'once a day; `when` then picks WHICH rows to act on and may use @today / @today+7 in its value.\n' +
+        'Typical uses from the field: 투입확정 → create three follow-up-call rows at +7/+30/+90 days; ' +
+        '부재 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.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        automations: z
+          .array(
+            z.object({
+              id: z.string().optional().describe('Keep an existing rule by passing its id; omit to create one'),
+              label: z.string().describe('What this rule is for, e.g. "투입확정 해피콜 3건"'),
+              enabled: z.boolean().optional().describe('false pauses it without deleting it'),
+              on: z
+                .array(z.enum(['created', 'updated', 'schedule']))
+                .optional()
+                .describe('When it wakes up. Defaults to ["updated"].'),
+              when: z
+                .object({
+                  property: z.string().describe('Column to watch (name or id)'),
+                  op: z.enum([
+                    'changed_to',
+                    'changed',
+                    'is',
+                    'is_not',
+                    'contains',
+                    'gt',
+                    'gte',
+                    'lt',
+                    'lte',
+                    'is_empty',
+                    'is_not_empty',
+                  ]),
+                  value: z.string().optional(),
+                })
+                .optional()
+                .describe('Omit to run on every matching event'),
+              schedule: z
+                .object({
+                  at: z.string().describe('"HH:MM", Korean time'),
+                  days: z.array(z.number()).optional().describe('0=Sun … 6=Sat; omit for every day'),
+                })
+                .optional(),
+              steps: z
+                .array(z.record(z.any()))
+                .describe('Ordered steps — same syntax as a button (max 8; "open_row" is not allowed here)'),
+            }),
+          )
+          .describe('The COMPLETE rule list for this table. [] removes every rule.'),
+      },
+    },
+    async ({ databaseId, automations }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.setDatabaseAutomations(id, automations));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  // ---- XLSX-FOLD: 시트 복제형 엑셀을 표 하나로 --------------------------
+
+  server.registerTool(
+    'rootr_import_folded_sheets',
+    {
+      title: 'Import a sheet-per-record Excel file as ONE table',
+      description:
+        'Fold a workbook that keeps ONE SHEET PER RECORD (783 sheets, one per site; 1,281, one per interview) ' +
+        'into a single Rootr (루터) DATABASE. Very common in small-company Excel, and until now it needed a ' +
+        'hand-written parser.\n' +
+        '· mode "vertical" — one sheet IS one row: label in the left cell, value to its right. Sheet name is kept ' +
+        'as a column.\n' +
+        '· mode "header" — every sheet repeats the same header row; all their data rows are merged and the sheet ' +
+        'name becomes a column (that is the month, or the branch).\n' +
+        'Omit mode and the server works it out from the file. ALWAYS call with dryRun:true first and show the ' +
+        'person the detected mode, columns and the first rows — folding 783 sheets the wrong way is far more ' +
+        'expensive to undo than to check. Pass upsertKey to make re-imports idempotent.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        workspaceId: z.string().describe('Workspace id'),
+        xlsx: z.string().describe('The .xlsx file, base64-encoded'),
+        dryRun: z.boolean().optional().describe('true = show what would happen, create nothing'),
+        mode: z.enum(['vertical', 'header']).optional(),
+        sheetNameColumn: z.string().optional().describe('Column name for the sheet name'),
+        skipSheets: z.array(z.string()).optional().describe('Sheet names to ignore (템플릿·설명 sheets)'),
+        headerRow: z.number().optional().describe('header mode: which row holds the headers (1-based)'),
+        name: z.string().optional().describe('Name for the new table'),
+        parentId: z.string().optional().describe('Folder to create it under'),
+        databaseId: z.string().optional().describe('Load into an EXISTING table instead of creating one'),
+        upsertKey: z.string().optional().describe('Column holding an external id, so re-imports update instead of duplicate'),
+      },
+    },
+    async ({ workspaceId, ...rest }) => {
+      try {
+        const client = makeClient();
+        return jsonResult(await client.importFoldedSheets(workspaceId, rest));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }

package/lib/mcp-tools/forms.js

@@ -355,4 +355,64 @@ export function registerFormTools(server) {
       }
     },
   );
+
+  // ---- FORM-MAP: 질문이 표의 어느 칸으로 들어가는가 ---------------------
+  // 2026-09-18 클린베테랑 요청 6번: 질문 이름과 칸 이름이 다르면 값이 조용히 빠졌고,
+  // 폼 10개 전부가 그래서 "응답은 들어오는데 행이 안 생기는" 상태였다.
+
+  server.registerTool(
+    'rootr_form_mapping',
+    {
+      title: 'Show which table column each form question feeds',
+      description:
+        'For a Rootr (루터) FORM linked to a DATABASE, show question → column for every question, and — the ' +
+        'point of this tool — `unmatched`: the questions with NO column, whose answers are silently dropped ' +
+        'when someone submits. Check this right after linking a form to a table or renaming anything: a ' +
+        'mismatch produces no error anywhere, and the loss is usually found weeks later. ' +
+        '`how` is "manual" (someone chose it), "auto" (names matched) or "none" (dropped). ' +
+        '`lastError` carries why the most recent submission failed to reach the table, if it did.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        formId: z.string().describe(`FORM node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ formId }) => {
+      try {
+        const client = makeClient();
+        formId = await resolveNodeId(client, formId);
+        return jsonResult(await client.formMapping(formId));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_form_mapping',
+    {
+      title: 'Wire form questions to table columns by hand',
+      description:
+        'Pin which DATABASE column each question of a Rootr (루터) FORM writes into: { "<fieldId>": "<columnId>" }. ' +
+        'Questions you leave out keep matching BY NAME, and passing null for one puts it back to automatic. ' +
+        'Use this whenever the question wording differs from the column header ("성함" vs "이름") — otherwise ' +
+        'that answer is dropped with no warning. Call rootr_form_mapping first for the ids and the current state. ' +
+        'A field or column that does not exist is refused, not ignored.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        formId: z.string().describe(`FORM node id${NODE_TARGET_HINT}`),
+        fieldMap: z
+          .record(z.string().nullable())
+          .describe('{ "<질문 id>": "<칸 id>" } — null puts that question back to name matching'),
+      },
+    },
+    async ({ formId, fieldMap }) => {
+      try {
+        const client = makeClient();
+        formId = await resolveNodeId(client, formId);
+        return jsonResult(await client.setFormMapping(formId, fieldMap));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.17.3",
+  "version": "0.18.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": {