@gravitykit/block-mcp 2.0.0-beta → 2.1.0

package/src/__tests__/tools/discovery/list_patterns.test.ts

@@ -3,7 +3,8 @@
  *
  * Covers:
  *   - Filter forwarding (search → q, synced, min_score)
- *   - Server-side limit = offset + limit (so client slice still works)
+ *   - Full fetch (no server-side limit) + client-side pagination, so `total`
+ *     and `next_offset` reflect the true count (matches list_block_types)
  *   - Client-side slicing via offset
  *   - Defaults: limit 20, offset 0
  *   - Response shape: patterns, count, total, offset, next_offset, summary
@@ -46,15 +47,33 @@ describe('list_patterns — pagination', () => {
     client.getPatterns.mockResolvedValue(patternsResponse);
   });
 
-  it('defaults to limit 20, offset 0', async () => {
+  it('fetches the full set (no truncating server-side limit)', async () => {
     await handleDiscoveryTool('list_patterns', {}, client as any);
-    // server limit is offset + limit = 0 + 20 = 20
-    expect(client.getPatterns).toHaveBeenCalledWith(expect.objectContaining({ limit: 20 }));
+    // No `limit` is sent: the handler paginates locally so `total` and
+    // `next_offset` reflect the true count instead of the fetched window.
+    const args = client.getPatterns.mock.calls[0][0];
+    expect(args?.limit).toBeUndefined();
   });
 
-  it('server limit accounts for offset (offset+limit)', async () => {
+  it('does not cap the fetch by offset+limit', async () => {
     await handleDiscoveryTool('list_patterns', { limit: 10, offset: 30 }, client as any);
-    expect(client.getPatterns).toHaveBeenCalledWith(expect.objectContaining({ limit: 40 }));
+    const args = client.getPatterns.mock.calls[0][0];
+    expect(args?.limit).toBeUndefined();
+  });
+
+  it('reports true total and non-null next_offset when more remain', async () => {
+    const many = Array.from({ length: 30 }, (_, i) => ({
+      id: i + 1, name: `pattern-${i}`,
+      type: 'registered' as const,
+      created: '2026-01-01', modified: '2026-01-01',
+      reference_count: 0,
+      preference: { score: 80, tier: 'recommended' as const, reasons: [] },
+      contains_blocks: [], has_legacy_blocks: false,
+    }));
+    client.getPatterns.mockResolvedValueOnce({ patterns: many } as any);
+    const result = await handleDiscoveryTool('list_patterns', { limit: 20, offset: 0 }, client as any) as Record<string, unknown>;
+    expect(result.total).toBe(30);
+    expect(result.next_offset).toBe(20);
   });
 
   it('client-side slice honors offset', async () => {

package/src/__tests__/tools/mutate/edit_block_tree.test.ts

@@ -40,6 +40,26 @@ describe('edit_block_tree — common validation', () => {
     ).rejects.toThrow(/post_id is required/);
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleMutateTool('edit_block_tree', { post_id: 1.5, op: 'update-attrs', path: [0], attributes: {} }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleMutateTool('edit_block_tree', { post_id: -1, op: 'update-attrs', path: [0], attributes: {} }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleMutateTool('edit_block_tree', {
+        post_id: Number.MAX_SAFE_INTEGER + 1, op: 'update-attrs', path: [0], attributes: {},
+      }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('rejects unknown op', async () => {
     await expect(
       handleMutateTool('edit_block_tree', { post_id: 1, op: 'frobnicate', path: [0] }, client as any)
@@ -247,6 +267,39 @@ describe('edit_block_tree — insert-child', () => {
     }));
   });
 
+  it('coerces a numeric-string position to an integer', async () => {
+    // The inputSchema advertises position as integer|string, so a numeric
+    // string ("3") is schema-conformant and must be accepted as the index.
+    await handleMutateTool('edit_block_tree', {
+      post_id: 1, op: 'insert-child', path: [0],
+      block: { name: 'core/paragraph' }, position: '3',
+    }, client as any);
+    expect(client.mutateBlockTree).toHaveBeenCalledWith(1, expect.objectContaining({
+      position: 3,
+    }));
+  });
+
+  it('accepts the "-1" append sentinel as a string', async () => {
+    // -1 is the documented append sentinel; its string form must behave like
+    // the number -1, not be rejected as a non-numeric position.
+    await handleMutateTool('edit_block_tree', {
+      post_id: 1, op: 'insert-child', path: [0],
+      block: { name: 'core/paragraph' }, position: '-1',
+    }, client as any);
+    expect(client.mutateBlockTree).toHaveBeenCalledWith(1, expect.objectContaining({
+      position: -1,
+    }));
+  });
+
+  it('rejects positions below the -1 append sentinel', async () => {
+    await expect(
+      handleMutateTool('edit_block_tree', {
+        post_id: 1, op: 'insert-child', path: [0],
+        block: { name: 'core/paragraph' }, position: '-2',
+      }, client as any)
+    ).rejects.toThrow(/position must be/);
+  });
+
   it('rejects invalid position string', async () => {
     await expect(
       handleMutateTool('edit_block_tree', {

package/src/__tests__/tools/patterns/insert_pattern.test.ts

@@ -27,6 +27,22 @@ describe('insert_pattern — validation', () => {
       .rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(handlePatternTool('insert_pattern', { post_id: 1.5, pattern_id: 1 }, client as any))
+      .rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(handlePatternTool('insert_pattern', { post_id: -1, pattern_id: 1 }, client as any))
+      .rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handlePatternTool('insert_pattern', { post_id: Number.MAX_SAFE_INTEGER + 1, pattern_id: 1 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires pattern_id', async () => {
     await expect(handlePatternTool('insert_pattern', { post_id: 1 }, client as any))
       .rejects.toThrow('pattern_id');

package/src/__tests__/tools/posts/update_post.test.ts

@@ -61,6 +61,20 @@ describe('update_post — request shape', () => {
     const body = client.updatePost.mock.calls[0]![1] as Record<string, unknown>;
     expect(body).not.toHaveProperty('post_id');
   });
+
+  // Some MCP clients / untyped JSON send numeric IDs as strings. get_post_info
+  // already coerces them; update_post must accept the same, or the same post is
+  // editable via one tool and rejected by another in one session.
+  it('coerces a numeric-string post_id to a number', async () => {
+    await handlePostTool('update_post', { post_id: '42', status: 'draft' }, client as any);
+    expect(client.updatePost).toHaveBeenCalledWith(42, { status: 'draft' });
+  });
+
+  it('rejects a non-numeric post_id string', async () => {
+    await expect(handlePostTool('update_post', { post_id: 'abc', status: 'draft' }, client as any))
+      .rejects.toThrow('post_id must be a positive integer');
+    expect(client.updatePost).not.toHaveBeenCalled();
+  });
 });
 
 describe('update_post — response shape', () => {

package/src/__tests__/tools/read/get_block.test.ts

@@ -31,6 +31,24 @@ describe('get_block — input validation', () => {
     ).rejects.toThrow(/post_id is required/);
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleReadTool('get_block', { post_id: 1.5, ref: 'blk_a' }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleReadTool('get_block', { post_id: -1, ref: 'blk_a' }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleReadTool('get_block', { post_id: Number.MAX_SAFE_INTEGER + 1, ref: 'blk_a' }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires exactly one of ref or flat_index (rejects neither)', async () => {
     await expect(
       handleReadTool('get_block', { post_id: 1 }, client as any)
@@ -54,6 +72,23 @@ describe('get_block — input validation', () => {
       handleReadTool('get_block', { post_id: 1, flat_index: NaN }, client as any)
     ).rejects.toThrow(/exactly one of ref or flat_index/);
   });
+
+  it('treats a fractional flat_index as missing (must be an integer)', async () => {
+    await expect(
+      handleReadTool('get_block', { post_id: 1, flat_index: 1.5 }, client as any)
+    ).rejects.toThrow(/exactly one of ref or flat_index/);
+    expect(client.getBlock).not.toHaveBeenCalled();
+  });
+
+  // update_block / delete_block reject a negative flat_index client-side;
+  // get_block must match so a negative index is treated as absent, not sent
+  // to the server as a valid target.
+  it('treats a negative flat_index as missing (still requires ref)', async () => {
+    await expect(
+      handleReadTool('get_block', { post_id: 1, flat_index: -1 }, client as any)
+    ).rejects.toThrow(/exactly one of ref or flat_index/);
+    expect(client.getBlock).not.toHaveBeenCalled();
+  });
 });
 
 describe('get_block — routing', () => {

package/src/__tests__/tools/read/get_page_blocks.test.ts

@@ -32,6 +32,24 @@ describe('get_page_blocks — input validation', () => {
     ).rejects.toThrow(/post_id or url/);
   });
 
+  it('rejects a float post_id (does not silently fall through to url resolution)', async () => {
+    await expect(
+      handleReadTool('get_page_blocks', { post_id: 1.5 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleReadTool('get_page_blocks', { post_id: -1 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleReadTool('get_page_blocks', { post_id: Number.MAX_SAFE_INTEGER + 1 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('accepts post_id alone', async () => {
     await expect(
       handleReadTool('get_page_blocks', { post_id: 42 }, client as any)

package/src/__tests__/tools/read/pagination.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Tool tests: get_page_blocks pagination (limit + cursor).
+ *
+ * The REST route and the client both support `limit`/`cursor` pagination,
+ * but the MCP tool never exposed them — agents had no way to page through a
+ * huge post. These pin the tool-layer contract:
+ *   - limit/cursor are declared on the inputSchema (dispatch validation
+ *     rejects undeclared keys, so omission = unusable);
+ *   - both forward to client.getPageBlocks;
+ *   - the response's `pagination` (incl. next_cursor) passes through so the
+ *     agent can fetch the next page.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { handleReadTool, READ_TOOLS } from '../../../tools/read.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { pageBlocksResponse } from '../../fixtures/rest-responses.js';
+
+describe('get_page_blocks — pagination', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+  });
+
+  it('declares limit and cursor on the inputSchema', () => {
+    const tool = READ_TOOLS.find((t) => t.name === 'get_page_blocks');
+    const props = (tool?.inputSchema as { properties?: Record<string, unknown> })?.properties ?? {};
+    expect(props.limit).toBeDefined();
+    expect(props.cursor).toBeDefined();
+  });
+
+  it('forwards limit and cursor to the client', async () => {
+    client.getPageBlocks.mockResolvedValue(pageBlocksResponse);
+    await handleReadTool(
+      'get_page_blocks',
+      { post_id: 42, limit: 2, cursor: 'idx_2' },
+      client as never,
+    );
+    expect(client.getPageBlocks).toHaveBeenCalledWith(
+      42,
+      expect.objectContaining({ limit: 2, cursor: 'idx_2' }),
+    );
+  });
+
+  it('passes the pagination meta (next_cursor) through to the agent', async () => {
+    client.getPageBlocks.mockResolvedValue({
+      ...pageBlocksResponse,
+      pagination: { limit: 2, offset: 0, total: 4, next_cursor: 'idx_2' },
+    });
+    const result = (await handleReadTool(
+      'get_page_blocks',
+      { post_id: 42, limit: 2 },
+      client as never,
+    )) as { pagination?: { next_cursor?: string | null } };
+    expect(result.pagination?.next_cursor).toBe('idx_2');
+  });
+
+  it('omits pagination from the response when not paginating', async () => {
+    client.getPageBlocks.mockResolvedValue(pageBlocksResponse);
+    const result = (await handleReadTool('get_page_blocks', { post_id: 42 }, client as never)) as {
+      pagination?: unknown;
+    };
+    expect(result.pagination).toBeUndefined();
+  });
+});

package/src/__tests__/tools/write/delete_block.test.ts

@@ -23,6 +23,24 @@ describe('delete_block — validation', () => {
     ).rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleWriteTool('delete_block', { post_id: 1.5, top_level_counter: 0 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleWriteTool('delete_block', { post_id: -1, top_level_counter: 0 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('delete_block', { post_id: Number.MAX_SAFE_INTEGER + 1, top_level_counter: 0 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires top_level_counter OR ref (not neither)', async () => {
     await expect(
       handleWriteTool('delete_block', { post_id: 1 }, client as any)

package/src/__tests__/tools/write/insert_blocks.test.ts

@@ -32,6 +32,27 @@ describe('insert_blocks — validation', () => {
     ).rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleWriteTool('insert_blocks', { post_id: 1.5, blocks: [{ name: 'core/paragraph' }] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleWriteTool('insert_blocks', { post_id: -1, blocks: [{ name: 'core/paragraph' }] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('insert_blocks', {
+        post_id: Number.MAX_SAFE_INTEGER + 1,
+        blocks: [{ name: 'core/paragraph' }],
+      }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires at least one block', async () => {
     await expect(
       handleWriteTool('insert_blocks', { post_id: 1 }, client as any)

package/src/__tests__/tools/write/replace_block_range.test.ts

@@ -11,6 +11,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { handleWriteTool } from '../../../tools/write.js';
 import { makeMockClient } from '../../helpers/mock-client.js';
+import { assertHasFormattedWarning, assertNoFormattedWarnings } from '../../helpers/request-matchers.js';
 
 vi.mock('../../../enrichers.js', () => ({
   enrichBlock: vi.fn(async (block: any) => block),
@@ -29,6 +30,26 @@ describe('replace_block_range — validation', () => {
     ).rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleWriteTool('replace_block_range', { post_id: 1.5, start: 0, count: 1, blocks: [] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleWriteTool('replace_block_range', { post_id: -1, start: 0, count: 1, blocks: [] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('replace_block_range', {
+        post_id: Number.MAX_SAFE_INTEGER + 1, start: 0, count: 1, blocks: [],
+      }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires start', async () => {
     await expect(
       handleWriteTool('replace_block_range', { post_id: 1, count: 1, blocks: [] }, client as any)
@@ -46,6 +67,24 @@ describe('replace_block_range — validation', () => {
       handleWriteTool('replace_block_range', { post_id: 1, start: 0, count: 1 }, client as any)
     ).rejects.toThrow('block');
   });
+
+  it('rejects a fractional start', async () => {
+    await expect(
+      handleWriteTool('replace_block_range', { post_id: 1, start: 1.5, count: 1, blocks: [] }, client as any)
+    ).rejects.toThrow('start must be a non-negative integer');
+  });
+
+  it('rejects a NaN count', async () => {
+    await expect(
+      handleWriteTool('replace_block_range', { post_id: 1, start: 0, count: NaN, blocks: [] }, client as any)
+    ).rejects.toThrow('count must be a non-negative integer');
+  });
+
+  it('rejects an Infinity start', async () => {
+    await expect(
+      handleWriteTool('replace_block_range', { post_id: 1, start: Infinity, count: 1, blocks: [] }, client as any)
+    ).rejects.toThrow('start must be a non-negative integer');
+  });
 });
 
 describe('replace_block_range — forwarding', () => {
@@ -88,3 +127,35 @@ describe('replace_block_range — forwarding', () => {
     expect(client.replaceBlocksRange).toHaveBeenCalled();
   });
 });
+
+describe('replace_block_range — warning enrichment', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('adds formatted_warnings when response has warnings', async () => {
+    client.replaceBlocksRange = vi.fn().mockResolvedValue({
+      success: true, removed: 1,
+      inserted: [{ index: 0, name: 'oldns/heading' }],
+      warnings: [{ block: 'oldns/heading', message: 'AVOID', suggested_replacement: 'core/heading' }],
+      before_revision_id: 1, revision_id: 2,
+    }) as any;
+    const result = await handleWriteTool('replace_block_range', {
+      post_id: 1, start: 0, count: 1, blocks: [{ name: 'oldns/heading' }],
+    }, client as any);
+    assertHasFormattedWarning(result, 'WARNING');
+    assertHasFormattedWarning(result, 'oldns/heading');
+  });
+
+  it('no formatted_warnings when response has none', async () => {
+    client.replaceBlocksRange = vi.fn().mockResolvedValue({
+      success: true, removed: 1,
+      inserted: [{ index: 0, name: 'core/heading' }],
+      warnings: [],
+      before_revision_id: 1, revision_id: 2,
+    }) as any;
+    const result = await handleWriteTool('replace_block_range', {
+      post_id: 1, start: 0, count: 1, blocks: [{ name: 'core/heading' }],
+    }, client as any);
+    assertNoFormattedWarnings(result);
+  });
+});

package/src/__tests__/tools/write/rewrite_post_blocks.test.ts

@@ -29,6 +29,27 @@ describe('rewrite_post_blocks — validation', () => {
     ).rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleWriteTool('rewrite_post_blocks', { post_id: 1.5, blocks: [{ name: 'core/paragraph' }] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleWriteTool('rewrite_post_blocks', { post_id: -1, blocks: [{ name: 'core/paragraph' }] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('rewrite_post_blocks', {
+        post_id: Number.MAX_SAFE_INTEGER + 1,
+        blocks: [{ name: 'core/paragraph' }],
+      }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires at least one block', async () => {
     await expect(
       handleWriteTool('rewrite_post_blocks', { post_id: 1 }, client as any)
@@ -108,6 +129,24 @@ describe('revert_to_revision — validation', () => {
     ).rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleWriteTool('revert_to_revision', { post_id: 1.5, revision_id: 1 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleWriteTool('revert_to_revision', { post_id: -1, revision_id: 1 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('revert_to_revision', { post_id: Number.MAX_SAFE_INTEGER + 1, revision_id: 1 }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires revision_id', async () => {
     await expect(
       handleWriteTool('revert_to_revision', { post_id: 1 }, client as any)

package/src/__tests__/tools/write/update_block.test.ts

@@ -48,6 +48,22 @@ describe('update_block — validation', () => {
       .rejects.toThrow('post_id');
   });
 
+  it('rejects a float post_id', async () => {
+    await expect(handleWriteTool('update_block', { post_id: 1.5, flat_index: 0, attributes: {} }, client as any))
+      .rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(handleWriteTool('update_block', { post_id: -1, flat_index: 0, attributes: {} }, client as any))
+      .rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('update_block', { post_id: Number.MAX_SAFE_INTEGER + 1, flat_index: 0, attributes: {} }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
   it('requires flat_index OR ref (not neither)', async () => {
     await expect(handleWriteTool('update_block', { post_id: 1, attributes: {} }, client as any))
       .rejects.toThrow(/Provide either flat_index/);

package/src/__tests__/tools/write/update_blocks.test.ts

@@ -33,6 +33,27 @@ describe('update_blocks — validation: post_id', () => {
       handleWriteTool('update_blocks', { updates: [{ ref: 'blk_a', innerHTML: 'x' }] }, client as any)
     ).rejects.toThrow('post_id');
   });
+
+  it('rejects a float post_id', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { post_id: 1.5, updates: [{ ref: 'blk_a', innerHTML: 'x' }] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects a negative post_id', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { post_id: -1, updates: [{ ref: 'blk_a', innerHTML: 'x' }] }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
+
+  it('rejects an overflow post_id', async () => {
+    await expect(
+      handleWriteTool('update_blocks', {
+        post_id: Number.MAX_SAFE_INTEGER + 1,
+        updates: [{ ref: 'blk_a', innerHTML: 'x' }],
+      }, client as any)
+    ).rejects.toThrow('post_id must be a positive integer');
+  });
 });
 
 describe('update_blocks — validation: updates array', () => {

package/src/__tests__/tools/yoast/yoast_get_seo.test.ts

@@ -33,9 +33,17 @@ describe('yoast_get_seo — validation', () => {
     expect(client.getYoastSEO).not.toHaveBeenCalled();
   });
 
-  it('rejects string post_id (must be number)', async () => {
-    await expect(handleYoastTool('yoast_get_seo', { post_id: '42' }, client as any))
-      .rejects.toThrow('post_id');
+  // Coerces a numeric-string post_id (parity with get_post_info / update_post),
+  // rejecting only a genuinely non-numeric value.
+  it('coerces a numeric-string post_id', async () => {
+    client.getYoastSEO.mockResolvedValue(yoastSEOResponse);
+    await handleYoastTool('yoast_get_seo', { post_id: '42' }, client as any);
+    expect(client.getYoastSEO).toHaveBeenCalledWith(42);
+  });
+
+  it('rejects a non-numeric post_id string', async () => {
+    await expect(handleYoastTool('yoast_get_seo', { post_id: 'abc' }, client as any))
+      .rejects.toThrow('post_id must be a positive integer');
     expect(client.getYoastSEO).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/tools/yoast/yoast_update_seo.test.ts

@@ -26,6 +26,22 @@ describe('yoast_update_seo — schema', () => {
     const tool = YOAST_TOOLS.find((t) => t.name === 'yoast_update_seo')!;
     expect(tool.inputSchema.required).toContain('post_id');
   });
+
+  // Regression: some AI clients (e.g. Google Gemini) reject a "null" member in a
+  // JSON Schema `type` array and 400 the entire tools/list request, taking down
+  // every tool on the server. noindex must advertise a single scalar type; the
+  // handler still accepts an explicit null (see "noindex tri-state" tests below).
+  it('advertises noindex as a single boolean type, never a ["boolean","null"] array', () => {
+    const tool = YOAST_TOOLS.find((t) => t.name === 'yoast_update_seo')!;
+    const props = tool.inputSchema.properties as unknown as Record<string, { type?: unknown }>;
+    expect(props.noindex.type).toBe('boolean');
+    // Guard the whole shared field set: no property may use a type array containing "null".
+    for (const [name, schema] of Object.entries(props)) {
+      if (Array.isArray(schema.type)) {
+        expect(schema.type, `${name} uses a type array containing "null"`).not.toContain('null');
+      }
+    }
+  });
 });
 
 describe('yoast_update_seo — validation', () => {

package/src/__tests__/unit/client/ref-endpoints.test.ts

@@ -191,12 +191,9 @@ describe('Client — mutateBlockTree ref/path body', () => {
     expect(body).not.toHaveProperty('ref');
   });
 
-  it('forwards before_ref in move body', async () => {
-    const client = makeClient();
-    await client.mutateBlockTree(42, { op: 'move', ref: 'blk_source', before_ref: 'blk_anchor' });
-    const req = captured.find((r) => r.method === 'POST' && r.url === '/posts/42/mutate');
-    expect((req!.data as Record<string, unknown>).before_ref).toBe('blk_anchor');
-  });
+  // NOTE: `before_ref`/`before` were removed from MutationRequest — the REST
+  // route only accepts `destination`/`destination_ref`, so forwarding the
+  // aliases pinned a param the server silently dropped.
 
   it('forwards destination_ref in move body', async () => {
     const client = makeClient();

package/src/__tests__/unit/enrichers/cbp-enricher.test.ts

@@ -185,6 +185,27 @@ describe('enrichBlock — Code Block Pro', () => {
     expect(textareaContent).toContain('</textarea>');
   });
 
+  /**
+   * Regression: when the enricher replaces an existing <pre class="shiki"> in
+   * innerHTML, the highlighted codeHTML was passed as the String.replace
+   * REPLACEMENT string, so a `$`-sequence in the source ($$ -> $, $& -> the
+   * whole matched <pre>) was interpreted as a replacement pattern and corrupted
+   * the rendered code. The replacement must be literal.
+   */
+  it('preserves $-sequences in code when replacing existing innerHTML', async () => {
+    const block: BlockDef = {
+      name: 'kevinbatdorf/code-block-pro',
+      attributes: { code: 'A $$MONEY$$ B $& C', language: 'plaintext', copyButton: false },
+      innerHTML: '<div class="wp-block-kevinbatdorf-code-block-pro"><pre class="shiki css-variables"><code>OLD</code></pre></div>',
+    };
+    const result = await enrichBlock(block);
+    expect(result.innerHTML).toContain('$$MONEY$$');
+    // $& would otherwise splice the whole old <pre> back in; the old content
+    // must be gone and the literal $& (shiki escapes the ampersand) preserved.
+    expect(result.innerHTML).not.toContain('OLD');
+    expect(result.innerHTML).toContain('$&#x26;');
+  });
+
   /**
    * Wrapper-style values come straight from caller-supplied attributes. A
    * value containing `"` (whether malicious or just a quoted font-name like