@open-mercato/ai-assistant 0.5.1-develop.3036.f02c281f23 → 0.5.1-develop.3045.b4b3320cc2

package/src/modules/ai_assistant/lib/__tests__/pending-action-recheck.test.ts

@@ -0,0 +1,378 @@
+import { z } from 'zod'
+import type { AwilixContainer } from 'awilix'
+import {
+  checkAgentAndFeatures,
+  checkAttachmentScope,
+  checkRecordVersion,
+  checkStatusAndExpiry,
+  checkToolWhitelist,
+  runPendingActionRechecks,
+  type PendingActionAuthContext,
+} from '../pending-action-recheck'
+import type { AiAgentDefinition } from '../ai-agent-definition'
+import type { AiToolDefinition } from '../types'
+import type { AiPendingAction } from '../../data/entities'
+
+const findWithDecryptionMock = jest.fn()
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findWithDecryption: (...args: unknown[]) => findWithDecryptionMock(...args),
+  findOneWithDecryption: jest.fn(),
+}))
+
+jest.mock('@open-mercato/core/modules/attachments/data/entities', () => ({
+  Attachment: class Attachment {},
+  AttachmentPartition: class AttachmentPartition {},
+}))
+
+function makeAction(overrides: Partial<AiPendingAction> = {}): AiPendingAction {
+  return {
+    id: 'pa_1',
+    tenantId: 'tenant-1',
+    organizationId: 'org-1',
+    agentId: 'catalog.merchandising_assistant',
+    toolName: 'catalog.update_product',
+    status: 'pending',
+    fieldDiff: [{ field: 'title', before: 'Old', after: 'New' }],
+    records: null,
+    failedRecords: null,
+    sideEffectsSummary: null,
+    recordVersion: 'v-1',
+    attachmentIds: [],
+    normalizedInput: { productId: 'p-1', patch: { title: 'New' } },
+    queueMode: 'inline',
+    executionResult: null,
+    targetEntityType: 'product',
+    targetRecordId: 'p-1',
+    conversationId: null,
+    idempotencyKey: 'idem_1',
+    createdByUserId: 'user-1',
+    createdAt: new Date('2026-04-18T10:00:00.000Z'),
+    expiresAt: new Date('2026-04-18T11:00:00.000Z'),
+    resolvedAt: null,
+    resolvedByUserId: null,
+    ...overrides,
+  } as unknown as AiPendingAction
+}
+
+function makeAgent(overrides: Partial<AiAgentDefinition> = {}): AiAgentDefinition {
+  return {
+    id: 'catalog.merchandising_assistant',
+    moduleId: 'catalog',
+    label: 'Catalog Agent',
+    description: '...',
+    systemPrompt: '...',
+    allowedTools: ['catalog.update_product'],
+    readOnly: false,
+    mutationPolicy: 'confirm-required',
+    ...overrides,
+  }
+}
+
+function makeTool(overrides: Partial<AiToolDefinition> = {}): AiToolDefinition {
+  return {
+    name: 'catalog.update_product',
+    description: 'Update a product',
+    inputSchema: z.object({
+      productId: z.string(),
+      patch: z.object({ title: z.string() }).partial(),
+    }),
+    handler: async () => ({ ok: true, recordId: 'p-1' }),
+    isMutation: true,
+    loadBeforeRecord: async () => ({
+      recordId: 'p-1',
+      entityType: 'catalog.product',
+      recordVersion: 'v-1',
+      before: { title: 'Old' },
+    }),
+    ...overrides,
+  } as AiToolDefinition
+}
+
+function makeCtx(overrides: Partial<PendingActionAuthContext> = {}): PendingActionAuthContext {
+  return {
+    tenantId: 'tenant-1',
+    organizationId: 'org-1',
+    userId: 'user-1',
+    userFeatures: ['ai_assistant.view', 'catalog.view', 'catalog.manage'],
+    isSuperAdmin: false,
+    container: {
+      resolve: (name: string) => {
+        if (name === 'em') return {}
+        throw new Error(`unknown dep ${name}`)
+      },
+    } as unknown as AwilixContainer,
+    em: {} as never,
+    ...overrides,
+  }
+}
+
+describe('pending-action-recheck guards', () => {
+  beforeEach(() => {
+    findWithDecryptionMock.mockReset()
+  })
+
+  describe('checkStatusAndExpiry', () => {
+    it('passes for pending + unexpired', () => {
+      const result = checkStatusAndExpiry(makeAction(), {
+        now: new Date('2026-04-18T10:30:00.000Z'),
+      })
+      expect(result.ok).toBe(true)
+    })
+
+    it('rejects cancelled with 409 invalid_status', () => {
+      const result = checkStatusAndExpiry(makeAction({ status: 'cancelled' as never }))
+      expect(result).toMatchObject({ ok: false, status: 409, code: 'invalid_status' })
+    })
+
+    it('rejects expired with 409 expired', () => {
+      const result = checkStatusAndExpiry(makeAction(), {
+        now: new Date('2026-04-18T12:00:00.000Z'),
+      })
+      expect(result).toMatchObject({ ok: false, status: 409, code: 'expired' })
+    })
+  })
+
+  describe('checkAgentAndFeatures', () => {
+    it('passes when caller carries the agent features', () => {
+      const result = checkAgentAndFeatures(makeAgent({ requiredFeatures: ['catalog.view'] }), makeCtx())
+      expect(result.ok).toBe(true)
+    })
+
+    it('rejects unknown agent with 404', () => {
+      const result = checkAgentAndFeatures(null, makeCtx())
+      expect(result).toMatchObject({ ok: false, status: 404, code: 'agent_unknown' })
+    })
+
+    it('rejects missing feature with 403 agent_features_denied', () => {
+      const result = checkAgentAndFeatures(
+        makeAgent({ requiredFeatures: ['catalog.manage.full'] }),
+        makeCtx({ userFeatures: ['catalog.view'] }),
+      )
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'agent_features_denied' })
+    })
+  })
+
+  describe('checkToolWhitelist', () => {
+    it('passes for whitelisted mutation tool', () => {
+      const result = checkToolWhitelist(makeAgent(), makeTool(), makeAction())
+      expect(result.ok).toBe(true)
+    })
+
+    it('rejects missing tool with 403 tool_not_whitelisted', () => {
+      const result = checkToolWhitelist(makeAgent(), null, makeAction())
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'tool_not_whitelisted' })
+    })
+
+    it('rejects tool dropped from allowedTools with 403', () => {
+      const result = checkToolWhitelist(
+        makeAgent({ allowedTools: [] }),
+        makeTool(),
+        makeAction(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'tool_not_whitelisted' })
+    })
+
+    it('rejects non-mutation tool with 403 tool_not_whitelisted', () => {
+      const result = checkToolWhitelist(
+        makeAgent(),
+        makeTool({ isMutation: false }),
+        makeAction(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'tool_not_whitelisted' })
+    })
+
+    it('rejects read-only override with 403 read_only_agent', () => {
+      const result = checkToolWhitelist(makeAgent(), makeTool(), makeAction(), {
+        mutationPolicyOverride: 'read-only',
+      })
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'read_only_agent' })
+    })
+  })
+
+  describe('checkAttachmentScope', () => {
+    it('passes when attachmentIds is empty', async () => {
+      const result = await checkAttachmentScope(makeAction({ attachmentIds: [] }), makeCtx())
+      expect(result.ok).toBe(true)
+      expect(findWithDecryptionMock).not.toHaveBeenCalled()
+    })
+
+    it('passes when every attachment belongs to the caller tenant', async () => {
+      findWithDecryptionMock.mockResolvedValueOnce([
+        { id: 'a-1', tenantId: 'tenant-1', organizationId: 'org-1' },
+        { id: 'a-2', tenantId: 'tenant-1', organizationId: 'org-1' },
+      ])
+      const result = await checkAttachmentScope(
+        makeAction({ attachmentIds: ['a-1', 'a-2'] }),
+        makeCtx(),
+      )
+      expect(result.ok).toBe(true)
+    })
+
+    it('rejects cross-tenant attachment id with 403', async () => {
+      findWithDecryptionMock.mockResolvedValueOnce([
+        { id: 'a-1', tenantId: 'tenant-1', organizationId: 'org-1' },
+        { id: 'a-2', tenantId: 'tenant-2', organizationId: 'org-x' },
+      ])
+      const result = await checkAttachmentScope(
+        makeAction({ attachmentIds: ['a-1', 'a-2'] }),
+        makeCtx(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'attachment_cross_tenant' })
+    })
+
+    it('rejects when lookup returns fewer rows than requested ids', async () => {
+      findWithDecryptionMock.mockResolvedValueOnce([
+        { id: 'a-1', tenantId: 'tenant-1', organizationId: 'org-1' },
+      ])
+      const result = await checkAttachmentScope(
+        makeAction({ attachmentIds: ['a-1', 'a-2'] }),
+        makeCtx(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 403, code: 'attachment_cross_tenant' })
+    })
+  })
+
+  describe('checkRecordVersion (single-record)', () => {
+    it('passes when stored version matches current', async () => {
+      const result = await checkRecordVersion(makeAction(), makeTool(), makeCtx())
+      expect(result.ok).toBe(true)
+    })
+
+    it('rejects mismatch with 412 stale_version', async () => {
+      const result = await checkRecordVersion(
+        makeAction({ recordVersion: 'v-1' } as never),
+        makeTool({
+          loadBeforeRecord: async () => ({
+            recordId: 'p-1',
+            entityType: 'catalog.product',
+            recordVersion: 'v-2',
+            before: { title: 'Old' },
+          }),
+        }),
+        makeCtx(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 412, code: 'stale_version' })
+    })
+
+    it('rejects schema drift with 412 schema_drift', async () => {
+      const tool = makeTool({
+        inputSchema: z.object({ productId: z.string(), newTitle: z.string() }),
+      })
+      const result = await checkRecordVersion(
+        makeAction({ normalizedInput: { productId: 'p-1', patch: { title: 'x' } } } as never),
+        tool,
+        makeCtx(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 412, code: 'schema_drift' })
+    })
+  })
+
+  describe('checkRecordVersion (batch)', () => {
+    function makeBatchAction() {
+      return makeAction({
+        records: [
+          {
+            recordId: 'r-1',
+            entityType: 'catalog.product',
+            label: 'P1',
+            fieldDiff: [],
+            recordVersion: 'v-1',
+          },
+          {
+            recordId: 'r-2',
+            entityType: 'catalog.product',
+            label: 'P2',
+            fieldDiff: [],
+            recordVersion: 'v-1',
+          },
+          {
+            recordId: 'r-3',
+            entityType: 'catalog.product',
+            label: 'P3',
+            fieldDiff: [],
+            recordVersion: 'v-1',
+          },
+        ],
+        normalizedInput: {
+          records: [
+            { recordId: 'r-1', patch: { title: 'a' } },
+            { recordId: 'r-2', patch: { title: 'b' } },
+            { recordId: 'r-3', patch: { title: 'c' } },
+          ],
+        },
+      } as never)
+    }
+
+    function makeBatchTool(currentVersions: Record<string, string>) {
+      return makeTool({
+        inputSchema: z.object({
+          records: z.array(
+            z.object({ recordId: z.string(), patch: z.object({ title: z.string() }).partial() }),
+          ),
+        }),
+        isBulk: true,
+        loadBeforeRecord: undefined,
+        loadBeforeRecords: async () =>
+          Object.entries(currentVersions).map(([recordId, recordVersion]) => ({
+            recordId,
+            entityType: 'catalog.product',
+            label: recordId,
+            recordVersion,
+            before: { title: 'X' },
+          })),
+      })
+    }
+
+    it('partial-stale: returns ok:true + failedRecords[] with only the stale ids', async () => {
+      const result = await checkRecordVersion(
+        makeBatchAction(),
+        makeBatchTool({ 'r-1': 'v-1', 'r-2': 'v-2', 'r-3': 'v-1' }),
+        makeCtx(),
+      )
+      expect(result.ok).toBe(true)
+      if (result.ok) {
+        expect(result.failedRecords).toEqual([
+          {
+            recordId: 'r-2',
+            error: { code: 'stale_version', message: 'Record version changed since preview.' },
+          },
+        ])
+      }
+    })
+
+    it('all stale: returns 412 stale_version', async () => {
+      const result = await checkRecordVersion(
+        makeBatchAction(),
+        makeBatchTool({ 'r-1': 'v-9', 'r-2': 'v-9', 'r-3': 'v-9' }),
+        makeCtx(),
+      )
+      expect(result).toMatchObject({ ok: false, status: 412, code: 'stale_version' })
+    })
+  })
+
+  describe('runPendingActionRechecks', () => {
+    it('runs every guard in order and returns ok when all pass', async () => {
+      findWithDecryptionMock.mockResolvedValueOnce([])
+      const result = await runPendingActionRechecks({
+        action: makeAction(),
+        agent: makeAgent(),
+        tool: makeTool(),
+        ctx: makeCtx(),
+        now: new Date('2026-04-18T10:30:00.000Z'),
+      })
+      expect(result.ok).toBe(true)
+    })
+
+    it('bubbles up first failure (expired before agent check)', async () => {
+      const result = await runPendingActionRechecks({
+        action: makeAction(),
+        agent: null,
+        tool: null,
+        ctx: makeCtx(),
+        now: new Date('2026-04-18T12:00:00.000Z'),
+      })
+      expect(result).toMatchObject({ ok: false, code: 'expired' })
+    })
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/phase-0-additive-contract.test.ts

@@ -0,0 +1,299 @@
+import { z } from 'zod'
+import {
+  registerGeneratedAiToolEntries,
+  type AiToolConfigEntry,
+} from '../tool-loader'
+import { toolRegistry } from '../tool-registry'
+import { convertMcpToolsToAiSdk } from '../mcp-tool-adapter'
+import { defineAiTool } from '../ai-tool-definition'
+import type {
+  AiToolDefinition,
+  McpToolDefinition,
+} from '../types'
+import type { InProcessMcpClient, ToolInfoWithSchema } from '../in-process-client'
+import { createAiAgentsExtension } from '../../../../../../cli/src/lib/generators/extensions/ai-agents'
+
+type PlainAiToolInput = { q: string }
+type PlainAiToolOutput = { echo: string; name: string }
+
+function makePlainAiTool(name: string): AiToolDefinition<PlainAiToolInput, PlainAiToolOutput> {
+  return {
+    name,
+    description: `Tool ${name}`,
+    inputSchema: z.object({ q: z.string() }),
+    requiredFeatures: [`${name}.view`],
+    handler: async (input) => ({ echo: input.q, name }),
+  }
+}
+
+function makeFakeAgentEntry(moduleId: string, agentCount: number) {
+  return {
+    moduleId,
+    agents: Array.from({ length: agentCount }, (_, index) => ({
+      id: `${moduleId}.agent_${index}`,
+      moduleId,
+      label: `${moduleId} agent ${index}`,
+      description: 'fixture',
+      systemPrompt: 'fixture',
+      allowedTools: [] as string[],
+    })),
+  }
+}
+
+function buildInProcessClient(result: unknown): {
+  client: InProcessMcpClient
+  callToolMock: jest.Mock
+} {
+  const callToolMock = jest.fn(async () => ({ success: true, result }))
+  const client = { callTool: callToolMock } as unknown as InProcessMcpClient
+  return { client, callToolMock }
+}
+
+describe('Phase 0 — restored module-tool loading is additive — existing modules still register', () => {
+  beforeEach(() => {
+    toolRegistry.clear()
+  })
+
+  afterAll(() => {
+    toolRegistry.clear()
+  })
+
+  it('registers plain-object aiTools[] exports through the restored loader', () => {
+    const entries: AiToolConfigEntry[] = [
+      { moduleId: 'legacy_module', tools: [makePlainAiTool('legacy_search')] },
+    ]
+
+    const registered = registerGeneratedAiToolEntries(entries)
+
+    expect(registered).toBe(1)
+    expect(toolRegistry.getTool('legacy_search')).toBeDefined()
+    expect(toolRegistry.listToolsByModule('legacy_module')).toEqual(['legacy_search'])
+  })
+
+  it('resolves registered tools through the mcp-tool-adapter without shape loss', async () => {
+    const plainTool = makePlainAiTool('legacy_query')
+    registerGeneratedAiToolEntries([{ moduleId: 'legacy_module', tools: [plainTool] }])
+
+    const registered = toolRegistry.getTool('legacy_query')
+    expect(registered).toBeDefined()
+    if (!registered) return
+
+    const mcpTools: ToolInfoWithSchema[] = [
+      {
+        name: registered.name,
+        description: registered.description,
+        inputSchema: registered.inputSchema,
+      },
+    ]
+
+    const { client, callToolMock } = buildInProcessClient({ rows: 0 })
+    const aiSdkTools = convertMcpToolsToAiSdk(client, mcpTools)
+
+    expect(Object.keys(aiSdkTools)).toEqual(['legacy_query'])
+    const adapted = aiSdkTools.legacy_query as unknown as {
+      description: string
+      execute: (args: unknown) => Promise<string>
+    }
+    expect(adapted.description).toBe(registered.description)
+
+    await adapted.execute({ q: 'hello' })
+    expect(callToolMock).toHaveBeenCalledWith('legacy_query', { q: 'hello' })
+  })
+
+  it('is idempotent — re-running the loader does not duplicate registrations', () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const entries: AiToolConfigEntry[] = [
+      { moduleId: 'legacy_module', tools: [makePlainAiTool('legacy_query')] },
+    ]
+
+    registerGeneratedAiToolEntries(entries)
+    registerGeneratedAiToolEntries(entries)
+
+    expect(toolRegistry.listToolsByModule('legacy_module')).toEqual(['legacy_query'])
+    expect(toolRegistry.listToolNames()).toEqual(['legacy_query'])
+    warnSpy.mockRestore()
+  })
+
+  it('stays silent for modules without an ai-tools.ts export', () => {
+    const entries: AiToolConfigEntry[] = [
+      { moduleId: 'empty_module', tools: [] },
+      { moduleId: 'missing_module', tools: undefined as unknown as unknown[] },
+    ]
+
+    expect(() => registerGeneratedAiToolEntries(entries)).not.toThrow()
+    expect(toolRegistry.listToolNames()).toEqual([])
+  })
+})
+
+describe('Phase 0 — `defineAiTool()` return value is compatible with the plain-object shape', () => {
+  beforeEach(() => {
+    toolRegistry.clear()
+  })
+
+  afterAll(() => {
+    toolRegistry.clear()
+  })
+
+  it('builder output and plain-object definition are structurally equivalent on required fields', () => {
+    const schema = z.object({ id: z.string() })
+    const handler = async (input: { id: string }) => ({ ok: true, id: input.id })
+
+    const builderTool = defineAiTool({
+      name: 'catalog.touch',
+      description: 'Touch a catalog record',
+      inputSchema: schema,
+      handler,
+    })
+
+    const plainTool: AiToolDefinition<{ id: string }, { ok: boolean; id: string }> = {
+      name: 'catalog.touch',
+      description: 'Touch a catalog record',
+      inputSchema: schema,
+      handler,
+    }
+
+    expect(builderTool.name).toBe(plainTool.name)
+    expect(builderTool.description).toBe(plainTool.description)
+    expect(builderTool.inputSchema).toBe(plainTool.inputSchema)
+    expect(builderTool.handler).toBe(plainTool.handler)
+    expect(builderTool.requiredFeatures).toBeUndefined()
+    expect(plainTool.requiredFeatures).toBeUndefined()
+    expect(builderTool.displayName).toBeUndefined()
+    expect(builderTool.tags).toBeUndefined()
+    expect(builderTool.isMutation).toBeUndefined()
+    expect(builderTool.maxCallsPerTurn).toBeUndefined()
+    expect(builderTool.supportsAttachments).toBeUndefined()
+  })
+
+  it('builder output is assignable to both AiToolDefinition and McpToolDefinition', () => {
+    const built = defineAiTool({
+      name: 'meta.ping',
+      description: 'Ping',
+      inputSchema: z.object({}),
+      handler: async () => ({ pong: true }),
+    })
+    const asAi: AiToolDefinition = built
+    const asMcp: McpToolDefinition = built
+    expect(asAi.name).toBe('meta.ping')
+    expect(asMcp.name).toBe('meta.ping')
+  })
+
+  it('both shapes register through the same loader path and produce identical registry entries', () => {
+    const schema = z.object({ id: z.string() })
+    const handler = async () => ({ ok: true })
+
+    const builderTool = defineAiTool({
+      name: 'builder_tool',
+      description: 'Builder-built tool',
+      inputSchema: schema,
+      handler,
+      displayName: 'Builder tool',
+      tags: ['builder'],
+      isMutation: false,
+      maxCallsPerTurn: 3,
+      supportsAttachments: false,
+    })
+
+    const plainTool: AiToolDefinition = {
+      name: 'plain_tool',
+      description: 'Plain tool',
+      inputSchema: schema,
+      handler,
+    }
+
+    registerGeneratedAiToolEntries([
+      { moduleId: 'mixed_module', tools: [builderTool, plainTool] },
+    ])
+
+    expect(toolRegistry.listToolsByModule('mixed_module').sort()).toEqual([
+      'builder_tool',
+      'plain_tool',
+    ])
+    const registeredBuilder = toolRegistry.getTool('builder_tool')
+    const registeredPlain = toolRegistry.getTool('plain_tool')
+    expect(registeredBuilder?.name).toBe('builder_tool')
+    expect(registeredBuilder?.description).toBe('Builder-built tool')
+    expect(typeof registeredBuilder?.handler).toBe('function')
+    expect(registeredPlain?.name).toBe('plain_tool')
+    expect(registeredPlain?.description).toBe('Plain tool')
+    expect(typeof registeredPlain?.handler).toBe('function')
+  })
+})
+
+describe('Phase 0 — `ai-agents.generated.ts` discovery is additive — does not break `ai-tools.generated.ts` consumption', () => {
+  beforeEach(() => {
+    toolRegistry.clear()
+  })
+
+  afterAll(() => {
+    toolRegistry.clear()
+  })
+
+  it('loads tools and ignores agent entries when both are present', () => {
+    const toolEntries: AiToolConfigEntry[] = [
+      { moduleId: 'catalog', tools: [makePlainAiTool('catalog_search')] },
+      { moduleId: 'customers', tools: [makePlainAiTool('customers_search')] },
+    ]
+    const agentEntries = [
+      makeFakeAgentEntry('catalog', 1),
+      makeFakeAgentEntry('customers', 2),
+    ]
+
+    const toolsRegistered = registerGeneratedAiToolEntries(toolEntries)
+
+    expect(toolsRegistered).toBe(2)
+    expect(toolRegistry.listToolNames().sort()).toEqual([
+      'catalog_search',
+      'customers_search',
+    ])
+    for (const agentModule of agentEntries) {
+      for (const agent of agentModule.agents) {
+        expect(toolRegistry.getTool(agent.id)).toBeUndefined()
+      }
+    }
+  })
+
+  it('still loads tools when only legacy `aiToolConfigEntries` exists (pre-agents fixture)', () => {
+    const entries: AiToolConfigEntry[] = [
+      { moduleId: 'legacy_only', tools: [makePlainAiTool('legacy_only_tool')] },
+    ]
+
+    const registered = registerGeneratedAiToolEntries(entries)
+
+    expect(registered).toBe(1)
+    expect(toolRegistry.getTool('legacy_only_tool')).toBeDefined()
+  })
+
+  it('registers zero tools and does not throw when only agent entries exist', () => {
+    const registered = registerGeneratedAiToolEntries([])
+
+    expect(registered).toBe(0)
+    expect(toolRegistry.listToolNames()).toEqual([])
+  })
+})
+
+describe('Phase 0 — generator output is stable across runs', () => {
+  it('`createAiAgentsExtension()` produces byte-identical output across repeated runs', () => {
+    const firstExtension = createAiAgentsExtension()
+    const secondExtension = createAiAgentsExtension()
+
+    const firstOutput = firstExtension.generateOutput().get('ai-agents.generated.ts')
+    const secondOutput = secondExtension.generateOutput().get('ai-agents.generated.ts')
+
+    expect(firstOutput).toBeDefined()
+    expect(secondOutput).toBeDefined()
+    expect(firstOutput).toBe(secondOutput)
+    expect(firstOutput?.startsWith('// AUTO-GENERATED')).toBe(true)
+    expect(firstOutput).toContain('export const aiAgentConfigEntries')
+    expect(firstOutput).toContain('export const allAiAgents')
+  })
+
+  it('calling `generateOutput()` twice on the same factory instance produces identical text', () => {
+    const extension = createAiAgentsExtension()
+
+    const firstRun = extension.generateOutput().get('ai-agents.generated.ts')
+    const secondRun = extension.generateOutput().get('ai-agents.generated.ts')
+
+    expect(firstRun).toBe(secondRun)
+  })
+})