rootr-cli 0.17.3 → 0.19.0

package/lib/mcp-tools/databases.js

@@ -128,10 +128,11 @@ export function registerDatabaseTools(server) {
         'column order, so one call keeps the columns in exactly the order you list them. ' +
         'The FIRST property must be type "title" (the row label). Other types: text | number | select | multi_select | ' +
         'status | date | checkbox | url | email | phone | person | files | relation | formula | rollup | ' +
-        'created_time | last_edited_time | created_by | last_edited_by | unique_id. ' +
+        'created_time | last_edited_time | created_by | last_edited_by | unique_id | vector. ' +
         'select/multi_select/status take options:[{name,color,group?}] (group ∈ todo|in_progress|done, status only); ' +
         'relation takes relationDatabaseId; formula takes formula ("{수량} * {단가}"); rollup takes ' +
-        'rollup:{relation,property?,function}; unique_id takes prefix ("TASK" → "TASK-42"). The last seven types are ' +
+        'rollup:{relation,property?,function}; unique_id takes prefix ("TASK" → "TASK-42"); vector takes dimensions ' +
+        '(the length of the embeddings you will store with rootr_set_row_vectors). The last seven types are ' +
         'filled in by the server and take no row value. ' +
         'Views default to a single table view; view types are table | board | gallery | calendar | timeline | list — ' +
         'a "board" view needs config.groupBy (a select/status property id), a "timeline"/"calendar" view needs ' +
@@ -176,8 +177,14 @@ export function registerDatabaseTools(server) {
                   'created_by',
                   'last_edited_by',
                   'unique_id',
+                  'vector',
                 ])
                 .describe('Column type; the FIRST property must be "title"'),
+              dimensions: z
+                .number()
+                .int()
+                .optional()
+                .describe('vector only: the length of every vector you will store, e.g. 1536 or 3072'),
               options: z
                 .array(z.object({ name: z.string(), color: z.string(), group: z.string().optional() }))
                 .optional()
@@ -198,9 +205,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"'),
             }),
           )
@@ -443,7 +473,13 @@ export function registerDatabaseTools(server) {
           client.getDatabase(id),
           client.listRows(id, { withBody: includeBody === true }),
         ]);
-        return jsonResult({ database, rows });
+        // 감사 ROUND-17 #9 — 좁혀진 롤업(상대 표가 "본인 행만"이거나 못 여는 표)은 값이 전체 합계가 아니다 — 모델이 전체로 옮겨 적지 않게 적는다
+        const narrowed = Array.isArray(database?.narrowedRollups) ? database.narrowedRollups : [];
+        const nameOf = new Map((database?.properties ?? []).map((p) => [p.id, p.name]));
+        const note = narrowed.length
+          ? `Rollup column(s) ${narrowed.map((id) => `"${nameOf.get(id) ?? id}"`).join(', ')} only count rows you can see (the linked table is "own rows only" or not readable) — not full totals.`
+          : undefined;
+        return jsonResult(note ? { database, rows, narrowedRollupsNote: note } : { database, rows });
       } catch (err) {
         return errorResult(err);
       }
@@ -564,20 +600,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,11 +861,23 @@ 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. ' +
+        'For vector pass dimensions — an embedding column YOU fill with rootr_set_row_vectors and search with ' +
+        'rootr_query_vectors (Rootr never embeds it for you; people see only "vector · N dims" in the grid). ' +
         '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. ' +
         'Returns the created column WITH ITS id.',
@@ -847,8 +907,9 @@ export function registerDatabaseTools(server) {
             'created_by',
             'last_edited_by',
             'unique_id',
+            'vector',
           ])
-          .describe('Column type'),
+          .describe('Column type ("vector" = an embedding column for agents — pass dimensions)'),
         options: z
           .array(z.object({ name: z.string(), color: z.string(), group: z.string().optional() }))
           .optional()
@@ -857,6 +918,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,13 +943,52 @@ 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'),
         prefix: z.string().optional().describe('unique_id only: prefix for the number, e.g. "TASK" → "TASK-42"'),
+        dimensions: z
+          .number()
+          .int()
+          .min(1)
+          .max(4096)
+          .optional()
+          .describe('vector only: the length of every vector you will store, e.g. 1536 or 3072'),
+        searchExcluded: z
+          .boolean()
+          .optional()
+          .describe(
+            'Exclude this column from the search index: its values never go into the index behind rootr_ask, AI explore ' +
+              'and rootr_find_similar_rows (people still see them in the table). It is NOT a read permission — the in-app ' +
+              '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.',
+          ),
       },
     },
-    async ({ databaseId, name, type, options, relationDatabaseId, formula, rollup, prefix }) => {
+    async ({ databaseId, name, type, options, relationDatabaseId, formula, rollup, prefix, searchExcluded, dimensions }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
@@ -893,6 +1000,8 @@ export function registerDatabaseTools(server) {
           formula,
           rollup,
           prefix,
+          searchExcluded,
+          dimensions,
         });
         return jsonResult({ property });
       } catch (err) {
@@ -906,9 +1015,16 @@ 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. ' +
-        '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.',
+        'Rename ONE column of a Rootr (루터) DATABASE, replace the choices of a select/multi_select column, edit a ' +
+        'formula or rollup config, turn an existing relation column TWO-WAY, or exclude it from the search index ' +
+        '(searchExcluded: true — managers only; values already indexed are removed before this returns). ' +
+        'The column TYPE and a vector column\'s dimensions cannot be changed — that would rewrite every row (or every stored vector) — ' +
+        'so passing type or dimensions is refused; add a new column and move the values instead. ' +
+        '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 +1034,51 @@ 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'),
+        type: z.string().optional().describe('Not changeable — passing it is refused with the reason'),
+        dimensions: z.number().optional().describe('Not changeable (vector only) — passing it is refused with the reason'),
+        reverseName: z
+          .string()
+          .optional()
+          .describe('relation only: pair it two-way under this name in the linked table; "" unpairs'),
+        searchExcluded: z
+          .boolean()
+          .optional()
+          .describe(
+            'Exclude this column from the search index: its values never go into the index behind rootr_ask, AI explore ' +
+              'and rootr_find_similar_rows (people still see them in the table). It is NOT a read permission — the in-app ' +
+              '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.',
+          ),
       },
     },
-    async ({ databaseId, propertyId, name, options }) => {
+    async ({ databaseId, propertyId, name, options, formula, rollup, prefix, reverseName, searchExcluded, type, dimensions }) => {
+      // 조용히 무시하지 않는다 — 못 바꾸는 것을 넘기면 까닭과 할 일을 말한다(벡터 차원을 바꾸면 저장된 벡터가 전부 틀려진다).
+      if (type !== undefined || dimensions !== undefined) {
+        return errorResult(
+          new Error(
+            '칸 종류(type)와 벡터 차원(dimensions)은 바꿀 수 없습니다. 새 칸을 만들고 값을 옮겨 주세요.' +
+              '\n힌트: 벡터 칸을 다른 차원으로 쓰려면 rootr_add_column(type "vector", dimensions 지정)으로 새 칸을 만든 뒤 벡터를 다시 넣으세요.',
+          ),
+        );
+      }
       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,
+          searchExcluded,
+        });
         return jsonResult({ property });
       } catch (err) {
         return errorResult(err);
@@ -1064,7 +1218,10 @@ export function registerDatabaseTools(server) {
       description:
         'Remove ONE column from a Rootr (루터) DATABASE. The values stored under it are NOT erased from the rows, ' +
         'so re-adding a column is not enough to bring them back in the UI — confirm with the user before calling this. ' +
-        'The title column cannot be deleted. Views grouped/dated by the column are cleared automatically.',
+        'Exception: values of a vector column are erased (see below). ' +
+        'The title column cannot be deleted. Views grouped/dated by the column are cleared automatically. ' +
+        'For a vector column the stored vectors are deleted with it (not kept for re-adding — re-add the column and ' +
+        'store the vectors again with rootr_set_row_vectors).',
       annotations: { readOnlyHint: false, destructiveHint: true },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
@@ -1123,14 +1280,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 +1331,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 +1355,310 @@ 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);
+      }
+    },
+  );
+
+  // ── DB-SEARCH — vector similarity search across rows ──────────────
+
+  server.registerTool(
+    'rootr_find_similar_rows',
+    {
+      title: 'Find semantically similar rows',
+      description:
+        'Find rows in a DATABASE that are semantically similar to a given row (duplicate reports, ' +
+        'a past answer to a similar inquiry, a similar experiment). Uses vector embeddings of the ' +
+        'row\'s columns — no keyword matching. Columns marked "exclude from search index" (searchExcluded) are never ' +
+        'indexed, and on an "own rows only" table you only get your own rows. Only rows that stand out from the ' +
+        'rest of the table are returned (the raw cosine of unrelated rows in one table is often 0.8+, so a fixed ' +
+        'cut-off lies): each row carries `similarityLevel` ("high" | "mid") and the raw `similarityScore`. ' +
+        'An empty list with `compared` > 0 means "nothing is especially similar", not an error. ' +
+        '`state`: "ready", "indexing" (the row, or `pending` other rows of the table, are not indexed yet — the rows found so far are returned; retry in a few seconds), "no-text" (the row has ' +
+        'nothing to compare — it is empty or only its excluded columns are filled; retrying will not help) or ' +
+        '"sync-off" (graph sync is turned off — `syncOffAt` says where to turn it back on: "node" = this table\'s menu, ' +
+        '"folder" = the parent folder named in `syncOffFolder`, "workspace" = workspace settings › General).',
+      annotations: { title: 'Find similar rows', readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().describe('The row whose similar counterparts you want to find'),
+        topK: z.number().int().min(1).max(20).optional().default(5)
+          .describe('How many similar rows to return (default 5, max 20)'),
+      },
+    },
+    async ({ databaseId, rowId, topK }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        const qs = `rowId=${encodeURIComponent(rowId)}&topK=${topK ?? 5}`;
+        const result = await client.request(`/databases/${encodeURIComponent(id)}/rows/similar?${qs}`);
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  // ── DB-VECTOR(기획 5단계) — 에이전트용 벡터 칸: 직접 넣고 직접 찾는다 ───────────
+  //
+  // 루터 표가 에이전트의 벡터 저장소가 된다. 행과 같은 권한을 탄다(본인 행만 표에서는 남의 행을 못 넣고 못 찾는다).
+
+  server.registerTool(
+    'rootr_set_row_vectors',
+    {
+      title: 'Store vectors in a vector column',
+      description:
+        'Store YOUR OWN embeddings in a "vector" column of a Rootr (루터) DATABASE — up to 500 { rowId, vector } per ' +
+        'call; sending a row again replaces its vector. Every vector must have exactly the column\'s `dimensions` ' +
+        '(create the column with rootr_add_column type "vector" + dimensions). Rootr does not embed anything here and ' +
+        'charges no AI credits. Rows you may not edit (own-rows-only tables, manager-locked column) are refused ' +
+        'with the reason — nothing is written if any item is invalid. To check which rows already hold a vector, read the ' +
+        'rows (rootr_list_rows / rootr_read_database: each row has `vectors` — column id → dimensions, empty when none). ' +
+        'To read one row\'s vector use rootr_get_row_vector; to remove it use rootr_delete_row_vector.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        column: z.string().describe('The vector column — its id or header name'),
+        items: z
+          .array(z.object({ rowId: z.string(), vector: z.array(z.number()) }))
+          .min(1)
+          .max(500)
+          .describe('[{ rowId, vector: [..numbers..] }]'),
+      },
+    },
+    async ({ databaseId, column, items }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.putVectors(id, column, items));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_query_vectors',
+    {
+      title: 'Nearest rows by vector',
+      description:
+        'Find the rows of a DATABASE whose stored vector (in a "vector" column) is closest to the vector you pass — ' +
+        'cosine similarity, highest first, with each row\'s values and `score`. Use it as a vector store: embed your ' +
+        'query with the same model you used for rootr_set_row_vectors. `minScore` drops weak matches. Rows the caller ' +
+        'cannot see (own-rows-only tables) are never returned. Rows without a stored vector are skipped. ' +
+        'The column can hold at most 50,000 vectors — a bigger column is refused, not searched partially — and the scan has ' +
+        'no index, so latency grows with the number of rows in the column.',
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        column: z.string().describe('The vector column — its id or header name'),
+        vector: z.array(z.number()).describe('Query vector — same length as the column\'s dimensions'),
+        topK: z.number().int().min(1).max(100).optional().default(10).describe('How many rows (default 10, max 100)'),
+        minScore: z.number().min(-1).max(1).optional().describe('Only rows with cosine ≥ this'),
+      },
+    },
+    async ({ databaseId, column, vector, topK, minScore }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.queryVectors(id, column, { vector, topK, minScore }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_get_row_vector',
+    {
+      title: 'Read one row\'s stored vector',
+      description:
+        'Read the vector stored for ONE row in a "vector" column. Returns { rowId, propId, dimensions, vector }; ' +
+        '`vector` is null when the row has no vector yet — so this is also the check "does this row hold a vector". ' +
+        'Rows you cannot see (own-rows-only tables) are refused.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().describe('Row id from rootr_list_rows / rootr_read_database'),
+        column: z.string().describe('The vector column — its id or header name'),
+      },
+    },
+    async ({ databaseId, rowId, column }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.getRowVector(id, rowId, column));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_delete_row_vector',
+    {
+      title: 'Remove one row\'s stored vector',
+      description:
+        'Remove the vector stored for ONE row in a "vector" column. The row itself and its other values stay. ' +
+        'The vector is gone for queries from then on (rootr_query_vectors will not return it). Rows you cannot ' +
+        'edit (own-rows-only tables, manager-locked column) are refused with the reason.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        rowId: z.string().describe('Row id from rootr_list_rows / rootr_read_database'),
+        column: z.string().describe('The vector column — its id or header name'),
+      },
+    },
+    async ({ databaseId, rowId, column }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        await client.deleteRowVector(id, rowId, column);
+        return jsonResult({ deleted: true, rowId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }