@open-mercato/ai-assistant 0.6.8-develop.7100.1.fbf66fca35 → 0.7.0

package/src/modules/ai_assistant/ai-tools/__tests__/search-pack.test.ts

@@ -2,8 +2,7 @@
  * Step 3.8 — `search.*` tool pack unit tests.
  *
  * Covers `search.hybrid_search` happy path and `search.get_record_context`
- * happy / miss / tenant isolation, plus per-entity ACL enforcement for
- * issue #5211 (legacy pack must not leak records the caller cannot view).
+ * happy / miss / tenant isolation.
  */
 import searchAiTools from '../search-pack'
 
@@ -58,19 +57,6 @@ function makeSearchService(results: unknown[]): {
   }
 }
 
-function makeLookup(configs: Array<{ entityId: string; aclFeatures?: string[]; enabled?: boolean }>) {
-  const map = new Map(configs.map((c) => [c.entityId, c]))
-  return {
-    getEntityConfig: (entityId: string) => map.get(entityId) as any,
-    getAllEntityConfigs: () => configs as any,
-  }
-}
-
-function permissiveLookup(entityIds: string[] = ['catalog:product']) {
-  const configs = entityIds.map((id) => ({ entityId: id, aclFeatures: ['search.view'], enabled: true }))
-  return makeLookup(configs)
-}
-
 describe('search.hybrid_search', () => {
   const tool = findTool('search.hybrid_search')
 
@@ -85,10 +71,8 @@ describe('search.hybrid_search', () => {
       },
     ])
     const ctx = makeCtx()
-    const lookup = permissiveLookup(['catalog:product'])
     ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
       if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
       throw new Error(`unexpected resolve ${name}`)
     })
     const result = (await tool.handler(
@@ -111,12 +95,7 @@ describe('search.hybrid_search', () => {
   it('defaults limit to 20 when omitted', async () => {
     const { service, calls } = makeSearchService([])
     const ctx = makeCtx()
-    const lookup = permissiveLookup(['catalog:product'])
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      return undefined
-    })
+    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
     await tool.handler({ q: 'hello' }, ctx as any)
     expect(calls[0].options.limit).toBe(20)
   })
@@ -126,105 +105,6 @@ describe('search.hybrid_search', () => {
     ;(ctx.container.resolve as jest.Mock).mockReturnValue({ search: jest.fn() })
     await expect(tool.handler({ q: 'x' }, ctx as any)).rejects.toThrow(/Tenant context/)
   })
-
-  it('withholds results for entity types the caller cannot view', async () => {
-    const lookup = makeLookup([
-      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
-      { entityId: 'catalog:catalog_product', aclFeatures: ['catalog.products.view'], enabled: true },
-    ])
-    const { service, calls } = makeSearchService([
-      { entityId: 'customers:customer_person_profile', recordId: 'p1', score: 0.9, source: 'fulltext', presenter: { title: 'Person' } },
-      { entityId: 'catalog:catalog_product', recordId: 'c1', score: 0.8, source: 'fulltext', presenter: { title: 'Product' } },
-    ])
-    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected resolve ${name}`)
-    })
-    const result = (await tool.handler({ q: 'test' }, ctx as any)) as Record<string, unknown>
-    // Should have narrowed entityTypes to only readable type
-    expect((calls[0].options as any).entityTypes).toEqual(['customers:customer_person_profile'])
-    // Defense in depth: results filtered to only readable
-    expect(result.totalResults).toBe(1)
-    expect((result.results as any[])[0].entityId).toBe('customers:customer_person_profile')
-  })
-
-  it('short-circuits without calling search when no entity type is readable for an explicit request', async () => {
-    const lookup = makeLookup([
-      { entityId: 'catalog:catalog_product', aclFeatures: ['catalog.products.view'], enabled: true },
-    ])
-    const { service, calls } = makeSearchService([
-      { entityId: 'catalog:catalog_product', recordId: 'c1', score: 0.8, source: 'fulltext' },
-    ])
-    const ctx = makeCtx({ userFeatures: ['search.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    const result = (await tool.handler({ q: 'test', entityTypes: ['catalog:catalog_product'] }, ctx as any)) as Record<string, unknown>
-    expect(calls).toHaveLength(0)
-    expect(result.totalResults).toBe(0)
-    expect(result.results).toEqual([])
-  })
-
-  it('intersects an explicitly requested mixed set with the readable set', async () => {
-    const lookup = makeLookup([
-      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
-      { entityId: 'catalog:catalog_product', aclFeatures: ['catalog.products.view'], enabled: true },
-      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
-    ])
-    const { service, calls } = makeSearchService([
-      { entityId: 'customers:customer_person_profile', recordId: 'p1', score: 0.9, source: 'fulltext' },
-      { entityId: 'catalog:catalog_product', recordId: 'c1', score: 0.8, source: 'fulltext' },
-    ])
-    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    await tool.handler({ q: 'test', entityTypes: ['customers:customer_person_profile', 'catalog:catalog_product', 'secret:thing'] }, ctx as any)
-    expect((calls[0].options as any).entityTypes).toEqual(['customers:customer_person_profile'])
-  })
-
-  it('drops results a strategy returned for an unreadable entity type (defense in depth)', async () => {
-    const lookup = makeLookup([
-      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
-      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
-    ])
-    const { service } = makeSearchService([
-      { entityId: 'customers:customer_person_profile', recordId: 'p1', score: 0.9, source: 'fulltext' },
-      { entityId: 'secret:thing', recordId: 's1', score: 0.8, source: 'fulltext' },
-    ])
-    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    const result = (await tool.handler({ q: 'test' }, ctx as any)) as Record<string, unknown>
-    expect((result.results as any[]).every((r: any) => r.entityId === 'customers:customer_person_profile')).toBe(true)
-  })
-
-  it('allows a superadmin to see all requested entity types', async () => {
-    const lookup = makeLookup([
-      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
-    ])
-    const { service, calls } = makeSearchService([
-      { entityId: 'secret:thing', recordId: 's1', score: 0.8, source: 'fulltext' },
-    ])
-    const ctx = makeCtx({ userFeatures: [], isSuperAdmin: true })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    const result = (await tool.handler({ q: 'test', entityTypes: ['secret:thing'] }, ctx as any)) as Record<string, unknown>
-    expect(calls[0].options.entityTypes).toEqual(['secret:thing'])
-    expect(result.totalResults).toBe(1)
-  })
 })
 
 describe('search.get_record_context', () => {
@@ -245,12 +125,7 @@ describe('search.get_record_context', () => {
       match,
     ])
     const ctx = makeCtx()
-    const lookup = permissiveLookup(['catalog:product'])
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
+    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
     const result = (await tool.handler(
       { entityId: 'catalog:product', recordId: 'rec-42' },
       ctx as any,
@@ -274,12 +149,7 @@ describe('search.get_record_context', () => {
       { entityId: 'catalog:product', recordId: 'other', score: 0.2, source: 'fulltext' },
     ])
     const ctx = makeCtx()
-    const lookup = permissiveLookup(['catalog:product'])
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
+    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
     const result = (await tool.handler(
       { entityId: 'catalog:product', recordId: 'missing' },
       ctx as any,
@@ -291,12 +161,7 @@ describe('search.get_record_context', () => {
   it('passes the caller tenant/org and never leaks another tenant', async () => {
     const { service, calls } = makeSearchService([])
     const ctx = makeCtx({ tenantId: 'tenant-A', organizationId: 'org-A' })
-    const lookup = permissiveLookup(['x:y'])
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
+    ;(ctx.container.resolve as jest.Mock).mockReturnValue(service)
     await tool.handler({ entityId: 'x:y', recordId: 'z' }, ctx as any)
     expect(calls[0].options).toMatchObject({
       tenantId: 'tenant-A',
@@ -312,77 +177,6 @@ describe('search.get_record_context', () => {
       tool.handler({ entityId: 'x:y', recordId: 'z' }, ctx as any),
     ).rejects.toThrow(/Tenant context/)
   })
-
-  it('rejects an explicitly requested unauthorized entity type', async () => {
-    const lookup = makeLookup([
-      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
-    ])
-    const { service } = makeSearchService([])
-    const ctx = makeCtx({ userFeatures: ['search.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    await expect(
-      tool.handler({ entityId: 'customers:customer_person_profile', recordId: 'rec-1' }, ctx as any),
-    ).rejects.toThrow(/Insufficient permissions/)
-  })
-
-  it('allows an authorized caller to retrieve record context', async () => {
-    const lookup = makeLookup([
-      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
-    ])
-    const { service } = makeSearchService([
-      { entityId: 'customers:customer_person_profile', recordId: 'rec-1', score: 1, source: 'fulltext', presenter: { title: 'Person' }, url: '/backend/customers/people/rec-1', links: [] },
-    ])
-    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    const result = (await tool.handler({ entityId: 'customers:customer_person_profile', recordId: 'rec-1' }, ctx as any)) as Record<string, unknown>
-    expect(result.found).toBe(true)
-    expect((result as any).presenter.title).toBe('Person')
-  })
-
-  it('filters stray results a strategy returned for an unreadable entity (defense in depth)', async () => {
-    const lookup = makeLookup([
-      { entityId: 'customers:customer_person_profile', aclFeatures: ['customers.people.view'], enabled: true },
-      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
-    ])
-    // User can read person, but strategy returns secret thing for same recordId
-    const { service } = makeSearchService([
-      { entityId: 'secret:thing', recordId: 'rec-1', score: 1, source: 'fulltext', presenter: { title: 'Secret' } },
-    ])
-    const ctx = makeCtx({ userFeatures: ['search.view', 'customers.people.view'] })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    // Requesting person, but backend returned secret – should be filtered to not found
-    const result = (await tool.handler({ entityId: 'customers:customer_person_profile', recordId: 'rec-1' }, ctx as any)) as Record<string, unknown>
-    expect(result.found).toBe(false)
-  })
-
-  it('allows a superadmin to retrieve any record context', async () => {
-    const lookup = makeLookup([
-      { entityId: 'secret:thing', aclFeatures: ['secret.view'], enabled: true },
-    ])
-    const { service } = makeSearchService([
-      { entityId: 'secret:thing', recordId: 'rec-1', score: 1, source: 'fulltext', presenter: { title: 'Secret' }, url: '/x', links: [] },
-    ])
-    const ctx = makeCtx({ userFeatures: [], isSuperAdmin: true })
-    ;(ctx.container.resolve as jest.Mock).mockImplementation((name: string) => {
-      if (name === 'searchService') return service
-      if (name === 'searchIndexer') return lookup
-      throw new Error(`unexpected ${name}`)
-    })
-    const result = (await tool.handler({ entityId: 'secret:thing', recordId: 'rec-1' }, ctx as any)) as Record<string, unknown>
-    expect(result.found).toBe(true)
-  })
 })
 
 describe('search-pack tool surface', () => {

package/src/modules/ai_assistant/ai-tools/search-pack.ts

@@ -7,68 +7,13 @@
  */
 import { z } from 'zod'
 import type { SearchOptions, SearchResult, SearchStrategyId } from '@open-mercato/shared/modules/search'
-import {
-  canReadSearchEntity,
-  filterSearchResultsByEntityAccess,
-  resolveReadableEntityTypes,
-  type SearchEntityAccessSubject,
-  type SearchEntityConfigLookup,
-  type SearchEntityDenyReason,
-} from '@open-mercato/shared/lib/search/entityAccess'
 import { defineAiTool } from '../lib/ai-tool-definition'
-import type { AiToolDefinition, McpToolContext } from '../lib/types'
+import type { AiToolDefinition } from '../lib/types'
 
 type SearchServiceLike = {
   search: (query: string, options: SearchOptions) => Promise<SearchResult[]>
 }
 
-class SearchToolAuthorizationError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'SearchToolAuthorizationError'
-  }
-}
-
-function resolveSearchIndexer(ctx: McpToolContext): SearchEntityConfigLookup {
-  try {
-    const indexer = ctx.container.resolve('searchIndexer') as SearchEntityConfigLookup | undefined
-    if (indexer && typeof indexer.getEntityConfig === 'function' && typeof indexer.getAllEntityConfigs === 'function') {
-      return indexer
-    }
-  } catch {
-    // fall through to throw
-  }
-  throw new SearchToolAuthorizationError('[internal] Search entity registry unavailable')
-}
-
-function authorizeEntityAccess(
-  entityType: string,
-  lookup: SearchEntityConfigLookup,
-  subject: SearchEntityAccessSubject,
-): void {
-  if (subject.isSuperAdmin) return
-  let denial: SearchEntityDenyReason | undefined
-  const allowed = canReadSearchEntity(entityType, lookup, subject, {
-    onDeny: (_, reason) => {
-      denial = reason
-    },
-  })
-  if (allowed) return
-  if (denial === 'unconfigured') {
-    throw new SearchToolAuthorizationError(`[internal] Entity type "${entityType}" is not configured for search`)
-  }
-  if (denial === 'no-acl-features') {
-    throw new SearchToolAuthorizationError(
-      `[internal] Entity type "${entityType}" does not declare aclFeatures; access denied`,
-    )
-  }
-  const config = lookup.getEntityConfig(entityType)
-  const required = config?.aclFeatures ?? []
-  throw new SearchToolAuthorizationError(
-    `[internal] Insufficient permissions for entity "${entityType}". Required: ${required.join(', ')}`,
-  )
-}
-
 const hybridSearchInput = z.object({
   q: z.string().min(1).describe('Search query text.'),
   limit: z
@@ -104,52 +49,13 @@ const hybridSearchTool = defineAiTool({
     const service = ctx.container.resolve<SearchServiceLike>('searchService')
     const limit = input.limit ?? 20
     const started = Date.now()
-    const subject: SearchEntityAccessSubject = {
-      grantedFeatures: ctx.userFeatures,
-      isSuperAdmin: ctx.isSuperAdmin,
-    }
-
-    if (ctx.isSuperAdmin) {
-      const results = await service.search(input.q, {
-        tenantId: ctx.tenantId,
-        organizationId: ctx.organizationId,
-        limit,
-        strategies: input.strategies as SearchStrategyId[] | undefined,
-        entityTypes: input.entityTypes,
-      })
-      const timingMs = Date.now() - started
-      const strategiesUsed = Array.from(
-        new Set(results.map((result) => result.source).filter((id): id is SearchStrategyId => typeof id === 'string')),
-      )
-      return {
-        query: input.q,
-        totalResults: results.length,
-        results,
-        strategiesUsed,
-        timing: { ms: timingMs },
-      }
-    }
-
-    const lookup = resolveSearchIndexer(ctx)
-    const readableEntityTypes = resolveReadableEntityTypes(lookup, subject, input.entityTypes)
-    if (readableEntityTypes && readableEntityTypes.length === 0) {
-      return {
-        query: input.q,
-        totalResults: 0,
-        results: [],
-        strategiesUsed: [],
-        timing: { ms: Date.now() - started },
-      }
-    }
-
-    const rawResults = await service.search(input.q, {
+    const results = await service.search(input.q, {
       tenantId: ctx.tenantId,
       organizationId: ctx.organizationId,
       limit,
       strategies: input.strategies as SearchStrategyId[] | undefined,
-      entityTypes: readableEntityTypes,
+      entityTypes: input.entityTypes,
     })
-    const results = filterSearchResultsByEntityAccess(rawResults, lookup, subject)
     const timingMs = Date.now() - started
     const strategiesUsed = Array.from(
       new Set(results.map((result) => result.source).filter((id): id is SearchStrategyId => typeof id === 'string')),
@@ -182,25 +88,13 @@ const getRecordContextTool = defineAiTool({
       throw new Error('Tenant context is required for search.get_record_context')
     }
     const input = getRecordContextInput.parse(rawInput)
-    const subject: SearchEntityAccessSubject = {
-      grantedFeatures: ctx.userFeatures,
-      isSuperAdmin: ctx.isSuperAdmin,
-    }
-
-    let lookup: SearchEntityConfigLookup | undefined
-    if (!ctx.isSuperAdmin) {
-      lookup = resolveSearchIndexer(ctx)
-      authorizeEntityAccess(input.entityId, lookup, subject)
-    }
-
     const service = ctx.container.resolve<SearchServiceLike>('searchService')
-    const rawResults = await service.search(input.recordId, {
+    const results = await service.search(input.recordId, {
       tenantId: ctx.tenantId,
       organizationId: ctx.organizationId,
       limit: 5,
       entityTypes: [input.entityId],
     })
-    const results = lookup ? filterSearchResultsByEntityAccess(rawResults, lookup, subject) : rawResults
     const match = results.find((result) => result.recordId === input.recordId)
     if (!match) {
       return {

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/AiModerationFlagsPageClient.tsx

@@ -32,7 +32,6 @@ type ModerationFlagsResponse = {
   total: number
   page: number
   pageSize: number
-  totalIsCapped?: boolean
 }
 
 async function fetchModerationFlags(params: {
@@ -124,7 +123,6 @@ export function AiModerationFlagsPageClient() {
   )
 
   const total = query.data?.total ?? 0
-  const totalIsCapped = query.data?.totalIsCapped === true
 
   return (
     <div className="flex flex-col gap-4">
@@ -178,7 +176,6 @@ export function AiModerationFlagsPageClient() {
           pageSize: PAGE_SIZE,
           total,
           totalPages: Math.max(1, Math.ceil(total / PAGE_SIZE)),
-          totalIsCapped,
           onPageChange: setPage,
         }}
       />

package/src/modules/ai_assistant/lib/__tests__/generated-registry-loader.test.ts

@@ -36,22 +36,6 @@ function safeJsLiteral(value: string): string {
   return escapeUnsafeJsStringChars(JSON.stringify(value))
 }
 
-describe('Next.js bundle boundary', () => {
-  it('keeps runtime-only imports out of the Next.js bundle', () => {
-    const loaderSource = fs.readFileSync(
-      path.join(__dirname, '..', 'generated-registry-loader.ts'),
-      'utf8',
-    )
-
-    expect(loaderSource).toMatch(
-      /await import\(\s*\/\* webpackIgnore: true \*\/\s*\/\* turbopackIgnore: true \*\/\s*pathToFileURL\(jsPath\)\.href\s*\)/,
-    )
-    expect(loaderSource).toMatch(
-      /await import\(\s*\/\* webpackIgnore: true \*\/\s*\/\* turbopackIgnore: true \*\/\s*'@open-mercato\/shared\/lib\/bootstrap\/dynamicLoader'\s*\)/,
-    )
-  })
-})
-
 describe('rewriteGeneratedAliasImports', () => {
   // Regression for the MCP dev-server crash:
   //   "Cannot find package '@/.mercato' imported from .../tool-loader.js"

package/src/modules/ai_assistant/lib/__tests__/mcp-client.test.ts

@@ -90,34 +90,4 @@ describe('McpClient stdio transport', () => {
     expect(transportArgs.args).not.toContain('omk_secret.value')
     expect(JSON.stringify(transportArgs.args)).not.toContain('omk_secret.value')
   })
-
-  it('preserves all MCP tool annotations returned by a remote server', async () => {
-    mockClientListTools.mockResolvedValueOnce({
-      tools: [{
-        name: 'customers.update_company',
-        description: 'Update a company.',
-        inputSchema: {},
-        annotations: {
-          title: 'Update company',
-          readOnlyHint: false,
-          destructiveHint: false,
-          idempotentHint: true,
-          openWorldHint: false,
-        },
-      }],
-    })
-    const client = await McpClient.connect({ transport: 'stdio', apiKeySecret: 'test-secret' })
-
-    await expect(client.listTools()).resolves.toEqual([
-      expect.objectContaining({
-        annotations: {
-          title: 'Update company',
-          readOnlyHint: false,
-          destructiveHint: false,
-          idempotentHint: true,
-          openWorldHint: false,
-        },
-      }),
-    ])
-  })
 })

package/src/modules/ai_assistant/lib/codemode-tools.ts

@@ -13,7 +13,7 @@ import { createLogger } from '@open-mercato/shared/lib/logger'
 import { z } from 'zod'
 import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
 import { registerMcpTool } from './tool-registry'
-import type { AiToolDefinition, McpToolContext } from './types'
+import type { McpToolContext } from './types'
 import { createSandbox } from './sandbox'
 import { truncateResult } from './truncate'
 import { applyContextScopeToQuery, applyContextScopeToBody } from './scope-injection'
@@ -560,15 +560,6 @@ export const CODE_MODE_MAX_API_CALLS = 50
 /** Maximum mutation (non-GET/HEAD/OPTIONS) api.request() calls allowed per execute() run. */
 export const CODE_MODE_MAX_MUTATION_CALLS = 20
 
-/**
- * Register a Code Mode tool through the typed definition so the optional
- * metadata (`isMutation`, `isDestructive`) survives registration — the MCP
- * `tools/list` annotations are derived from those flags.
- */
-function registerCodeModeTool(tool: AiToolDefinition<{ code: string }>): void {
-  registerMcpTool(tool, { moduleId: 'codemode' })
-}
-
 /**
  * Load and register the two Code Mode tools.
  * Generates TypeScript type stubs for common endpoints at startup.
@@ -585,10 +576,9 @@ export async function loadCodeModeTools(): Promise<number> {
  * search — Query the OpenAPI spec and entity graph programmatically.
  */
 function registerSearchTool(): void {
-  registerCodeModeTool(
+  registerMcpTool(
     {
       name: 'search',
-      isMutation: false,
       description: `Query the OpenAPI spec and entity schemas. READ-ONLY, no side effects.
 Globals: spec.findEndpoints(keyword), spec.describeEndpoint(path, method), spec.describeEntity(keyword), spec.paths, spec.entitySchemas.
 Use BEFORE execute to learn endpoint schemas for CREATE/UPDATE. Skip for common paths (companies, people, orders, quotes, products).`,
@@ -660,7 +650,8 @@ Use BEFORE execute to learn endpoint schemas for CREATE/UPDATE. Skip for common
           _memoryContext: memoryContext,
         }
       },
-    }
+    },
+    { moduleId: 'codemode' }
   )
 }
 
@@ -672,15 +663,9 @@ function registerExecuteTool(commonTypes: string): void {
     ? `\n\n${commonTypes}`
     : ''
 
-  registerCodeModeTool(
+  registerMcpTool(
     {
       name: 'execute',
-      // api.request() reaches every documented endpoint, including POST/PUT/DELETE,
-      // so the tool is neither read-only nor guaranteed non-destructive. It is
-      // intentionally exempt from prepareMutation: arbitrary sandbox code cannot
-      // provide the structured before/after preview that approval flow requires.
-      isMutation: true,
-      isDestructive: true,
       description: `Make API calls. Returns JSON.
 Globals: api.request({ method, path, query?, body? }) → { success, statusCode, data }, context { tenantId, organizationId, userId }.
 RULES: For FIND/LIST → GET only (1 call). For UPDATE → PUT to collection path with id in BODY. NEVER PUT/POST/DELETE unless user explicitly asked to change data. Before ANY write operation (POST/PUT/DELETE), you MUST use the AskUserQuestion tool to get explicit user confirmation. Do NOT just ask in text — use the tool so execution pauses until the user responds.${typesBlock}`,
@@ -764,7 +749,8 @@ RULES: For FIND/LIST → GET only (1 call). For UPDATE → PUT to collection pat
           _memoryContext: memoryContext,
         }
       },
-    }
+    },
+    { moduleId: 'codemode' }
   )
 }
 

package/src/modules/ai_assistant/lib/generated-registry-loader.ts

@@ -121,11 +121,7 @@ export async function compileAndImportGenerated(tsPath: string): Promise<Record<
   if (useJestCjsArtifact) {
     return requireFromHere(jsPath) as Record<string, unknown>
   }
-  return (await import(
-    /* webpackIgnore: true */
-    /* turbopackIgnore: true */
-    pathToFileURL(jsPath).href
-  )) as Record<string, unknown>
+  return (await import(pathToFileURL(jsPath).href)) as Record<string, unknown>
 }
 
 function isJestRuntime(): boolean {
@@ -173,11 +169,7 @@ async function compileAppLocalModuleEntries(
   if (specifiers.length === 0) return artifacts
 
   const generatedDir = path.join(appRoot, '.mercato', 'generated')
-  const { compileAppSourceFile } = await import(
-    /* webpackIgnore: true */
-    /* turbopackIgnore: true */
-    '@open-mercato/shared/lib/bootstrap/dynamicLoader'
-  )
+  const { compileAppSourceFile } = await import('@open-mercato/shared/lib/bootstrap/dynamicLoader')
 
   for (const specifier of specifiers) {
     const target = path.resolve(generatedDir, specifier)

package/src/modules/ai_assistant/lib/http-server.ts

@@ -10,7 +10,6 @@ import { executeTool } from './tool-executor'
 import { loadAllModuleTools, indexToolsForSearch } from './tool-loader'
 import { authenticateMcpRequest, extractApiKeyFromHeaders, hasRequiredFeatures } from './auth'
 import { jsonSchemaToZod, toSafeZodSchema } from './schema-utils'
-import { buildMcpToolAnnotations } from './mcp-tool-annotations'
 import { redactSecretForLog, deriveApiKeySessionId } from './log-redaction'
 import type { McpServerConfig, McpToolContext } from './types'
 import type { SearchService } from '@open-mercato/search/service'
@@ -220,7 +219,6 @@ function createMcpServerForRequest(
         {
           description: tool.description,
           inputSchema: safeSchema,
-          annotations: buildMcpToolAnnotations(tool),
         },
         async (args: unknown) => {
           const toolArgs = (args ?? {}) as Record<string, unknown>

package/src/modules/ai_assistant/lib/in-process-client.ts

@@ -1,7 +1,6 @@
 import type { AwilixContainer } from 'awilix'
 import type { z } from 'zod'
 import { toolInputJsonSchema } from './tool-input-schema'
-import { buildMcpToolAnnotations } from './mcp-tool-annotations'
 import { getToolRegistry } from './tool-registry'
 import { executeTool } from './tool-executor'
 import { loadAllModuleTools } from './tool-loader'
@@ -139,7 +138,6 @@ export class InProcessMcpClient implements McpClientInterface {
       name: tool.name,
       description: tool.description,
       inputSchema: toolInputJsonSchema(tool.inputSchema),
-      annotations: buildMcpToolAnnotations(tool),
     }))
   }
 

package/src/modules/ai_assistant/lib/mcp-client.ts

@@ -147,7 +147,6 @@ export class McpClient implements McpClientInterface {
       name: tool.name,
       description: tool.description ?? '',
       inputSchema: (tool.inputSchema ?? {}) as Record<string, unknown>,
-      annotations: tool.annotations,
     }))
   }
 

package/src/modules/ai_assistant/lib/mcp-dev-server.ts

@@ -8,7 +8,6 @@ import { executeTool } from './tool-executor'
 import { loadAllModuleTools, indexToolsForSearch } from './tool-loader'
 import { authenticateMcpRequest, extractApiKeyFromHeaders, hasRequiredFeatures } from './auth'
 import { jsonSchemaToZod } from './schema-utils'
-import { buildMcpToolAnnotations } from './mcp-tool-annotations'
 import { getApiKeyFromMcpJson } from './mcp-dev-key-resolution'
 import type { McpToolContext } from './types'
 import type { SearchService } from '@open-mercato/search/service'
@@ -112,7 +111,6 @@ function createDevMcpServer(
         {
           description: tool.description,
           inputSchema: safeSchema,
-          annotations: buildMcpToolAnnotations(tool),
         },
         async (args: unknown) => {
           const toolArgs = (args ?? {}) as Record<string, unknown>