@open-mercato/cli 0.6.8-develop.6891.1.4dca3f1ad3 → 0.6.8-develop.6892.1.f179677788

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.8-develop.6891.1.4dca3f1ad3",
+  "version": "0.6.8-develop.6892.1.f179677788",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,9 +60,9 @@
     "@mikro-orm/decorators": "^7.1.8",
     "@mikro-orm/migrations": "^7.1.8",
     "@mikro-orm/postgresql": "^7.1.8",
-    "@open-mercato/queue": "0.6.8-develop.6891.1.4dca3f1ad3",
-    "@open-mercato/shared": "0.6.8-develop.6891.1.4dca3f1ad3",
-    "@open-mercato/telemetry": "0.6.8-develop.6891.1.4dca3f1ad3",
+    "@open-mercato/queue": "0.6.8-develop.6892.1.f179677788",
+    "@open-mercato/shared": "0.6.8-develop.6892.1.f179677788",
+    "@open-mercato/telemetry": "0.6.8-develop.6892.1.f179677788",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -73,10 +73,10 @@
     "typescript-js": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.8-develop.6891.1.4dca3f1ad3"
+    "@open-mercato/shared": "0.6.8-develop.6892.1.f179677788"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.8-develop.6891.1.4dca3f1ad3",
+    "@open-mercato/shared": "0.6.8-develop.6892.1.f179677788",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.12"

package/src/__tests__/mercato.test.ts

@@ -716,6 +716,7 @@ describe('generate post-step structural invalidation', () => {
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })
+
 })
 
 describe('server dev managed process exits', () => {
@@ -1263,6 +1264,86 @@ describe('server dev managed process exits', () => {
     consoleLogSpy.mockRestore()
   })
 
+  it('uses lightweight manifest workers instead of handler-bearing CLI modules', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.OM_AUTO_SPAWN_WORKERS_LAZY = 'true'
+    process.env.OM_AUTO_SPAWN_WORKERS_LAZY_MODE = 'shared'
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          pathIncludes(candidate, 'next/dist/bin/next') || pathIncludes(candidate, '@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: 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: () => ({}),
+    }))
+
+    const supervisorClose = jest.fn().mockResolvedValue(undefined)
+    const startLazyWorkerSupervisor = jest.fn(() => ({
+      startedQueues: new Set<string>(),
+      getActiveChild: () => undefined,
+      close: supervisorClose,
+      done: Promise.resolve(),
+    }))
+    jest.doMock('../lib/queue-worker-supervisor', () => ({
+      startLazyWorkerSupervisor,
+    }))
+    jest.doMock('child_process', () =>
+      buildMockChildProcessModule((args) =>
+        pathIncludes(args[0] ?? '', 'next/dist/bin/next') ? { code: null, signal: 'SIGTERM' } : undefined,
+      ),
+    )
+
+    const manifestRegistry = await import('../lib/dev-supervisor-manifest')
+    manifestRegistry.registerDevSupervisorManifest({
+      version: 1,
+      workers: [
+        {
+          id: 'manifest:worker',
+          moduleId: 'manifest',
+          queue: 'manifest-events',
+          concurrency: 1,
+        },
+      ],
+      schedulerStartStatus: 'missing-module',
+      requiresFullBootstrap: false,
+    })
+    const mercato = await import('../mercato')
+    mercato.registerCliModules([eventsWorkerFixture as Module])
+
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+
+    expect(exitCode).toBe(0)
+    expect(startLazyWorkerSupervisor).toHaveBeenCalledTimes(1)
+    const workers = startLazyWorkerSupervisor.mock.calls[0][0].workers
+    expect(workers).toEqual([
+      {
+        id: 'manifest:worker',
+        moduleId: 'manifest',
+        queue: 'manifest-events',
+        concurrency: 1,
+      },
+    ])
+    expect(workers[0]).not.toHaveProperty('handler')
+    expect(supervisorClose).toHaveBeenCalled()
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
   it('starts the lazy scheduler supervisor instead of the scheduler process when OM_AUTO_SPAWN_SCHEDULER_LAZY=true', async () => {
     const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
     const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
@@ -1328,6 +1409,69 @@ describe('server dev managed process exits', () => {
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })
+
+  it('uses the lightweight manifest scheduler status without loading scheduler CLI modules', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_SCHEDULER = 'true'
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+    process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY = 'true'
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          pathIncludes(candidate, 'next/dist/bin/next') || pathIncludes(candidate, '@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: 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: () => ({}),
+    }))
+
+    const schedulerClose = jest.fn().mockResolvedValue(undefined)
+    const startLazySchedulerSupervisor = jest.fn(() => ({
+      started: false,
+      getActiveChild: () => undefined,
+      close: schedulerClose,
+      done: Promise.resolve(),
+    }))
+    jest.doMock('../lib/scheduler-supervisor', () => ({
+      startLazySchedulerSupervisor,
+    }))
+    jest.doMock('child_process', () =>
+      buildMockChildProcessModule((args) =>
+        pathIncludes(args[0] ?? '', 'next/dist/bin/next') ? { code: null, signal: 'SIGTERM' } : undefined,
+      ),
+    )
+
+    const manifestRegistry = await import('../lib/dev-supervisor-manifest')
+    manifestRegistry.registerDevSupervisorManifest({
+      version: 1,
+      workers: [],
+      schedulerStartStatus: 'ok',
+      requiresFullBootstrap: false,
+    })
+    const mercato = await import('../mercato')
+
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+
+    expect(exitCode).toBe(0)
+    expect(startLazySchedulerSupervisor).toHaveBeenCalledTimes(1)
+    expect(schedulerClose).toHaveBeenCalled()
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
 })
 
 describe('server start managed process exits', () => {

package/src/bin.ts

@@ -8,37 +8,10 @@ import {
   getTelemetryRuntime,
   isTelemetryBackendEnabled,
 } from '@open-mercato/shared/lib/telemetry/runtime'
+import { resolveCliBootstrapMode, type CliBootstrapMode } from './lib/cli-bootstrap-mode.js'
 // `run` is imported dynamically inside `main()` so telemetry can initialize
 // before the mercato entry (and its Postgres driver) loads — see main().
 
-// Commands that can run without bootstrap (without generated files)
-// - generate: creates the generated files
-// - db: uses resolver directly to find modules and migrations
-// - init: runs yarn commands to set up the app
-// - help: just shows help text
-const BOOTSTRAP_FREE_COMMANDS = [
-  'generate',
-  'module',
-  'deploy',
-  'db',
-  'init',
-  'agentic:init',
-  'telemetry',
-  'eject',
-  'test',
-  'test:integration',
-  'test:integration:coverage',
-  'test:integration:spec-coverage',
-  'test:ephemeral',
-  'test:integration:interactive',
-  'umes:list',
-  'umes:inspect',
-  'umes:check',
-  'help',
-  '--help',
-  '-h',
-]
-
 function assertNode24Runtime(): void {
   const detectedNodeVersion = process.versions.node
   const majorVersion = Number.parseInt(detectedNodeVersion.split('.')[0] ?? '0', 10)
@@ -54,20 +27,30 @@ function assertNode24Runtime(): void {
   )
 }
 
-function needsBootstrap(argv: string[]): boolean {
-  const [, , first] = argv
-  if (!first) return false // help screen
-  return !BOOTSTRAP_FREE_COMMANDS.includes(first)
-}
-
-async function tryBootstrap(): Promise<boolean> {
+async function tryBootstrap(mode: Exclude<CliBootstrapMode, 'none'>): Promise<boolean> {
   try {
-    const { bootstrapFromAppRoot } = await import('@open-mercato/shared/lib/bootstrap/dynamicLoader')
-    const { registerCliModules } = await import('./mercato.js')
     // Use the CLI resolver to find the app directory (handles monorepo detection)
     const { createResolver } = await import('./lib/resolver.js')
     const resolver = createResolver()
     const appDir = resolver.getAppDir()
+
+    if (mode === 'dev-supervisor') {
+      const {
+        canUseLightweightDevSupervisor,
+        loadDevSupervisorManifest,
+        registerDevSupervisorManifest,
+      } = await import(
+        './lib/dev-supervisor-manifest.js'
+      )
+      const manifest = loadDevSupervisorManifest(appDir)
+      if (canUseLightweightDevSupervisor(manifest)) {
+        registerDevSupervisorManifest(manifest)
+        return true
+      }
+    }
+
+    const { bootstrapFromAppRoot } = await import('@open-mercato/shared/lib/bootstrap/dynamicLoader')
+    const { registerCliModules } = await import('./mercato.js')
     const data = await bootstrapFromAppRoot(appDir)
     // Register CLI modules directly to avoid module resolution issues
     registerCliModules(data.modules)
@@ -76,8 +59,11 @@ async function tryBootstrap(): Promise<boolean> {
     const message = err instanceof Error ? err.message : String(err)
     // Check if the error is about missing generated files
     if (
-      message.includes('Cannot find module') &&
-      (message.includes('/generated/') || message.includes('.generated') || message.includes('.mercato'))
+      message.includes('dev-supervisor.generated.json') ||
+      (
+        message.includes('Cannot find module') &&
+        (message.includes('/generated/') || message.includes('.generated') || message.includes('.mercato'))
+      )
     ) {
       return false
     }
@@ -88,9 +74,9 @@ async function tryBootstrap(): Promise<boolean> {
 
 async function main(): Promise<void> {
   assertNode24Runtime()
-  const requiresBootstrap = needsBootstrap(process.argv)
+  const bootstrapMode = resolveCliBootstrapMode(process.argv)
 
-  if (requiresBootstrap) {
+  if (bootstrapMode !== 'none') {
     // Load the app's `.env` BEFORE initTelemetry(): `run()` only dotenv-loads it
     // later (ensureEnvLoaded), which is too late — TELEMETRY_BACKEND set only in
     // `.env` would silently resolve to `noop` for worker/scheduler processes.
@@ -111,7 +97,7 @@ async function main(): Promise<void> {
       await initTelemetry()
     }
 
-    const bootstrapSucceeded = await tryBootstrap()
+    const bootstrapSucceeded = await tryBootstrap(bootstrapMode)
     if (!bootstrapSucceeded) {
       console.error('╔═══════════════════════════════════════════════════════════════════╗')
       console.error('║  Generated files not found!                                       ║')

package/src/lib/__tests__/cli-bootstrap-mode.test.ts

@@ -0,0 +1,22 @@
+import { resolveCliBootstrapMode } from '../cli-bootstrap-mode'
+
+describe('resolveCliBootstrapMode', () => {
+  it('uses the lightweight manifest only for the exact server dev command', () => {
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'server', 'dev'])).toBe('dev-supervisor')
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'server', 'dev', '--port', '4000'])).toBe('dev-supervisor')
+  })
+
+  it('keeps production, workers, scheduler, and module commands on the full bootstrap', () => {
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'server', 'start'])).toBe('full')
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'queue', 'worker', '--all'])).toBe('full')
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'scheduler', 'start'])).toBe('full')
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'customers', 'seed'])).toBe('full')
+  })
+
+  it('preserves existing bootstrap-free commands', () => {
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'generate'])).toBe('none')
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'db', 'generate'])).toBe('none')
+    expect(resolveCliBootstrapMode(['node', 'mercato', 'help'])).toBe('none')
+    expect(resolveCliBootstrapMode(['node', 'mercato'])).toBe('none')
+  })
+})

package/src/lib/__tests__/content-stable-writes.test.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createGeneratorResult, readChecksumRecord, writeGeneratedFile } from '../utils'
+
+describe('content-stable generated writes', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'generated-write-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('updates structure checksum state without touching byte-identical generated output', () => {
+    const outFile = path.join(tmpDir, 'modules.generated.ts')
+    const checksumFile = path.join(tmpDir, 'modules.generated.checksum')
+    const content = '// generated\nexport const modules = []\n'
+
+    writeGeneratedFile({
+      outFile,
+      checksumFile,
+      content,
+      structureChecksum: 'structure-a',
+      result: createGeneratorResult(),
+      quiet: true,
+    })
+
+    const oldTime = new Date(Date.now() - 60_000)
+    fs.utimesSync(outFile, oldTime, oldTime)
+    fs.utimesSync(checksumFile, oldTime, oldTime)
+    const outputMtimeBefore = fs.statSync(outFile).mtimeMs
+
+    const result = createGeneratorResult()
+    writeGeneratedFile({
+      outFile,
+      checksumFile,
+      content,
+      structureChecksum: 'structure-b',
+      result,
+      quiet: true,
+    })
+
+    expect(result.filesWritten).toEqual([])
+    expect(result.filesUnchanged).toEqual([outFile])
+    expect(fs.statSync(outFile).mtimeMs).toBe(outputMtimeBefore)
+    expect(fs.statSync(checksumFile).mtimeMs).toBeGreaterThan(oldTime.getTime())
+    expect(readChecksumRecord(checksumFile)?.structure).toBe('structure-b')
+  })
+
+  it('rewrites generated output when its actual bytes change', () => {
+    const outFile = path.join(tmpDir, 'modules.generated.ts')
+    const checksumFile = path.join(tmpDir, 'modules.generated.checksum')
+    fs.writeFileSync(outFile, 'stale output\n')
+
+    const result = createGeneratorResult()
+    const content = '// generated\nexport const modules = ["customers"]\n'
+    writeGeneratedFile({
+      outFile,
+      checksumFile,
+      content,
+      structureChecksum: 'structure-c',
+      result,
+      quiet: true,
+    })
+
+    expect(result.filesWritten).toEqual([outFile])
+    expect(result.filesUnchanged).toEqual([])
+    expect(fs.readFileSync(outFile, 'utf8')).toBe(content)
+    expect(readChecksumRecord(checksumFile)?.structure).toBe('structure-c')
+  })
+})

package/src/lib/__tests__/dev-supervisor-manifest.test.ts

@@ -0,0 +1,131 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  canUseLightweightDevSupervisor,
+  DEV_SUPERVISOR_MANIFEST_FILE,
+  getRegisteredDevSupervisorManifest,
+  loadDevSupervisorManifest,
+  registerDevSupervisorManifest,
+  resetDevSupervisorManifestForTests,
+} from '../dev-supervisor-manifest'
+
+function writeManifest(appDir: string, value: unknown): string {
+  const filePath = path.join(appDir, '.mercato', 'generated', DEV_SUPERVISOR_MANIFEST_FILE)
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(value), 'utf8')
+  return filePath
+}
+
+describe('dev supervisor manifest', () => {
+  let appDir: string
+
+  beforeEach(() => {
+    appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-dev-supervisor-'))
+    resetDevSupervisorManifestForTests()
+  })
+
+  afterEach(() => {
+    resetDevSupervisorManifestForTests()
+    fs.rmSync(appDir, { recursive: true, force: true })
+  })
+
+  it('loads and registers primitive worker and scheduler metadata', () => {
+    writeManifest(appDir, {
+      version: 1,
+      workers: [
+        {
+          id: 'events:workers:dispatch',
+          moduleId: 'events',
+          queue: 'events',
+          concurrency: 2,
+        },
+      ],
+      schedulerStartStatus: 'ok',
+      requiresFullBootstrap: false,
+    })
+
+    const manifest = loadDevSupervisorManifest(appDir)
+    expect(manifest).toEqual({
+      version: 1,
+      workers: [
+        {
+          id: 'events:workers:dispatch',
+          moduleId: 'events',
+          queue: 'events',
+          concurrency: 2,
+        },
+      ],
+      schedulerStartStatus: 'ok',
+      requiresFullBootstrap: false,
+    })
+
+    expect(canUseLightweightDevSupervisor(manifest)).toBe(true)
+    registerDevSupervisorManifest(manifest)
+    expect(getRegisteredDevSupervisorManifest()).toBe(manifest)
+  })
+
+  it('reports a missing generated manifest with regeneration guidance', () => {
+    expect(() => loadDevSupervisorManifest(appDir)).toThrow(
+      /dev-supervisor\.generated\.json.*Run `yarn generate`/,
+    )
+  })
+
+  it('rejects malformed JSON', () => {
+    const filePath = path.join(appDir, '.mercato', 'generated', DEV_SUPERVISOR_MANIFEST_FILE)
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    fs.writeFileSync(filePath, '{', 'utf8')
+
+    expect(() => loadDevSupervisorManifest(appDir)).toThrow(/JSON could not be parsed/)
+  })
+
+  it('rejects unsupported versions and invalid worker fields', () => {
+    writeManifest(appDir, {
+      version: 2,
+      workers: [],
+      schedulerStartStatus: 'missing-module',
+    })
+    expect(() => loadDevSupervisorManifest(appDir)).toThrow(/unsupported version 2/)
+
+    writeManifest(appDir, {
+      version: 1,
+      workers: [{ id: 'worker', queue: '', concurrency: 1 }],
+      schedulerStartStatus: 'missing-module',
+    })
+    expect(() => loadDevSupervisorManifest(appDir)).toThrow(/workers\[0\]\.queue/)
+  })
+
+  it('rejects unknown scheduler command states', () => {
+    writeManifest(appDir, {
+      version: 1,
+      workers: [],
+      schedulerStartStatus: 'maybe',
+    })
+    expect(() => loadDevSupervisorManifest(appDir)).toThrow(/schedulerStartStatus is invalid/)
+  })
+
+  it('preserves the full-bootstrap fallback marker', () => {
+    writeManifest(appDir, {
+      version: 1,
+      workers: [],
+      schedulerStartStatus: 'ok',
+      requiresFullBootstrap: true,
+    })
+
+    const manifest = loadDevSupervisorManifest(appDir)
+    expect(manifest.requiresFullBootstrap).toBe(true)
+    expect(canUseLightweightDevSupervisor(manifest)).toBe(false)
+  })
+
+  it('treats a legacy version-1 manifest without the safety marker as full-bootstrap only', () => {
+    writeManifest(appDir, {
+      version: 1,
+      workers: [],
+      schedulerStartStatus: 'ok',
+    })
+
+    const manifest = loadDevSupervisorManifest(appDir)
+    expect(manifest.requiresFullBootstrap).toBe(true)
+    expect(canUseLightweightDevSupervisor(manifest)).toBe(false)
+  })
+})

package/src/lib/__tests__/queue-worker-supervisor.test.ts

@@ -65,6 +65,39 @@ async function flushAsync(times = 5): Promise<void> {
 }
 
 describe('startLazyWorkerSupervisor', () => {
+  it('accepts lightweight worker descriptors without importing handlers', async () => {
+    const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
+    const probeFn = jest.fn(async (queueName, strategy) =>
+      emptyProbe(queueName, strategy),
+    ) as jest.MockedFunction<LazySupervisorProbeFn>
+
+    const handle = startLazyWorkerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      workers: [
+        {
+          id: 'events:workers:dispatch',
+          moduleId: 'events',
+          queue: 'events',
+          concurrency: 1,
+        },
+      ],
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      strategy: 'local',
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    expect(probeFn).toHaveBeenCalledWith('events', 'local')
+    expect(spawnFn).not.toHaveBeenCalled()
+
+    await handle.close()
+  })
+
   it('does not spawn any worker while every queue is idle', async () => {
     const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
     const probeFn = jest.fn(async (queueName, strategy) =>

package/src/lib/__tests__/resolver.enterprise.test.ts

@@ -67,6 +67,33 @@ if (enabledModules.some((entry) => entry.id === 'example')) {
   )
 }
 
+function writeModulesConfigWithSupervisorOverrides(rootDir: string) {
+  const srcDir = path.join(rootDir, 'src')
+  fs.mkdirSync(srcDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(srcDir, 'modules.ts'),
+    `
+const supervisorPolicy = { workers: { 'events:dispatch': null } }
+export const enabledModules = [
+  {
+    id: 'events',
+    from: '@open-mercato/events',
+    overrides: {
+      workers: {
+        'events:dispatch': null,
+        'events:replacement': { id: 'events:replacement', queue: 'events-v2', concurrency: 2, handler() {} },
+      },
+      cli: { start: null },
+    },
+  },
+  { id: 'scheduler', overrides: supervisorPolicy },
+  { id: 'queue', overrides: { ...supervisorPolicy } },
+]
+`,
+    'utf8',
+  )
+}
+
 describe('resolver enterprise module toggle', () => {
   const originalEnv = process.env.OM_ENABLE_ENTERPRISE_MODULES
   const originalResolverMarker = (globalThis as Record<string, unknown>).__resolver_evaluated__
@@ -140,4 +167,27 @@ describe('resolver enterprise module toggle', () => {
       ]),
     )
   })
+
+  it('marks inline worker and CLI overrides for the full dev bootstrap', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'resolver-supervisor-overrides-'))
+    writeModulesConfigWithSupervisorOverrides(tempDir)
+
+    expect(createResolver(tempDir).loadEnabledModules()).toEqual([
+      {
+        id: 'events',
+        from: '@open-mercato/events',
+        devSupervisorRequiresFullBootstrap: true,
+      },
+      {
+        id: 'scheduler',
+        from: '@open-mercato/core',
+        devSupervisorRequiresFullBootstrap: true,
+      },
+      {
+        id: 'queue',
+        from: '@open-mercato/core',
+        devSupervisorRequiresFullBootstrap: true,
+      },
+    ])
+  })
 })

package/src/lib/cli-bootstrap-mode.ts

@@ -0,0 +1,31 @@
+export type CliBootstrapMode = 'none' | 'dev-supervisor' | 'full'
+
+const BOOTSTRAP_FREE_COMMANDS = new Set([
+  'generate',
+  'module',
+  'deploy',
+  'db',
+  'init',
+  'agentic:init',
+  'telemetry',
+  'eject',
+  'test',
+  'test:integration',
+  'test:integration:coverage',
+  'test:integration:spec-coverage',
+  'test:ephemeral',
+  'test:integration:interactive',
+  'umes:list',
+  'umes:inspect',
+  'umes:check',
+  'help',
+  '--help',
+  '-h',
+])
+
+export function resolveCliBootstrapMode(argv: readonly string[]): CliBootstrapMode {
+  const [, , first, second] = argv
+  if (!first || BOOTSTRAP_FREE_COMMANDS.has(first)) return 'none'
+  if (first === 'server' && second === 'dev') return 'dev-supervisor'
+  return 'full'
+}