@@ -0,0 +1,82 @@
+/**
+ * @vitest-environment node
+ */
+import { NextResponse } from 'next/server'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const { handlers } = vi.hoisted(() => ({
+  handlers: {
+    listBlocks: vi.fn(),
+    getBlock: vi.fn(),
+    latestVersion: vi.fn(),
+  },
+}))
+
+vi.mock('@/lib/api/server/routes/v2-route-table.generated', () => ({
+  V2_ROUTES: [
+    { pattern: '/api/v2/blocks', load: async () => ({ GET: handlers.listBlocks }) },
+    { pattern: '/api/v2/blocks/{blockId}', load: async () => ({ GET: handlers.getBlock }) },
+    {
+      pattern: '/api/v2/blocks/latest',
+      load: async () => ({ GET: handlers.latestVersion }),
+    },
+  ],
+}))
+
+import {
+  createInProcessTransport,
+  matchV2Route,
+} from '@/lib/api/server/routes/in-process-transport'
+import { isInternalRequest } from '@/lib/api/server/routes/internal-request'
+
+describe('in-process transport', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.clearAllMocks()
+  })
+
+  it('prefers the more literal pattern and decodes dynamic segments', async () => {
+    expect(matchV2Route('/api/v2/blocks/latest')?.params).toEqual({})
+    const dynamic = matchV2Route('/api/v2/blocks/slack%20v2')
+    expect(dynamic?.params).toEqual({ blockId: 'slack v2' })
+    expect(matchV2Route('/api/v2/nowhere')).toBeNull()
+  })
+
+  it('dispatches a v2 request to its route handler in-process, marked internal', async () => {
+    handlers.getBlock.mockImplementation(
+      async (request: Request, context: { params: Promise<Record<string, string>> }) =>
+        NextResponse.json({
+          internal: isInternalRequest(request),
+          key: request.headers.get('x-api-key'),
+          query: new URL(request.url).searchParams.get('workspaceId'),
+          params: await context.params,
+        })
+    )
+    const transport = createInProcessTransport()
+
+    const response = await transport('http://internal/api/v2/blocks/agent?workspaceId=ws-1', {
+      method: 'GET',
+      headers: { 'x-api-key': 'secret' },
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({
+      internal: true,
+      key: 'secret',
+      query: 'ws-1',
+      params: { blockId: 'agent' },
+    })
+    expect(handlers.listBlocks).not.toHaveBeenCalled()
+  })
+
+  it('falls through to fetch for anything outside the v2 table', async () => {
+    const network = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('elsewhere'))
+    const transport = createInProcessTransport()
+
+    const response = await transport('http://internal/api/files/serve/abc', { method: 'GET' })
+
+    expect(await response.text()).toBe('elsewhere')
+    expect(network).toHaveBeenCalledTimes(1)
+    expect(handlers.getBlock).not.toHaveBeenCalled()
+  })
+})
@@ -0,0 +1,96 @@
+import { NextRequest } from 'next/server'
+import { markInternalRequest } from '@/lib/api/server/routes/internal-request'
+import { V2_ROUTES } from '@/lib/api/server/routes/v2-route-table.generated'
+
+/**
+ * A `fetch` that answers the server's own v2 requests in-process.
+ *
+ * The embedded CLI and the agent-cli engines are typed v2 clients. Pointing them at
+ * the server's URL made every tool call a network round trip through the proxy,
+ * API-key authentication, the abuse rate limits, and the proxy body ceiling — a
+ * grep over one block definition cost seconds and tripped the per-key limit. This
+ * transport resolves the request's path against the generated route table and
+ * invokes the route handler directly, with the request marked internal so
+ * admission authenticates it but does not rate-limit it. Contracts, use cases,
+ * presenters, and error envelopes are untouched: the handler that runs is the one
+ * the network path would run.
+ *
+ * Anything outside the v2 table falls through to real `fetch`.
+ */
+
+type RouteHandler = (
+  request: NextRequest,
+  context: { params: Promise<Record<string, string>> }
+) => Promise<Response>
+
+interface CompiledRoute {
+  regex: RegExp
+  params: string[]
+  /** Literal segments — a more specific pattern wins over a parameterized one. */
+  literals: number
+  load: () => Promise<object>
+}
+
+interface MatchedRoute {
+  params: Record<string, string>
+  literals: number
+  load: () => Promise<object>
+}
+
+const COMPILED: CompiledRoute[] = V2_ROUTES.map((route) => {
+  const params: string[] = []
+  let literals = 0
+  const source = route.pattern
+    .split('/')
+    .map((segment) => {
+      const param = /^\{(.+)\}$/.exec(segment)
+      if (!param?.[1]) {
+        literals += 1
+        return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      }
+      params.push(param[1])
+      return '([^/]+)'
+    })
+    .join('/')
+  return { regex: new RegExp(`^${source}$`), params, literals, load: route.load }
+})
+
+export function matchV2Route(pathname: string): MatchedRoute | null {
+  let best: MatchedRoute | null = null
+  for (const route of COMPILED) {
+    const match = route.regex.exec(pathname)
+    if (!match) continue
+    if (best && best.literals >= route.literals) continue
+    const params: Record<string, string> = {}
+    route.params.forEach((name, index) => {
+      params[name] = decodeURIComponent(match[index + 1] ?? '')
+    })
+    best = { params, literals: route.literals, load: route.load }
+  }
+  return best
+}
+
+function requestUrl(input: RequestInfo | URL): URL {
+  if (typeof input === 'string') return new URL(input)
+  if (input instanceof URL) return input
+  return new URL(input.url)
+}
+
+export function createInProcessTransport(): typeof fetch {
+  return async (input, init) => {
+    const url = requestUrl(input)
+    const method = (init?.method ?? 'GET').toUpperCase()
+    const matched = url.pathname.startsWith('/api/v2/') ? matchV2Route(url.pathname) : null
+    if (!matched) return fetch(input, init)
+    const handler = Reflect.get(await matched.load(), method)
+    if (typeof handler !== 'function') return fetch(input, init)
+    const request = new NextRequest(url, {
+      method,
+      headers: init?.headers,
+      body: init?.body ?? null,
+      signal: init?.signal ?? undefined,
+    })
+    markInternalRequest(request)
+    return (handler as RouteHandler)(request, { params: Promise.resolve(matched.params) })
+  }
+}
@@ -0,0 +1,22 @@
+/**
+ * Requests the server makes to itself.
+ *
+ * The embedded CLI and the agent-cli engines dispatch to the v2 route handlers
+ * in-process (see `in-process-transport.ts`). Those requests are marked here so
+ * admission can skip the abuse controls that exist for callers arriving over the
+ * network: the pre-auth IP bucket and the per-key rate limits. Authentication is
+ * not skipped — an internal request still carries the caller's key and resolves
+ * to the same principal the network path would.
+ *
+ * A WeakSet keyed by the Request object, not a header: any client on the wire
+ * can set a header; nothing outside this process can reach the set.
+ */
+const INTERNAL_REQUESTS = new WeakSet<Request>()
+
+export function markInternalRequest(request: Request): void {
+  INTERNAL_REQUESTS.add(request)
+}
+
+export function isInternalRequest(request: Request): boolean {
+  return INTERNAL_REQUESTS.has(request)
+}
@@ -28,6 +28,7 @@ class TestLockedError extends HttpError {
 vi.mock('@/lib/api/server/routes/v2-api-key-auth', () => v2ApiKeyAuthModuleMock)
 vi.mock('@/lib/core/rate-limiter', () => v2RateLimiterModuleMock)
 
+import { markInternalRequest } from '@/lib/api/server/routes/internal-request'
 import type { V2ApiKeyAuthContext } from '@/lib/api/server/routes/v2-api-key-auth'
 import {
   defineV2JsonRoute,
@@ -204,6 +205,21 @@ describe('defineV2JsonRoute', () => {
     expect(response.headers.get('Cache-Control')).toBe('private, no-store')
   })
 
+  it('authenticates but never rate-limits a request the server marked as its own', async () => {
+    // The embedded CLI and the agent-cli engines dispatch to these handlers in-process;
+    // the IP bucket and the per-key limits exist for callers on the wire, and a chat
+    // turn's tool calls all land on one key (dev 2026-09-03: grep hit the limit).
+    const internal = request()
+    markInternalRequest(internal)
+
+    const response = await createHandler()(internal)
+
+    expect(response.status).toBe(201)
+    expect(v2RouteMocks.authenticate).toHaveBeenCalledTimes(1)
+    expect(v2RouteMocks.preauthRate).not.toHaveBeenCalled()
+    expect(v2RouteMocks.operationRate).not.toHaveBeenCalled()
+  })
+
   it('fails closed before authentication when the IP bucket cannot admit the request', async () => {
     v2RouteMocks.preauthRate.mockResolvedValueOnce({
       allowed: false,
 
@@ -5,6 +5,7 @@ import {
   methodMatchesContract,
   requireJsonRouteDefinition,
 } from '@/lib/api/server/routes/definition'
+import { isInternalRequest } from '@/lib/api/server/routes/internal-request'
 import type {
   JsonApiRouteContract,
   JsonNextRouteHandler,
@@ -318,7 +319,12 @@ async function admitAuthenticatedV2Request(
     throw new V2RouteInfrastructureError('authentication', error)
   }
 
-  const limited = await rateLimitPolicy.enforce(request, auth, operation)
+  // The server's own requests (embedded CLI, agent-cli engines) are authenticated like
+  // any other but never rate limited: the buckets exist for callers on the wire, and a
+  // chat turn's tool calls all land on one key. See `internal-request.ts`.
+  const limited = isInternalRequest(request)
+    ? null
+    : await rateLimitPolicy.enforce(request, auth, operation)
   return limited ? { success: false, response: limited } : { success: true, auth }
 }
 
@@ -330,7 +336,7 @@ async function admitRateLimitedV2Request(
 ): Promise<
   { success: true; auth: V2ApiKeyAuthContext } | { success: false; response: NextResponse }
 > {
-  const preAuthResponse = await enforceV2PreAuthIpLimit(request)
+  const preAuthResponse = isInternalRequest(request) ? null : await enforceV2PreAuthIpLimit(request)
   if (preAuthResponse) return { success: false, response: preAuthResponse }
   return admitAuthenticatedV2Request(request, operation, authPolicy, rateLimitPolicy)
 }
@@ -355,7 +361,7 @@ export async function admitOptionalV2Request(
 ): Promise<
   { success: true; auth?: V2ApiKeyAuthContext } | { success: false; response: NextResponse }
 > {
-  const preAuthResponse = await enforceV2PreAuthIpLimit(request)
+  const preAuthResponse = isInternalRequest(request) ? null : await enforceV2PreAuthIpLimit(request)
   if (preAuthResponse) return { success: false, response: preAuthResponse }
   if (!request.headers.has('x-api-key')) return { success: true }
   return admitAuthenticatedV2Request(request, operation, authPolicy, rateLimitPolicy)