@geometra/mcp 1.19.10 → 1.19.11

package/README.md

@@ -21,8 +21,8 @@ Geometra proxy:       Chromium → DOM geometry → same WebSocket as native →
 | `geometra_connect` | Connect with `url` (ws://…) **or** `pageUrl` (https://…) to auto-start geometra-proxy; `url: "https://…"` is auto-coerced onto the proxy path |
 | `geometra_query` | Find elements by stable id, role, name, text content, current value, or semantic state such as `invalid`, `required`, or `busy` |
 | `geometra_wait_for` | Wait for a semantic condition instead of guessing sleeps (`busy`, `disabled`, alerts, values, etc.) |
-| `geometra_fill_fields` | Fill labeled text/choice/toggle/file fields in one MCP call |
-| `geometra_run_actions` | Execute a batch of high-level actions in one MCP round trip and get one consolidated result |
+| `geometra_fill_fields` | Fill labeled text/choice/toggle/file fields in one MCP call; can return final-only status for the smallest responses |
+| `geometra_run_actions` | Execute a batch of high-level actions in one MCP round trip and get one consolidated result, with optional final-only output |
 | `geometra_page_model` | Summary-first webpage model: archetypes, stable section ids, counts, top-level sections, primary actions |
 | `geometra_expand_section` | Expand one form/dialog/list/landmark from `geometra_page_model` on demand |
 | `geometra_click` | Click an element by coordinates |
@@ -39,27 +39,155 @@ Geometra proxy:       Chromium → DOM geometry → same WebSocket as native →
 
 ## Setup
 
-### Claude Code
+<details>
+<summary>Claude Code</summary>
 
+**One-line install:**
 ```bash
-claude mcp add geometra -- npx @geometra/mcp
+claude mcp add geometra -- npx -y @geometra/mcp
 ```
 
-### Claude Desktop
+**Uninstall:**
+```bash
+claude mcp remove geometra
+```
+
+Or manually add to `.mcp.json` (project-level) or `~/.claude/settings.json` (global):
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall manually, remove the `geometra` entry from the config file.
+
+</details>
+
+<details>
+<summary>Claude Desktop</summary>
+
+Add to your Claude Desktop MCP config:
+
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the `geometra` entry from the config file.
+
+</details>
+
+<details>
+<summary>OpenAI Codex</summary>
+
+Add to your Codex MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the `geometra` entry from the config file.
+
+</details>
+
+<details>
+<summary>Cursor</summary>
 
-Add to `claude_desktop_config.json`:
+Open Settings → MCP → Add new MCP server, or add to `.cursor/mcp.json`:
 
 ```json
 {
   "mcpServers": {
     "geometra": {
       "command": "npx",
-      "args": ["@geometra/mcp"]
+      "args": ["-y", "@geometra/mcp"]
     }
   }
 }
 ```
 
+To uninstall, remove the entry from MCP settings.
+
+</details>
+
+<details>
+<summary>Windsurf</summary>
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the entry from the config file.
+
+</details>
+
+<details>
+<summary>VS Code / Copilot</summary>
+
+**One-line install:**
+```bash
+code --add-mcp '{"name":"geometra","command":"npx","args":["-y","@geometra/mcp"]}'
+```
+
+Or add to `.vscode/mcp.json`:
+```json
+{
+  "servers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the entry from MCP settings or delete the server from the MCP panel.
+
+</details>
+
+<details>
+<summary>Other MCP clients</summary>
+
+Any MCP client that supports stdio transport can use Geometra. The server config is:
+
+```json
+{
+  "command": "npx",
+  "args": ["-y", "@geometra/mcp"]
+}
+```
+
+To uninstall, remove the server entry from your client's MCP configuration.
+
+</details>
+
 ### From source (this repo)
 
 ```bash
@@ -200,6 +328,11 @@ Typical batch:
 
 Single action tools now default to terse summaries. Pass `detail: "verbose"` when you need a fuller current-UI fallback for debugging.
 
+For the smallest long-form responses, prefer:
+
+1. `detail: "minimal"` for structured step metadata instead of narrated deltas
+2. `includeSteps: false` when you only need aggregate success/error counts plus the final validation/state payload
+
 Typical field fill:
 
 ```json
@@ -211,7 +344,9 @@ Typical field fill:
     { "kind": "choice", "fieldLabel": "Will you require sponsorship?", "value": "No" },
     { "kind": "file", "fieldLabel": "Resume", "paths": ["/Users/you/resume.pdf"] }
   ],
-  "failOnInvalid": true
+  "failOnInvalid": true,
+  "detail": "minimal",
+  "includeSteps": false
 }
 ```
 

package/dist/__tests__/server-batch-results.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/server-batch-results.test.js

@@ -0,0 +1,206 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+function node(role, name, options) {
+    return {
+        role,
+        ...(name ? { name } : {}),
+        ...(options?.value ? { value: options.value } : {}),
+        ...(options?.state ? { state: options.state } : {}),
+        ...(options?.validation ? { validation: options.validation } : {}),
+        ...(options?.meta ? { meta: options.meta } : {}),
+        bounds: { x: 0, y: 0, width: 120, height: 40 },
+        path: options?.path ?? [],
+        children: options?.children ?? [],
+        focusable: role !== 'group',
+    };
+}
+const mockState = vi.hoisted(() => ({
+    currentA11yRoot: node('group', undefined, {
+        meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 0 },
+    }),
+    session: {
+        tree: { kind: 'box' },
+        layout: { x: 0, y: 0, width: 1280, height: 800, children: [] },
+        url: 'ws://127.0.0.1:3200',
+        updateRevision: 1,
+    },
+    sendClick: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendType: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendKey: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendFileUpload: vi.fn(async () => ({ status: 'updated', timeoutMs: 8000 })),
+    sendFieldText: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendFieldChoice: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendListboxPick: vi.fn(async () => ({ status: 'updated', timeoutMs: 4500 })),
+    sendSelectOption: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendSetChecked: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendWheel: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    waitForUiCondition: vi.fn(async () => true),
+}));
+vi.mock('../session.js', () => ({
+    connect: vi.fn(),
+    connectThroughProxy: vi.fn(),
+    disconnect: vi.fn(),
+    getSession: vi.fn(() => mockState.session),
+    sendClick: mockState.sendClick,
+    sendType: mockState.sendType,
+    sendKey: mockState.sendKey,
+    sendFileUpload: mockState.sendFileUpload,
+    sendFieldText: mockState.sendFieldText,
+    sendFieldChoice: mockState.sendFieldChoice,
+    sendListboxPick: mockState.sendListboxPick,
+    sendSelectOption: mockState.sendSelectOption,
+    sendSetChecked: mockState.sendSetChecked,
+    sendWheel: mockState.sendWheel,
+    buildA11yTree: vi.fn(() => mockState.currentA11yRoot),
+    buildCompactUiIndex: vi.fn(() => ({ nodes: [], context: {} })),
+    buildPageModel: vi.fn(() => ({
+        viewport: { width: 1280, height: 800 },
+        archetypes: ['form'],
+        summary: { landmarkCount: 0, formCount: 1, dialogCount: 0, listCount: 0, focusableCount: 2 },
+        primaryActions: [],
+        landmarks: [],
+        forms: [],
+        dialogs: [],
+        lists: [],
+    })),
+    expandPageSection: vi.fn(() => null),
+    buildUiDelta: vi.fn(() => ({})),
+    hasUiDelta: vi.fn(() => false),
+    nodeIdForPath: vi.fn((path) => `n:${path.length > 0 ? path.join('.') : 'root'}`),
+    summarizeCompactIndex: vi.fn(() => ''),
+    summarizePageModel: vi.fn(() => ''),
+    summarizeUiDelta: vi.fn(() => ''),
+    waitForUiCondition: mockState.waitForUiCondition,
+}));
+const { createServer } = await import('../server.js');
+function getToolHandler(name) {
+    const server = createServer();
+    return server._registeredTools[name].handler;
+}
+describe('batch MCP result shaping', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 420 },
+            children: [
+                node('textbox', 'Mission', {
+                    value: 'Ship calm developer tools across browsers and platforms.',
+                    path: [0],
+                }),
+                node('textbox', 'Email', {
+                    value: 'taylor@example.com',
+                    path: [1],
+                }),
+            ],
+        });
+    });
+    it('keeps fill_fields minimal output structured and does not echo long essay text', async () => {
+        const longAnswer = 'A'.repeat(180);
+        const handler = getToolHandler('geometra_fill_fields');
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 420 },
+            children: [
+                node('textbox', 'Mission', { value: longAnswer, path: [0] }),
+                node('textbox', 'Email', { value: 'taylor@example.com', path: [1] }),
+            ],
+        });
+        const result = await handler({
+            fields: [
+                { kind: 'text', fieldLabel: 'Mission', value: longAnswer },
+                { kind: 'text', fieldLabel: 'Email', value: 'taylor@example.com' },
+            ],
+            stopOnError: true,
+            failOnInvalid: false,
+            includeSteps: true,
+            detail: 'minimal',
+        });
+        const text = result.content[0].text;
+        const payload = JSON.parse(text);
+        const steps = payload.steps;
+        expect(text).not.toContain(longAnswer);
+        expect(payload).toMatchObject({
+            completed: true,
+            fieldCount: 2,
+            successCount: 2,
+            errorCount: 0,
+        });
+        expect(steps[0]).toMatchObject({
+            index: 0,
+            kind: 'text',
+            ok: true,
+            fieldLabel: 'Mission',
+            valueLength: 180,
+            wait: 'updated',
+            readback: { role: 'textbox', valueLength: 180 },
+        });
+        expect(steps[1]).toMatchObject({
+            index: 1,
+            kind: 'text',
+            ok: true,
+            fieldLabel: 'Email',
+            value: 'taylor@example.com',
+            wait: 'updated',
+            readback: { role: 'textbox', value: 'taylor@example.com' },
+        });
+    });
+    it('lets run_actions omit step listings while keeping capped final validation state', async () => {
+        const handler = getToolHandler('geometra_run_actions');
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 2400 },
+            children: [
+                node('textbox', 'Full name', {
+                    value: '',
+                    path: [0],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Enter your full name.' },
+                }),
+                node('textbox', 'Email', {
+                    value: '',
+                    path: [1],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Enter your email.' },
+                }),
+                node('textbox', 'Phone', {
+                    value: '',
+                    path: [2],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Enter your phone number.' },
+                }),
+                node('textbox', 'Location', {
+                    value: '',
+                    path: [3],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Choose a location.' },
+                }),
+                node('textbox', 'LinkedIn', {
+                    value: '',
+                    path: [4],
+                    state: { invalid: true },
+                    validation: { error: 'Enter a valid URL.' },
+                }),
+                node('alert', 'Your form needs corrections', { path: [5] }),
+            ],
+        });
+        const result = await handler({
+            actions: [{ type: 'click', x: 320, y: 540 }],
+            stopOnError: true,
+            includeSteps: false,
+            detail: 'minimal',
+        });
+        const payload = JSON.parse(result.content[0].text);
+        const final = payload.final;
+        expect(payload).toMatchObject({
+            completed: true,
+            stepCount: 1,
+            successCount: 1,
+            errorCount: 0,
+        });
+        expect(payload).not.toHaveProperty('steps');
+        expect(final).toMatchObject({
+            pageUrl: 'https://jobs.example.com/application',
+            alertCount: 1,
+            invalidCount: 5,
+        });
+        expect(final.invalidFields.length).toBe(4);
+        expect(final.alerts.length).toBe(1);
+    });
+});

package/dist/server.js

@@ -145,7 +145,7 @@ const batchActionSchema = z.discriminatedUnion('type', [
     }),
 ]);
 export function createServer() {
-    const server = new McpServer({ name: 'geometra', version: '1.19.10' }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: 'geometra', version: '1.19.11' }, { capabilities: { tools: {} } });
     // ── connect ──────────────────────────────────────────────────
     server.tool('geometra_connect', `Connect to a Geometra WebSocket peer, or start \`geometra-proxy\` automatically for a normal web page.
 
@@ -309,8 +309,13 @@ Use \`kind: "text"\` for textboxes / textareas, \`"choice"\` for selects / combo
             .optional()
             .default(false)
             .describe('Return an error if invalid fields remain after filling'),
+        includeSteps: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Include per-field step results in the JSON payload (default true). Set false for the smallest batch response.'),
         detail: detailInput(),
-    }, async ({ fields, stopOnError, failOnInvalid, detail }) => {
+    }, async ({ fields, stopOnError, failOnInvalid, includeSteps, detail }) => {
         const session = getSession();
         if (!session)
             return err('Not connected. Call geometra_connect first.');
@@ -319,8 +324,10 @@ Use \`kind: "text"\` for textboxes / textareas, \`"choice"\` for selects / combo
         for (let index = 0; index < fields.length; index++) {
             const field = fields[index];
             try {
-                const summary = await executeFillField(session, field, detail);
-                steps.push({ index, kind: field.kind, ok: true, summary });
+                const result = await executeFillField(session, field, detail);
+                steps.push(detail === 'verbose'
+                    ? { index, kind: field.kind, ok: true, summary: result.summary }
+                    : { index, kind: field.kind, ok: true, ...result.compact });
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
@@ -334,12 +341,16 @@ Use \`kind: "text"\` for textboxes / textareas, \`"choice"\` for selects / combo
         const after = sessionA11y(session);
         const signals = after ? collectSessionSignals(after) : undefined;
         const invalidRemaining = signals?.invalidFields.length ?? 0;
+        const successCount = steps.filter(step => step.ok === true).length;
+        const errorCount = steps.length - successCount;
         const payload = {
             completed: stoppedAt === undefined && steps.length === fields.length,
             fieldCount: fields.length,
-            steps,
+            successCount,
+            errorCount,
+            ...(includeSteps ? { steps } : {}),
             ...(stoppedAt !== undefined ? { stoppedAt } : {}),
-            ...(signals ? { final: sessionSignalsPayload(signals) } : {}),
+            ...(signals ? { final: sessionSignalsPayload(signals, detail) } : {}),
         };
         if (failOnInvalid && invalidRemaining > 0) {
             return err(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
@@ -351,8 +362,13 @@ Use \`kind: "text"\` for textboxes / textareas, \`"choice"\` for selects / combo
 Supported step types: \`click\`, \`type\`, \`key\`, \`upload_files\`, \`pick_listbox_option\`, \`select_option\`, \`set_checked\`, \`wheel\`, \`wait_for\`, and \`fill_fields\`.`, {
         actions: z.array(batchActionSchema).min(1).max(80).describe('Ordered high-level action steps to run sequentially'),
         stopOnError: z.boolean().optional().default(true).describe('Stop at the first failing step (default true)'),
+        includeSteps: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Include per-action step results in the JSON payload (default true). Set false for the smallest batch response.'),
         detail: detailInput(),
-    }, async ({ actions, stopOnError, detail }) => {
+    }, async ({ actions, stopOnError, includeSteps, detail }) => {
         const session = getSession();
         if (!session)
             return err('Not connected. Call geometra_connect first.');
@@ -361,8 +377,10 @@ Supported step types: \`click\`, \`type\`, \`key\`, \`upload_files\`, \`pick_lis
         for (let index = 0; index < actions.length; index++) {
             const action = actions[index];
             try {
-                const summary = await executeBatchAction(session, action, detail);
-                steps.push({ index, type: action.type, ok: true, summary });
+                const result = await executeBatchAction(session, action, detail, includeSteps);
+                steps.push(detail === 'verbose'
+                    ? { index, type: action.type, ok: true, summary: result.summary }
+                    : { index, type: action.type, ok: true, ...result.compact });
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
@@ -374,12 +392,16 @@ Supported step types: \`click\`, \`type\`, \`key\`, \`upload_files\`, \`pick_lis
             }
         }
         const after = sessionA11y(session);
+        const successCount = steps.filter(step => step.ok === true).length;
+        const errorCount = steps.length - successCount;
         const payload = {
             completed: stoppedAt === undefined && steps.length === actions.length,
             stepCount: actions.length,
-            steps,
+            successCount,
+            errorCount,
+            ...(includeSteps ? { steps } : {}),
             ...(stoppedAt !== undefined ? { stoppedAt } : {}),
-            ...(after ? { final: sessionSignalsPayload(collectSessionSignals(after)) } : {}),
+            ...(after ? { final: sessionSignalsPayload(collectSessionSignals(after), detail) } : {}),
         };
         return ok(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
     });
@@ -897,7 +919,7 @@ function truncateInlineText(text, max) {
         return undefined;
     return normalized.length > max ? `${normalized.slice(0, max - 1)}…` : normalized;
 }
-function sessionSignalsPayload(signals) {
+function sessionSignalsPayload(signals, detail = 'minimal') {
     return {
         ...(signals.pageUrl ? { pageUrl: signals.pageUrl } : {}),
         ...(signals.scrollX !== undefined || signals.scrollY !== undefined
@@ -906,26 +928,85 @@ function sessionSignalsPayload(signals) {
         ...(signals.focus ? { focus: signals.focus } : {}),
         dialogCount: signals.dialogCount,
         busyCount: signals.busyCount,
-        alerts: signals.alerts,
-        invalidFields: signals.invalidFields,
+        alertCount: signals.alerts.length,
+        invalidCount: signals.invalidFields.length,
+        alerts: detail === 'verbose' ? signals.alerts : signals.alerts.slice(0, 2),
+        invalidFields: detail === 'verbose' ? signals.invalidFields : signals.invalidFields.slice(0, 4),
     };
 }
-async function executeBatchAction(session, action, detail) {
+function compactTextValue(value, inlineLimit = 48) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return { valueLength: value.length };
+    return normalized.length <= inlineLimit
+        ? { value: normalized }
+        : { valueLength: value.length };
+}
+function fieldStatePayload(session, fieldLabel) {
+    const a11y = sessionA11y(session);
+    if (!a11y)
+        return undefined;
+    const matches = findNodes(a11y, {
+        name: fieldLabel,
+        role: 'combobox',
+    });
+    if (matches.length === 0) {
+        matches.push(...findNodes(a11y, { name: fieldLabel, role: 'textbox' }));
+    }
+    if (matches.length === 0) {
+        matches.push(...findNodes(a11y, { name: fieldLabel, role: 'button' }));
+    }
+    const match = matches[0];
+    if (!match)
+        return undefined;
+    const valuePayload = match.value ? compactTextValue(match.value, 64) : {};
+    return {
+        role: match.role,
+        ...valuePayload,
+        ...(match.state && Object.keys(match.state).length > 0 ? { state: match.state } : {}),
+        ...(match.validation?.error ? { error: truncateInlineText(match.validation.error, 120) } : {}),
+    };
+}
+function waitStatusPayload(wait) {
+    return wait ? { wait: wait.status } : {};
+}
+function compactFilterPayload(filter) {
+    return Object.fromEntries(Object.entries(filter).filter(([, value]) => value !== undefined));
+}
+async function executeBatchAction(session, action, detail, includeSteps) {
     switch (action.type) {
         case 'click': {
             const before = sessionA11y(session);
             const wait = await sendClick(session, action.x, action.y, action.timeoutMs);
-            return `Clicked at (${action.x}, ${action.y}).\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Clicked at (${action.x}, ${action.y}).\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    at: { x: action.x, y: action.y },
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'type': {
             const before = sessionA11y(session);
             const wait = await sendType(session, action.text, action.timeoutMs);
-            return `Typed "${action.text}".\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Typed "${action.text}".\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    ...compactTextValue(action.text),
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'key': {
             const before = sessionA11y(session);
             const wait = await sendKey(session, action.key, { shift: action.shift, ctrl: action.ctrl, meta: action.meta, alt: action.alt }, action.timeoutMs);
-            return `Pressed ${formatKeyCombo(action.key, action)}.\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Pressed ${formatKeyCombo(action.key, action)}.\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    key: formatKeyCombo(action.key, action),
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'upload_files': {
             const before = sessionA11y(session);
@@ -936,7 +1017,16 @@ async function executeBatchAction(session, action, detail) {
                 strategy: action.strategy,
                 drop: action.dropX !== undefined && action.dropY !== undefined ? { x: action.dropX, y: action.dropY } : undefined,
             }, action.timeoutMs ?? 8_000);
-            return `Uploaded ${action.paths.length} file(s).\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Uploaded ${action.paths.length} file(s).\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    fileCount: action.paths.length,
+                    ...(action.fieldLabel ? { fieldLabel: action.fieldLabel } : {}),
+                    ...(action.strategy ? { strategy: action.strategy } : {}),
+                    ...waitStatusPayload(wait),
+                    ...(action.fieldLabel ? { readback: fieldStatePayload(session, action.fieldLabel) } : {}),
+                },
+            };
         }
         case 'pick_listbox_option': {
             const before = sessionA11y(session);
@@ -948,7 +1038,15 @@ async function executeBatchAction(session, action, detail) {
             }, action.timeoutMs);
             const summary = postActionSummary(session, before, wait, detail);
             const fieldSummary = action.fieldLabel ? summarizeFieldLabelState(session, action.fieldLabel) : undefined;
-            return [`Picked listbox option "${action.label}".`, fieldSummary, summary].filter(Boolean).join('\n');
+            return {
+                summary: [`Picked listbox option "${action.label}".`, fieldSummary, summary].filter(Boolean).join('\n'),
+                compact: {
+                    label: action.label,
+                    ...(action.fieldLabel ? { fieldLabel: action.fieldLabel } : {}),
+                    ...waitStatusPayload(wait),
+                    ...(action.fieldLabel ? { readback: fieldStatePayload(session, action.fieldLabel) } : {}),
+                },
+            };
         }
         case 'select_option': {
             if (action.value === undefined && action.label === undefined && action.index === undefined) {
@@ -960,7 +1058,16 @@ async function executeBatchAction(session, action, detail) {
                 label: action.label,
                 index: action.index,
             }, action.timeoutMs);
-            return `Selected option.\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Selected option.\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    at: { x: action.x, y: action.y },
+                    ...(action.value !== undefined ? { value: action.value } : {}),
+                    ...(action.label !== undefined ? { label: action.label } : {}),
+                    ...(action.index !== undefined ? { index: action.index } : {}),
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'set_checked': {
             const before = sessionA11y(session);
@@ -969,7 +1076,15 @@ async function executeBatchAction(session, action, detail) {
                 exact: action.exact,
                 controlType: action.controlType,
             }, action.timeoutMs);
-            return `Set ${action.controlType ?? 'checkbox/radio'} "${action.label}" to ${String(action.checked ?? true)}.\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Set ${action.controlType ?? 'checkbox/radio'} "${action.label}" to ${String(action.checked ?? true)}.\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    label: action.label,
+                    checked: action.checked ?? true,
+                    ...(action.controlType ? { controlType: action.controlType } : {}),
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'wheel': {
             const before = sessionA11y(session);
@@ -978,7 +1093,15 @@ async function executeBatchAction(session, action, detail) {
                 x: action.x,
                 y: action.y,
             }, action.timeoutMs);
-            return `Wheel delta (${action.deltaX ?? 0}, ${action.deltaY}).\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Wheel delta (${action.deltaX ?? 0}, ${action.deltaY}).\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    deltaY: action.deltaY,
+                    ...(action.deltaX !== undefined ? { deltaX: action.deltaX } : {}),
+                    ...(action.x !== undefined && action.y !== undefined ? { at: { x: action.x, y: action.y } } : {}),
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'wait_for': {
             if (!session.tree || !session.layout)
@@ -1016,24 +1139,64 @@ async function executeBatchAction(session, action, detail) {
                 throw new Error(`Timed out after ${timeoutMs}ms waiting for ${present ? 'presence' : 'absence'} of ${JSON.stringify(filter)}`);
             }
             if (!present) {
-                return `Condition satisfied after ${elapsedMs}ms: no nodes matched ${JSON.stringify(filter)}.`;
+                return {
+                    summary: `Condition satisfied after ${elapsedMs}ms: no nodes matched ${JSON.stringify(filter)}.`,
+                    compact: {
+                        present,
+                        elapsedMs,
+                        filter: compactFilterPayload(filter),
+                    },
+                };
             }
             const after = sessionA11y(session);
             if (!after) {
-                return `Condition satisfied after ${elapsedMs}ms for ${JSON.stringify(filter)}.`;
+                return {
+                    summary: `Condition satisfied after ${elapsedMs}ms for ${JSON.stringify(filter)}.`,
+                    compact: {
+                        present,
+                        elapsedMs,
+                        filter: compactFilterPayload(filter),
+                    },
+                };
             }
             const matches = findNodes(after, filter);
             if (detail === 'verbose') {
-                return JSON.stringify(matches.slice(0, 8).map(node => formatNode(node, after.bounds)), null, 2);
+                return {
+                    summary: JSON.stringify(matches.slice(0, 8).map(node => formatNode(node, after.bounds)), null, 2),
+                    compact: {
+                        present,
+                        elapsedMs,
+                        matchCount: matches.length,
+                        filter: compactFilterPayload(filter),
+                    },
+                };
             }
-            return `Condition satisfied after ${elapsedMs}ms with ${matches.length} matching node(s).`;
+            return {
+                summary: `Condition satisfied after ${elapsedMs}ms with ${matches.length} matching node(s).`,
+                compact: {
+                    present,
+                    elapsedMs,
+                    matchCount: matches.length,
+                    filter: compactFilterPayload(filter),
+                },
+            };
         }
         case 'fill_fields': {
-            const lines = [];
-            for (const field of action.fields) {
-                lines.push(await executeFillField(session, field, detail));
+            const steps = [];
+            for (let index = 0; index < action.fields.length; index++) {
+                const field = action.fields[index];
+                const result = await executeFillField(session, field, detail);
+                steps.push(detail === 'verbose'
+                    ? { index, kind: field.kind, ok: true, summary: result.summary }
+                    : { index, kind: field.kind, ok: true, ...result.compact });
             }
-            return lines.join('\n');
+            return {
+                summary: steps.map(step => String(step.summary ?? '')).filter(Boolean).join('\n'),
+                compact: {
+                    fieldCount: action.fields.length,
+                    ...(includeSteps ? { steps } : {}),
+                },
+            };
         }
     }
 }
@@ -1043,36 +1206,68 @@ async function executeFillField(session, field, detail) {
             const before = sessionA11y(session);
             const wait = await sendFieldText(session, field.fieldLabel, field.value, { exact: field.exact }, field.timeoutMs);
             const fieldSummary = summarizeFieldLabelState(session, field.fieldLabel);
-            return [
-                `Filled text field "${field.fieldLabel}".`,
-                fieldSummary,
-                postActionSummary(session, before, wait, detail),
-            ].filter(Boolean).join('\n');
+            return {
+                summary: [
+                    `Filled text field "${field.fieldLabel}".`,
+                    fieldSummary,
+                    postActionSummary(session, before, wait, detail),
+                ].filter(Boolean).join('\n'),
+                compact: {
+                    fieldLabel: field.fieldLabel,
+                    ...compactTextValue(field.value),
+                    ...waitStatusPayload(wait),
+                    readback: fieldStatePayload(session, field.fieldLabel),
+                },
+            };
         }
         case 'choice': {
             const before = sessionA11y(session);
             const wait = await sendFieldChoice(session, field.fieldLabel, field.value, { exact: field.exact, query: field.query }, field.timeoutMs);
             const fieldSummary = summarizeFieldLabelState(session, field.fieldLabel);
-            return [
-                `Set choice field "${field.fieldLabel}" to "${field.value}".`,
-                fieldSummary,
-                postActionSummary(session, before, wait, detail),
-            ].filter(Boolean).join('\n');
+            return {
+                summary: [
+                    `Set choice field "${field.fieldLabel}" to "${field.value}".`,
+                    fieldSummary,
+                    postActionSummary(session, before, wait, detail),
+                ].filter(Boolean).join('\n'),
+                compact: {
+                    fieldLabel: field.fieldLabel,
+                    value: field.value,
+                    ...waitStatusPayload(wait),
+                    readback: fieldStatePayload(session, field.fieldLabel),
+                },
+            };
         }
         case 'toggle': {
             const before = sessionA11y(session);
             const wait = await sendSetChecked(session, field.label, { checked: field.checked, exact: field.exact, controlType: field.controlType }, field.timeoutMs);
-            return `Set ${field.controlType ?? 'checkbox/radio'} "${field.label}" to ${String(field.checked ?? true)}.\n${postActionSummary(session, before, wait, detail)}`;
+            return {
+                summary: `Set ${field.controlType ?? 'checkbox/radio'} "${field.label}" to ${String(field.checked ?? true)}.\n${postActionSummary(session, before, wait, detail)}`,
+                compact: {
+                    label: field.label,
+                    checked: field.checked ?? true,
+                    ...(field.controlType ? { controlType: field.controlType } : {}),
+                    ...waitStatusPayload(wait),
+                },
+            };
         }
         case 'file': {
             const before = sessionA11y(session);
             const wait = await sendFileUpload(session, field.paths, { fieldLabel: field.fieldLabel, exact: field.exact }, field.timeoutMs ?? 8_000);
             const fieldSummary = summarizeFieldLabelState(session, field.fieldLabel);
-            return [
-                `Uploaded ${field.paths.length} file(s) to "${field.fieldLabel}".`,
-                fieldSummary,
-                postActionSummary(session, before, wait, detail),
-            ].filter(Boolean).join('\n');
+            return {
+                summary: [
+                    `Uploaded ${field.paths.length} file(s) to "${field.fieldLabel}".`,
+                    fieldSummary,
+                    postActionSummary(session, before, wait, detail),
+                ].filter(Boolean).join('\n'),
+                compact: {
+                    fieldLabel: field.fieldLabel,
+                    fileCount: field.paths.length,
+                    ...waitStatusPayload(wait),
+                    readback: fieldStatePayload(session, field.fieldLabel),
+                },
+            };
         }
     }
 }
@@ -1134,29 +1329,20 @@ export function findNodes(node, filter) {
     return matches;
 }
 function summarizeFieldLabelState(session, fieldLabel) {
-    const a11y = sessionA11y(session);
-    if (!a11y)
-        return undefined;
-    const matches = findNodes(a11y, {
-        name: fieldLabel,
-        role: 'combobox',
-    });
-    if (matches.length === 0) {
-        matches.push(...findNodes(a11y, { name: fieldLabel, role: 'textbox' }));
-    }
-    if (matches.length === 0) {
-        matches.push(...findNodes(a11y, { name: fieldLabel, role: 'button' }));
-    }
-    const match = matches[0];
-    if (!match)
+    const payload = fieldStatePayload(session, fieldLabel);
+    if (!payload)
         return undefined;
     const parts = [`Field "${fieldLabel}"`];
-    if (match.value)
-        parts.push(`value=${JSON.stringify(match.value)}`);
-    if (match.state && Object.keys(match.state).length > 0)
-        parts.push(`state=${JSON.stringify(match.state)}`);
-    if (match.validation?.error)
-        parts.push(`error=${JSON.stringify(match.validation.error)}`);
+    if (payload.role)
+        parts.push(`role=${String(payload.role)}`);
+    if (payload.value)
+        parts.push(`value=${JSON.stringify(payload.value)}`);
+    if (payload.valueLength)
+        parts.push(`valueLength=${String(payload.valueLength)}`);
+    if (payload.state)
+        parts.push(`state=${JSON.stringify(payload.state)}`);
+    if (payload.error)
+        parts.push(`error=${JSON.stringify(payload.error)}`);
     return parts.join(' ');
 }
 function formatNode(node, viewport) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.10",
+  "version": "1.19.11",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "ui-testing"
   ],
   "dependencies": {
-    "@geometra/proxy": "^1.19.10",
+    "@geometra/proxy": "^1.19.11",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"