rootr-cli 0.20.0 → 0.23.3

package/lib/client.js

@@ -757,6 +757,16 @@ export class RootrClient {
    * 이름을 그대로 다시 적게 하는 것은 서버가 요구하는 안전장치다 — 지울 것을
    * 정말 보고 있는지 확인한다.
    */
+  /**
+   * WS-EMBLEM — set (attachment id) or clear (null) the workspace emblem shown in the
+   * sidebar badge and workspace switcher. The server only accepts the relative raw path
+   * of an image attachment already uploaded to this same workspace.
+   */
+  async setWorkspaceEmblem(workspaceId, attachmentId) {
+    const iconUrl = attachmentId ? `/api/v1/attachments/${encodeURIComponent(attachmentId)}/raw` : null;
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}`, { method: 'PATCH', body: { iconUrl } });
+  }
+
   async deleteWorkspace({ workspaceId, confirmName }) {
     return this.request(`/workspaces/${workspaceId}`, {
       method: 'DELETE',
@@ -1221,13 +1231,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/attachments.js

@@ -82,7 +82,10 @@ export function registerAttachmentTools(server) {
         '`markdown` is ready to paste into a document body (![alt](url)). For the common case of inserting an ' +
         'image straight into a document, prefer rootr_attach_image_to_document instead. For a large file (or ' +
         'over the remote connector, where filePath is not available), use rootr_create_upload_url → PUT → ' +
-        'rootr_complete_upload instead of inlining the bytes as base64Data.',
+        'rootr_complete_upload instead of inlining the bytes as base64Data. ' +
+        'Video files (mp4/webm/mov, up to 75MB) are allowed; to put one on a slide, upload it with nodeId = the deck and add it to the slide\'s ' +
+        '`videos[]` (Team plan and above for decks). Videos play via signed URLs (`vt=`) that the server adds when it returns the slide — a bare /raw link ' +
+        'opened from another website is blocked.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: uploadInputSchema,
     },
@@ -154,6 +157,60 @@ export function registerAttachmentTools(server) {
     },
   );
 
+  // 엠블럼은 워크스페이스에 붙는 것이라 노드 칸(nodeId)은 받지 않는다.
+  const { nodeId: _unusedNodeId, ...emblemUploadSchema } = uploadInputSchema;
+  // WS-EMBLEM — 화면(설정 → 일반 → 엠블럼)에서만 되던 일을 에이전트도 하게. 새 파일을 주면
+  // 올린 뒤 걸고, 이미 올린 첨부 id 를 주면 그것을 걸고, clear 면 이름 첫 글자 배지로 되돌린다.
+  server.registerTool(
+    'rootr_set_workspace_emblem',
+    {
+      title: 'Set or clear the workspace emblem (logo)',
+      description:
+        'Set the Rootr (루터) workspace emblem — the small square logo shown in the sidebar badge and the ' +
+        'workspace switcher for every member. Give ONE of: an image file (filePath or base64Data, with filename ' +
+        '+ mimeType — it is uploaded to this workspace first), `attachmentId` of an image already uploaded to ' +
+        'this workspace (e.g. from rootr_upload_attachment / rootr_complete_upload), or `clear: true` to go back ' +
+        'to the default initial-letter badge. Requires ADMIN on the workspace. A square PNG/SVG/WebP of 256px+ ' +
+        'looks best; it is shown cropped to a rounded square.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        ...emblemUploadSchema,
+        filename: emblemUploadSchema.filename.optional(),
+        mimeType: emblemUploadSchema.mimeType.optional(),
+        attachmentId: z.string().optional().describe('Id of an image attachment already in this workspace'),
+        clear: z.boolean().optional().describe('true = remove the emblem (back to the initial-letter badge)'),
+      },
+    },
+    async ({ filename, mimeType, filePath, base64Data, attachmentId, clear, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        const given = [Boolean(filePath || base64Data), Boolean(attachmentId), Boolean(clear)].filter(Boolean).length;
+        if (given !== 1) {
+          throw new RootrApiError('파일(filePath/base64Data), attachmentId, clear 중 하나만 주세요.');
+        }
+        let id = null;
+        if (attachmentId) {
+          if (!ATTACHMENT_ID.test(attachmentId)) throw new RootrApiError(`첨부 id 모양이 아닙니다: ${attachmentId}`);
+          id = attachmentId;
+        } else if (!clear) {
+          if (!filename || !mimeType) throw new RootrApiError('파일을 올릴 때는 filename 과 mimeType 이 필요합니다.');
+          if (!mimeType.startsWith('image/')) throw new RootrApiError('엠블럼은 이미지(image/*)만 됩니다.');
+          const data = readAttachmentBytes({ filePath, base64Data });
+          ({ id } = await client.uploadAttachment(ws, { filename, mimeType, data }));
+        }
+        const updated = await client.setWorkspaceEmblem(ws, id);
+        return jsonResult({
+          workspaceId: ws,
+          iconUrl: updated?.iconUrl ?? null,
+          emblemUrl: id ? client.attachmentRawUrl(id) : null,
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   // ISSUE-222 — rootr_upload_attachment/rootr_attach_image_to_document require
   // the full file as base64Data over the remote connector (it can't read
   // filePath), which breaks down for larger images. This gives the caller a

package/lib/mcp-tools/booking.js

@@ -119,7 +119,18 @@ export function registerBookingTools(server) {
           .number()
           .optional()
           .describe('Length of one booking in minutes: 15, 20, 30, 45, 60, 90, 120, 180 or 240.'),
-        bufferMin: z.number().optional().describe('Gap kept before AND after each booking, in minutes.'),
+        bufferMin: z
+          .number()
+          .optional()
+          .describe('Gap kept before AND after each booking made through this table, in minutes (0-240).'),
+        calendarBufferMin: z
+          .number()
+          .optional()
+          .describe(
+            'Gap kept before AND after every event already on the connected Google Calendar (travel time etc.), in minutes (0-240). ' +
+              'Separate from bufferMin: e.g. 60 here and 0 in bufferMin blocks an hour around outside meetings while online bookings may sit back to back. ' +
+              'Bookings this table wrote to Google are not "existing events" — they get bufferMin. If never set, it follows bufferMin.',
+          ),
         minNoticeHours: z.number().optional().describe('No bookings closer than this many hours from now.'),
         maxDaysAhead: z.number().optional().describe('How far ahead visitors may book, in days.'),
         maxPerDay: z.number().optional().describe('Max bookings per day. 0 = unlimited.'),
@@ -209,6 +220,15 @@ export function registerBookingTools(server) {
           .optional()
           .describe('Let the visitor add other email addresses. Guests get the same emails and the same calendar invite.'),
         maxGuests: z.number().int().optional().describe('How many guests a visitor may add (default 5). 0 turns it off.'),
+        trackSource: z
+          .boolean()
+          .optional()
+          .describe(
+            'Record where each booking came from. Adds a text column ("유입 경로" unless you pass sourceLabel) and fills it ' +
+              'from the address the visitor arrived on, e.g. "source=meta, medium=paid, campaign=ax, content=3-docs" ' +
+              '(utm_* first, else the ad click id, else the referring site). Left empty when nothing is known.',
+          ),
+        sourceLabel: z.string().optional().describe('Name for the column trackSource creates (default "유입 경로").'),
         redirectUrl: z
           .string()
           .optional()

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.';