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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.5.1-develop.3036.f02c281f23",
+  "version": "0.5.1-develop.3045.b4b3320cc2",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -59,8 +59,8 @@
     "@mikro-orm/decorators": "^7.0.13",
     "@mikro-orm/migrations": "^7.0.13",
     "@mikro-orm/postgresql": "^7.0.13",
-    "@open-mercato/queue": "0.5.1-develop.3036.f02c281f23",
-    "@open-mercato/shared": "0.5.1-develop.3036.f02c281f23",
+    "@open-mercato/queue": "0.5.1-develop.3045.b4b3320cc2",
+    "@open-mercato/shared": "0.5.1-develop.3045.b4b3320cc2",
     "cross-spawn": "^7.0.6",
     "pg": "8.20.0",
     "semver": "^7.7.4",
@@ -70,10 +70,10 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.5.1-develop.3036.f02c281f23"
+    "@open-mercato/shared": "0.5.1-develop.3045.b4b3320cc2"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.5.1-develop.3036.f02c281f23",
+    "@open-mercato/shared": "0.5.1-develop.3045.b4b3320cc2",
     "@types/jest": "^30.0.0",
     "jest": "^30.3.0",
     "ts-jest": "^29.4.9"

package/src/__tests__/mercato.test.ts

@@ -630,6 +630,7 @@ describe('server dev managed process exits', () => {
   afterEach(() => {
     jest.dontMock('child_process')
     jest.dontMock('node:fs')
+    jest.dontMock('../lib/dev-env-reload')
     jest.dontMock('../lib/generators')
     jest.dontMock('../lib/resolver')
     jest.resetModules()
@@ -844,4 +845,115 @@ describe('server start managed process exits', () => {
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })
+
+  it('restarts the managed dev runtime when an app env file changes', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    let envChangeCallback: ((filePath: string) => void) | null = null
+    let reloadCount = 0
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          candidate.includes('next/dist/bin/next') || candidate.includes('@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: jest.fn(),
+      }
+    })
+    jest.doMock('../lib/dev-env-reload', () => ({
+      createDevEnvReloader: () => ({
+        reload: jest.fn(() => {
+          reloadCount += 1
+          process.env.RESTART_TOKEN = reloadCount === 1 ? 'initial' : 'changed'
+        }),
+        getWatchedFiles: () => ['/tmp/test-app/.env'],
+      }),
+      watchDevEnvFiles: jest.fn((_appDir: string, onChange: (filePath: string) => void) => {
+        envChangeCallback = onChange
+        return jest.fn()
+      }),
+    }))
+    jest.doMock('../lib/generators', () => ({
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+      createResolver: () => ({}),
+    }))
+    jest.doMock('child_process', () => {
+      const { EventEmitter } = jest.requireActual('node:events')
+      let nextSpawnCount = 0
+
+      const createChild = (
+        autoExit?: { code: number | null; signal?: NodeJS.Signals | null },
+      ) => {
+        const child = new EventEmitter() as any
+        child.stdout = new EventEmitter()
+        child.stderr = new EventEmitter()
+        child.killed = false
+        child.exitCode = null
+        child.signalCode = null
+        child.kill = jest.fn((signal: NodeJS.Signals = 'SIGTERM') => {
+          child.killed = true
+          if (child.exitCode !== null || child.signalCode !== null) {
+            return true
+          }
+          child.signalCode = signal
+          queueMicrotask(() => {
+            child.emit('exit', null, signal)
+          })
+          return true
+        })
+
+        if (autoExit) {
+          queueMicrotask(() => {
+            if (child.exitCode !== null || child.signalCode !== null) return
+            child.exitCode = autoExit.code
+            child.signalCode = autoExit.signal ?? null
+            child.emit('exit', child.exitCode, child.signalCode)
+          })
+        }
+
+        return child
+      }
+
+      return {
+        spawn: jest.fn((_command: string, args: string[]) => {
+          if (args[0]?.includes('next/dist/bin/next')) {
+            nextSpawnCount += 1
+            if (nextSpawnCount === 1) {
+              queueMicrotask(() => envChangeCallback?.('/tmp/test-app/.env'))
+              return createChild()
+            }
+            return createChild({ code: null, signal: 'SIGTERM' })
+          }
+          return createChild()
+        }),
+      }
+    })
+
+    const mercado = await import('../mercato')
+    const exitCode = await mercado.run(['node', 'mercato', 'server', 'dev'])
+    const { spawn } = await import('child_process')
+    const nextSpawns = (spawn as jest.Mock).mock.calls.filter((call) =>
+      call[1]?.[0]?.includes('next/dist/bin/next'),
+    )
+
+    expect(exitCode).toBe(0)
+    expect(nextSpawns).toHaveLength(2)
+    expect(nextSpawns[0][2].env.RESTART_TOKEN).toBe('initial')
+    expect(nextSpawns[1][2].env.RESTART_TOKEN).toBe('changed')
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '[server] Detected environment file change (.env). Restarting app runtime...',
+    )
+
+    delete process.env.RESTART_TOKEN
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
 })

package/src/lib/__integration__/TC-INT-007.spec.ts

@@ -0,0 +1,228 @@
+import { expect, test } from '@playwright/test'
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const repoRoot = path.resolve(__dirname, '..', '..', '..', '..', '..')
+const cliBin = path.join(repoRoot, 'packages', 'cli', 'dist', 'bin.js')
+const fixtureModulePackage = path.join(
+  repoRoot,
+  'packages',
+  'cli',
+  'src',
+  'lib',
+  '__fixtures__',
+  'official-module-package',
+)
+
+function yarnBinary(): string {
+  return process.platform === 'win32' ? 'yarn.cmd' : 'yarn'
+}
+
+function runCommand(command: string, args: string[], cwd: string): string {
+  const yarnCacheFolder = path.join(cwd, '.yarn', 'cache')
+  return execFileSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0',
+      NODE_NO_WARNINGS: '1',
+      YARN_CACHE_FOLDER: yarnCacheFolder,
+      YARN_ENABLE_GLOBAL_CACHE: '0',
+      YARN_ENABLE_IMMUTABLE_INSTALLS: '0',
+      YARN_NODE_LINKER: 'node-modules',
+    },
+  })
+}
+
+function runMercato(args: string[], cwd: string): string {
+  return runCommand(process.execPath, [cliBin, ...args], cwd)
+}
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, content)
+}
+
+function createCoreWorkspacePackage(rootDir: string, relativeDir: string): string {
+  const coreDir = path.join(rootDir, relativeDir)
+  writeFile(
+    path.join(coreDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: '@open-mercato/core',
+        version: '0.4.7',
+        type: 'module',
+      },
+      null,
+      2,
+    ),
+  )
+  return coreDir
+}
+
+function createMonorepoFixture(rootDir: string): string {
+  writeFile(
+    path.join(rootDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'cli-module-monorepo-fixture',
+        private: true,
+        workspaces: ['apps/*', 'packages/*'],
+      },
+      null,
+      2,
+    ),
+  )
+  writeFile(
+    path.join(rootDir, '.yarnrc.yml'),
+    ['nodeLinker: node-modules', 'enableGlobalCache: false', 'cacheFolder: ./.yarn/cache', ''].join('\n'),
+  )
+  createCoreWorkspacePackage(rootDir, path.join('packages', 'core'))
+
+  const appDir = path.join(rootDir, 'apps', 'mercato')
+  writeFile(
+    path.join(appDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: '@open-mercato/app',
+        version: '0.0.0',
+        private: true,
+      },
+      null,
+      2,
+    ),
+  )
+  writeFile(path.join(appDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+  return appDir
+}
+
+function createStandaloneFixture(rootDir: string): string {
+  writeFile(
+    path.join(rootDir, '.yarnrc.yml'),
+    ['nodeLinker: node-modules', 'enableGlobalCache: false', 'cacheFolder: ./.yarn/cache', ''].join('\n'),
+  )
+  createCoreWorkspacePackage(rootDir, path.join('vendor', 'core'))
+  writeFile(
+    path.join(rootDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'cli-module-standalone-fixture',
+        private: true,
+        dependencies: {
+          '@open-mercato/core': 'file:./vendor/core',
+        },
+      },
+      null,
+      2,
+    ),
+  )
+  writeFile(path.join(rootDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+  return rootDir
+}
+
+function readFile(filePath: string): string {
+  return fs.readFileSync(filePath, 'utf8')
+}
+
+test.describe('TC-INT-007: CLI official module install and eject flows', () => {
+  test('module add installs and registers a package-backed module in a monorepo app', () => {
+    const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-cli-monorepo-'))
+
+    try {
+      const appDir = createMonorepoFixture(rootDir)
+      runCommand(yarnBinary(), ['install'], rootDir)
+
+      runMercato(
+        [
+          'module',
+          'add',
+          `@open-mercato/test-package@file:${fixtureModulePackage}`,
+        ],
+        rootDir,
+      )
+
+      const modulesSource = readFile(path.join(appDir, 'src', 'modules.ts'))
+      const cssSource = readFile(path.join(appDir, '.mercato', 'generated', 'module-package-sources.css'))
+      const appPackageJson = JSON.parse(readFile(path.join(appDir, 'package.json'))) as {
+        dependencies?: Record<string, string>
+      }
+
+      expect(modulesSource).toContain("{ id: 'test_package', from: '@open-mercato/test-package' }")
+      expect(cssSource).toContain('node_modules/@open-mercato/test-package/src/**/*.{ts,tsx}')
+      expect(appPackageJson.dependencies?.['@open-mercato/test-package']).toBeTruthy()
+    } finally {
+      fs.rmSync(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('module add --eject copies module source and omits package CSS entries', () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-cli-standalone-source-'))
+
+    try {
+      createStandaloneFixture(appDir)
+      runCommand(yarnBinary(), ['install'], appDir)
+
+      runMercato(
+        [
+          'module',
+          'add',
+          `@open-mercato/test-package@file:${fixtureModulePackage}`,
+          '--eject',
+        ],
+        appDir,
+      )
+
+      const modulesSource = readFile(path.join(appDir, 'src', 'modules.ts'))
+      const cssSource = readFile(path.join(appDir, '.mercato', 'generated', 'module-package-sources.css'))
+
+      expect(modulesSource).toContain("{ id: 'test_package', from: '@app' }")
+      expect(fs.existsSync(path.join(appDir, 'src', 'modules', 'test_package', 'index.ts'))).toBe(true)
+      expect(cssSource).toBe('')
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+
+  test('module enable supports package-backed and ejected flows plus both eject entrypoints', () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-cli-standalone-eject-'))
+
+    try {
+      createStandaloneFixture(appDir)
+      runCommand(yarnBinary(), ['install'], appDir)
+      runCommand(
+        yarnBinary(),
+        ['add', `@open-mercato/test-package@file:${fixtureModulePackage}`],
+        appDir,
+      )
+
+      runMercato(['module', 'enable', '@open-mercato/test-package'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain(
+        "{ id: 'test_package', from: '@open-mercato/test-package' }",
+      )
+
+      writeFile(path.join(appDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+      fs.rmSync(path.join(appDir, 'src', 'modules', 'test_package'), { recursive: true, force: true })
+      runMercato(['module', 'enable', '@open-mercato/test-package', '--eject'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain("{ id: 'test_package', from: '@app' }")
+      expect(fs.existsSync(path.join(appDir, 'src', 'modules', 'test_package', 'index.ts'))).toBe(true)
+      expect(readFile(path.join(appDir, '.mercato', 'generated', 'module-package-sources.css'))).toBe('')
+
+      writeFile(path.join(appDir, 'src', 'modules.ts'), "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n")
+      fs.rmSync(path.join(appDir, 'src', 'modules', 'test_package'), { recursive: true, force: true })
+      runMercato(['module', 'eject', 'test_package'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain("{ id: 'test_package', from: '@app' }")
+
+      writeFile(path.join(appDir, 'src', 'modules.ts'), "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n")
+      fs.rmSync(path.join(appDir, 'src', 'modules', 'test_package'), { recursive: true, force: true })
+      runMercato(['eject', 'test_package'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain("{ id: 'test_package', from: '@app' }")
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/lib/__tests__/dev-env-reload.test.ts

@@ -0,0 +1,62 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createDevEnvReloader, resolveDevEnvFilePaths } from '../dev-env-reload'
+
+describe('dev env reload helpers', () => {
+  let appDir: string
+
+  beforeEach(() => {
+    appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'om-dev-env-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(appDir, { recursive: true, force: true })
+  })
+
+  it('resolves app env files in low-to-high dev precedence order', () => {
+    expect(resolveDevEnvFilePaths('/tmp/app')).toEqual([
+      '/tmp/app/.env',
+      '/tmp/app/.env.development',
+      '/tmp/app/.env.local',
+      '/tmp/app/.env.development.local',
+    ])
+  })
+
+  it('reloads changed app env files without overriding shell-provided values', () => {
+    fs.writeFileSync(path.join(appDir, '.env'), [
+      'APP_URL=http://env.example',
+      'DATABASE_URL=postgres://env-database',
+      'REMOVED_LATER=present',
+    ].join('\n'))
+    fs.writeFileSync(path.join(appDir, '.env.local'), [
+      'APP_URL=http://local.example',
+      'SHELL_VALUE=env-file-value',
+    ].join('\n'))
+
+    const environment: NodeJS.ProcessEnv = {
+      SHELL_VALUE: 'shell-value',
+    }
+    const reloader = createDevEnvReloader(appDir, environment, Object.entries(environment))
+
+    reloader.reload()
+
+    expect(environment.APP_URL).toBe('http://local.example')
+    expect(environment.DATABASE_URL).toBe('postgres://env-database')
+    expect(environment.SHELL_VALUE).toBe('shell-value')
+    expect(environment.REMOVED_LATER).toBe('present')
+
+    fs.writeFileSync(path.join(appDir, '.env'), [
+      'APP_URL=http://env.example',
+      'DATABASE_URL=postgres://changed-database',
+    ].join('\n'))
+    fs.rmSync(path.join(appDir, '.env.local'))
+
+    reloader.reload()
+
+    expect(environment.APP_URL).toBe('http://env.example')
+    expect(environment.DATABASE_URL).toBe('postgres://changed-database')
+    expect(environment.SHELL_VALUE).toBe('shell-value')
+    expect(environment.REMOVED_LATER).toBeUndefined()
+  })
+})

package/src/lib/dev-env-reload.ts

@@ -0,0 +1,110 @@
+import dotenv from 'dotenv'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const DEV_ENV_PRIORITY = [
+  '.env',
+  '.env.development',
+  '.env.local',
+  '.env.development.local',
+] as const
+
+export type DevEnvReloader = {
+  reload: () => void
+  getWatchedFiles: () => string[]
+}
+
+export function resolveDevEnvFilePaths(appDir: string): string[] {
+  return DEV_ENV_PRIORITY.map((fileName) => path.join(appDir, fileName))
+}
+
+export function createDevEnvReloader(
+  appDir: string,
+  environment: NodeJS.ProcessEnv = process.env,
+  baseEnvironmentEntries: Iterable<[string, string | undefined]> = Object.entries(environment),
+): DevEnvReloader {
+  const baseEnvironment = new Map<string, string | undefined>(
+    Array.from(baseEnvironmentEntries, ([key, value]) => [key, value]),
+  )
+  const managedKeys = new Set<string>()
+  const envFilePaths = resolveDevEnvFilePaths(appDir)
+
+  const resetManagedKeys = () => {
+    for (const key of managedKeys) {
+      const baseValue = baseEnvironment.get(key)
+      if (baseValue === undefined) {
+        delete environment[key]
+      } else {
+        environment[key] = baseValue
+      }
+    }
+    managedKeys.clear()
+  }
+
+  const reload = () => {
+    resetManagedKeys()
+
+    for (const envFilePath of envFilePaths) {
+      if (!fs.existsSync(envFilePath)) continue
+
+      const parsed = dotenv.parse(fs.readFileSync(envFilePath))
+      for (const [key, value] of Object.entries(parsed)) {
+        if (baseEnvironment.has(key) && baseEnvironment.get(key) !== undefined) {
+          continue
+        }
+        environment[key] = value
+        managedKeys.add(key)
+      }
+    }
+  }
+
+  return {
+    reload,
+    getWatchedFiles: () => [...envFilePaths],
+  }
+}
+
+export function watchDevEnvFiles(
+  appDir: string,
+  onChange: (filePath: string) => void,
+  options: { debounceMs?: number } = {},
+): () => void {
+  const debounceMs = options.debounceMs ?? 250
+  const envFilePaths = resolveDevEnvFilePaths(appDir)
+  const timers = new Map<string, NodeJS.Timeout>()
+  const watchers = envFilePaths.map((envFilePath) => {
+    const watchDir = path.dirname(envFilePath)
+    const watchFileName = path.basename(envFilePath)
+
+    if (!fs.existsSync(watchDir)) return null
+
+    try {
+      return fs.watch(watchDir, (eventType, fileName) => {
+        if (eventType !== 'change' && eventType !== 'rename') return
+        if (String(fileName ?? '') !== watchFileName) return
+
+        const existingTimer = timers.get(envFilePath)
+        if (existingTimer) {
+          clearTimeout(existingTimer)
+        }
+
+        timers.set(envFilePath, setTimeout(() => {
+          timers.delete(envFilePath)
+          onChange(envFilePath)
+        }, debounceMs))
+      })
+    } catch {
+      return null
+    }
+  }).filter((watcher): watcher is fs.FSWatcher => watcher !== null)
+
+  return () => {
+    for (const timer of timers.values()) {
+      clearTimeout(timer)
+    }
+    timers.clear()
+    for (const watcher of watchers) {
+      watcher.close()
+    }
+  }
+}

package/src/lib/generators/__tests__/module-subset.test.ts

@@ -1383,6 +1383,7 @@ describe('all generated files are valid with varying subsets', () => {
       'search.generated.ts',
       'notifications.generated.ts',
       'ai-tools.generated.ts',
+      'ai-agents.generated.ts',
       'events.generated.ts',
       'analytics.generated.ts',
       'translations-fields.generated.ts',
@@ -1441,6 +1442,19 @@ describe('all generated files are valid with varying subsets', () => {
     expect(aiTools).not.toContain('no_ai')
   })
 
+  it('ai-agents.generated.ts is empty when no module provides ai-agents.ts', async () => {
+    scaffoldModule(tmpDir, 'no_ai_agents', 'pkg', ['setup.ts'])
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'no_ai_agents', from: '@open-mercato/core' },
+    ])
+    await generateModuleRegistry({ resolver, quiet: true })
+
+    const aiAgents = readGenerated(tmpDir, 'ai-agents.generated.ts')!
+    expect(aiAgents).toContain('export const aiAgentConfigEntries')
+    expect(aiAgents).toContain('export const allAiAgents')
+    expect(aiAgents).not.toContain('no_ai_agents')
+  })
+
   it('security generated registries are empty when no module provides security convention files', async () => {
     scaffoldModule(tmpDir, 'no_security', 'pkg', ['setup.ts'])
     touchFile(

package/src/lib/generators/__tests__/output-snapshots.test.ts

@@ -370,6 +370,22 @@ export default aiTools
 `,
   )
 
+  // -- AI agents --
+  touchFile(
+    pkgModulePath('orders', 'ai-agents.ts'),
+    `export const aiAgents = [
+  {
+    id: 'orders.assistant',
+    module: 'orders',
+    displayName: 'Orders Assistant',
+    allowedTools: ['list_orders'],
+    readOnly: true,
+  },
+]
+export default aiAgents
+`,
+  )
+
   // -- Frontend middleware --
   touchFile(
     pkgModulePath('orders', 'frontend', 'middleware.ts'),
@@ -652,6 +668,7 @@ function captureGeneratedFiles(): Map<string, string> {
 describe('generator output compatibility', () => {
   const registryFiles = [
     'ai-tools.generated.ts',
+    'ai-agents.generated.ts',
     'analytics.generated.ts',
     'api-routes.generated.ts',
     'backend-middleware.generated.ts',

package/src/lib/generators/__tests__/scanner.test.ts

@@ -380,7 +380,7 @@ describe('resolveModuleFile', () => {
   it('app override takes precedence for all convention files', () => {
     const conventionFiles = [
       'acl.ts', 'ce.ts', 'search.ts', 'notifications.ts',
-      'ai-tools.ts', 'events.ts', 'analytics.ts', 'setup.ts',
+      'ai-tools.ts', 'ai-agents.ts', 'events.ts', 'analytics.ts', 'setup.ts',
       'translations.ts', 'security.mfa-providers.ts', 'security.sudo.ts',
       'data/extensions.ts', 'data/fields.ts',
     ]

package/src/lib/generators/__tests__/structural-contracts.test.ts

@@ -209,6 +209,7 @@ function scaffoldFixture(): ModuleEntry[] {
   touchFile(pkgModulePath('orders', 'inbox-actions.ts'), `export const inboxActions = [\n  { type: 'orders.approve', id: 'orders.approve-order', label: 'Approve Order', icon: 'check', description: 'Approve pending', async execute(a: any) { return { ok: true } } },\n]\nexport default inboxActions\n`)
   touchFile(pkgModulePath('orders', 'analytics.ts'), `export const analyticsConfig = {\n  entities: [{ entityId: 'orders:sales_order', requiredFeatures: ['orders.view'], entityConfig: { tableName: 'sales_orders', dateField: 'created_at' }, fieldMappings: { id: { dbColumn: 'id', type: 'uuid' } } }],\n}\nexport default analyticsConfig\n`)
   touchFile(pkgModulePath('orders', 'ai-tools.ts'), `export const aiTools = [\n  { name: 'list_orders', description: 'List recent orders', inputSchema: {}, requiredFeatures: ['orders.view'] },\n]\nexport default aiTools\n`)
+  touchFile(pkgModulePath('orders', 'ai-agents.ts'), `export const aiAgents = [\n  { id: 'orders.assistant', module: 'orders', displayName: 'Orders Assistant', allowedTools: ['list_orders'], readOnly: true },\n]\nexport default aiAgents\n`)
   touchFile(pkgModulePath('orders', 'frontend', 'middleware.ts'), `export const middleware = [\n  { id: 'orders.auth-check', pattern: '/orders/**', handler: async (req: any) => req },\n]\nexport default middleware\n`)
   touchFile(pkgModulePath('orders', 'backend', 'middleware.ts'), `export const middleware = [\n  { id: 'orders.admin-check', pattern: '/backend/orders/**', handler: async (req: any) => req },\n]\nexport default middleware\n`)
   touchFile(pkgModulePath('orders', 'message-types.ts'), `export const messageTypes = [\n  { type: 'orders.order_confirmation', module: 'orders', labelKey: 'orders.messages.confirmation.label', icon: 'mail', color: 'blue', allowReply: false, allowForward: true },\n]\nexport default messageTypes\n`)
@@ -937,6 +938,31 @@ describe('ai-tools.generated.ts', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// ai-agents.generated.ts
+// ---------------------------------------------------------------------------
+
+describe('ai-agents.generated.ts', () => {
+  let content: string
+
+  beforeEach(async () => {
+    const enabled = scaffoldFixture()
+    const resolver = createMockResolver(enabled)
+    await generateModuleRegistry({ resolver, quiet: true })
+    content = readGenerated('ai-agents.generated.ts')
+  })
+
+  it('exports filtered entries and flattened allAiAgents', () => {
+    expect(content).toContain('export const aiAgentConfigEntries')
+    expect(content).toContain('export const allAiAgents')
+  })
+
+  it('has orders module entry with agents property', () => {
+    expectModuleIds(content, ['orders'])
+    expect(content).toContain('agents:')
+  })
+})
+
 // ---------------------------------------------------------------------------
 // translations-fields.generated.ts
 // ---------------------------------------------------------------------------