diff --git a/src/main/services/erp/cleaner.ts b/src/main/services/erp/cleaner.ts
new file mode 100644
index 0000000..5fa93be
--- /dev/null
+++ b/src/main/services/erp/cleaner.ts
@@ -0,0 +1,463 @@
+import { ERP_LOCATORS } from './locators'
+import { ErpAuthService } from './erp-auth'
+import type { CleanerInput, CleanerResult, OrderCleanDetail } from '../../types/cleaner.types'
+import type { ErpSession } from '../../types/erp.types'
+import type { FrameLocator, Locator, Page } from 'playwright'
+
+/**
+ * Cleaner Service Options
+ */
+export interface CleanerOptions {
+  dryRun?: boolean
+  verbose?: boolean
+}
+
+/**
+ * Material deletion check parameters
+ */
+export interface ShouldDeleteParams {
+  rowNumber: number
+  pendingQty: string
+  materialCode: string
+  deleteSet: Set<string>
+}
+
+/**
+ * ERP Cleaner Service
+ * Deletes specified materials from production orders in ERP system
+ *
+ * Reference: playwrite/utils/discrete_material_plan_cleaner.py
+ */
+export class CleanerService {
+  private authService: ErpAuthService
+  private dryRun: boolean
+
+  constructor(authService: ErpAuthService, options: CleanerOptions = {}) {
+    this.authService = authService
+    this.dryRun = options.dryRun ?? false
+  }
+
+  /**
+   * Check if dry-run mode is enabled
+   */
+  isDryRun(): boolean {
+    return this.dryRun
+  }
+
+  /**
+   * Determine if a material should be deleted
+   * Reference: Python lines 284-406
+   *
+   * Deletion conditions:
+   * 1. Material code must be in the delete set
+   * 2. Row number must NOT be in range 7000-7999
+   * 3. Pending quantity must be empty
+   */
+  shouldDeleteMaterial(params: ShouldDeleteParams): boolean {
+    const { rowNumber, pendingQty, materialCode, deleteSet } = params
+
+    // Check if material is in delete list
+    if (!deleteSet.has(materialCode)) {
+      return false
+    }
+
+    // Check row number range (7000-7999 are protected)
+    if (rowNumber >= 7000 && rowNumber < 8000) {
+      return false
+    }
+
+    // Check pending quantity (must be empty)
+    if (pendingQty && pendingQty.trim() !== '') {
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Execute the cleaning process
+   * Reference: Python clean() method lines 456-525
+   */
+  async clean(input: CleanerInput): Promise<CleanerResult> {
+    const result: CleanerResult = {
+      ordersProcessed: 0,
+      materialsDeleted: 0,
+      materialsSkipped: 0,
+      errors: [],
+      details: []
+    }
+
+    // Create delete set for O(1) lookup
+    const deleteSet = new Set(input.materialCodes)
+
+    try {
+      const session = this.authService.getSession()
+
+      // Navigate to cleaner page
+      const { popupPage, workFrame } = await this.navigateToCleanerPage(session)
+
+      // Setup query interface
+      await this.setupQueryInterface(workFrame)
+
+      // Process each order
+      for (let i = 0; i < input.orderNumbers.length; i++) {
+        const orderNumber = input.orderNumbers[i]
+        const progress = ((i + 1) / input.orderNumbers.length) * 100
+
+        input.onProgress?.(
+          `Processing order ${i + 1}/${input.orderNumbers.length}: ${orderNumber}`,
+          progress
+        )
+
+        try {
+          const detail = await this.processOrder({
+            workFrame,
+            popupPage,
+            orderNumber,
+            orderIndex: i,
+            totalOrders: input.orderNumbers.length,
+            deleteSet,
+            dryRun: input.dryRun ?? this.dryRun,
+            onProgress: input.onProgress
+          })
+
+          result.details.push(detail)
+          result.ordersProcessed++
+          result.materialsDeleted += detail.materialsDeleted
+          result.materialsSkipped += detail.materialsSkipped
+        } catch (error) {
+          const message = error instanceof Error ? error.message : 'Unknown error'
+          result.errors.push(`Order ${orderNumber}: ${message}`)
+
+          // Add error detail
+          result.details.push({
+            orderNumber,
+            materialsDeleted: 0,
+            materialsSkipped: 0,
+            errors: [message]
+          })
+        }
+      }
+
+      // Close popup page
+      await popupPage.close()
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      result.errors.push(`Clean failed: ${message}`)
+    }
+
+    return result
+  }
+
+  /**
+   * Navigate to the discrete production order maintenance page
+   * Reference: Python lines 476-486
+   */
+  async navigateToCleanerPage(
+    session: ErpSession
+  ): Promise<{ popupPage: Page; workFrame: FrameLocator }> {
+    const { page, mainFrame } = session
+
+    // Click menu icon (Python line 476)
+    await mainFrame.locator('i').first().click()
+
+    // Click discrete production order menu item and expect popup (Python lines 477-479)
+    const popupPromise = page.waitForEvent('popup')
+    await mainFrame.getByTitle('离散生产订单维护', { exact: true }).first().click()
+    const popupPage = await popupPromise
+
+    // Get nested frame structure (Python lines 482-486)
+    const forwardFrameLocator = popupPage.locator('#forwardFrame')
+    const fFrame = forwardFrameLocator.contentFrame()
+
+    const innerFrameLocator = fFrame.locator('#mainiframe')
+    await innerFrameLocator.waitFor({ state: 'visible', timeout: 30000 })
+    const workFrame = innerFrameLocator.contentFrame()
+
+    // Wait for hot-key-head_list to be visible (Python line 484-486)
+    await workFrame.locator('#hot-key-head_list').waitFor({ state: 'visible', timeout: 30000 })
+
+    return { popupPage, workFrame }
+  }
+
+  /**
+   * Setup query interface
+   * Reference: Python setup_query_interface() lines 445-454
+   */
+  private async setupQueryInterface(innerFrame: FrameLocator): Promise<void> {
+    // Click search icon (Python line 447)
+    await innerFrame.locator('.search-name-wrapper > .iconfont').click()
+
+    // Click "订单号查询" menu item (Python line 448)
+    await innerFrame.getByText('订单号查询').click()
+
+    // Click "全部" tab (Python line 449)
+    await innerFrame.getByRole('tab', { name: '全部' }).click()
+
+    // Set limit to 5000 (Python lines 451-454)
+    const inputEl = innerFrame.locator('#rc_select_0')
+    await inputEl.fill('5000')
+    await inputEl.press('Enter')
+  }
+
+  /**
+   * Process a single order
+   * Reference: Python process_order() lines 171-443
+   */
+  private async processOrder(params: {
+    workFrame: FrameLocator
+    popupPage: Page
+    orderNumber: string
+    orderIndex: number
+    totalOrders: number
+    deleteSet: Set<string>
+    dryRun: boolean
+    onProgress?: (message: string, progress?: number) => void
+  }): Promise<OrderCleanDetail> {
+    const {
+      workFrame,
+      popupPage,
+      orderNumber,
+      orderIndex,
+      totalOrders,
+      deleteSet,
+      dryRun,
+      onProgress
+    } = params
+
+    const detail: OrderCleanDetail = {
+      orderNumber,
+      materialsDeleted: 0,
+      materialsSkipped: 0,
+      errors: []
+    }
+
+    // Query the order (Python lines 187-189)
+    const textbox = workFrame.getByRole('textbox', { name: '生产订单号' })
+    await textbox.fill(orderNumber)
+    await workFrame.locator('.search-component-searchBtn').click()
+
+    // Wait for loading (Python lines 192-197)
+    await this.waitForLoading(workFrame)
+
+    // Click "更多" to open menu (Python line 200)
+    await workFrame.locator('#hot-key-head_list').getByText('更多').click()
+
+    // Click "备料计划" and expect popup (Python lines 201-203)
+    const detailPagePromise = popupPage.waitForEvent('popup')
+    await workFrame.getByText('备料计划').click()
+    const detailPage = await detailPagePromise
+
+    try {
+      // Navigate nested frames in detail page (Python lines 206-207)
+      const detailMainFrame = detailPage.locator('#forwardFrame')
+      const dFrame = await detailMainFrame.contentFrame()
+
+      if (!dFrame) {
+        throw new Error('Failed to access detail page forward frame')
+      }
+
+      const detailInnerLocator = dFrame.locator('#mainiframe')
+      await detailInnerLocator.waitFor({ state: 'visible', timeout: 30000 })
+      const detailInnerFrame = await detailInnerLocator.contentFrame()
+
+      if (!detailInnerFrame) {
+        throw new Error('Failed to access detail inner frame')
+      }
+
+      // Wait for plan code (Python lines 210-213)
+      await detailInnerFrame
+        .getByText(/^离散备料计划维护：/)
+        .waitFor({ state: 'visible', timeout: 30000 })
+
+      // Extract detail count (Python lines 215-218)
+      const detailCountText = await detailInnerFrame.getByText(/^详细信息 \(\d+\)$/).innerText()
+      const detailCountMatch = detailCountText.match(/\((\d+)\)/)
+      const detailCount = detailCountMatch ? parseInt(detailCountMatch[1], 10) : 0
+
+      // Extract status (Python lines 220-225)
+      const statusText = await detailInnerFrame.getByText(/^备料状态:.+$/).innerText()
+      const statusMatch = statusText.replace(/\n/g, '').match(/备料状态:(.+)$/)
+      const detailStatus = statusMatch ? statusMatch[1].trim() : ''
+
+      // Process based on status (Python lines 228-441)
+      if (detailStatus === '审批通过' && detailCount > 0) {
+        // Click modify button (Python line 235)
+        await detailInnerFrame.getByRole('button', { name: '修改' }).click()
+
+        // Wait for save button (Python lines 238-242)
+        const saveButtonLocator = detailInnerFrame.getByRole('button', { name: '保存' })
+        await saveButtonLocator.waitFor({ state: 'visible', timeout: 30000 })
+
+        // Expand the form (Python line 245)
+        await detailInnerFrame.getByText('展开').first().click()
+
+        // Get form elements (Python lines 247-253)
+        const childForm = detailInnerFrame.locator('.card-table-side-box')
+        const buttonWrapper = childForm.locator('.button-wrapper')
+        const deleteRowBtn = buttonWrapper.getByRole('button', { name: '删行' })
+        const nextBtn = buttonWrapper.locator('.icon-jiantouyou')
+        const collapseBtn = buttonWrapper.locator('.icon-celashouqi')
+
+        let lastRowNumber = ''
+        let materialIdx = 0
+
+        // Process each material row (Python lines 257-423)
+        while (true) {
+          materialIdx++
+
+          // Wait for row number to stabilize (Python lines 262-265)
+          const currentRow = await this.getInputValue(childForm, /^行号$/)
+          const rowNumInt = parseInt(currentRow, 10)
+
+          if (currentRow === lastRowNumber) {
+            await this.delay(500)
+          }
+
+          // Get material data (Python lines 267-271)
+          const materialCode = await this.getInputValue(childForm, /^材料编码/)
+          const materialName = await this.getInputValue(childForm, /^材料名称/)
+          const pendingQty = await this.getInputValue(childForm, /^累计待发数量$/)
+
+          // Report progress
+          onProgress?.(
+            `Order ${orderNumber} - Material ${materialIdx}/${detailCount}: ${materialName}`,
+            ((orderIndex + materialIdx / detailCount) / totalOrders) * 100
+          )
+
+          // Check if should delete (Python lines 284-406)
+          if (deleteSet.has(materialCode)) {
+            const shouldDelete = this.shouldDeleteMaterial({
+              rowNumber: rowNumInt,
+              pendingQty,
+              materialCode,
+              deleteSet
+            })
+
+            if (shouldDelete && !dryRun) {
+              // Delete the material (Python lines 302-340)
+              const oldRowNumber = currentRow
+              await deleteRowBtn.click()
+
+              // Wait for row number to change (Python lines 306-324)
+              const deleteSuccess = await this.waitForRowChange(childForm, oldRowNumber, 10000)
+
+              if (deleteSuccess) {
+                detail.materialsDeleted++
+              }
+              continue
+            } else if (!shouldDelete) {
+              detail.materialsSkipped++
+            }
+          }
+
+          // Move to next row (Python lines 419-423)
+          const isNextEnabled = await this.isButtonEnabled(nextBtn)
+          if (isNextEnabled) {
+            lastRowNumber = currentRow
+            await nextBtn.click()
+          } else {
+            break
+          }
+        }
+
+        // Collapse form (Python line 424)
+        await collapseBtn.click()
+
+        // Save changes (Python lines 427-435)
+        if (!dryRun && detail.materialsDeleted > 0) {
+          await saveButtonLocator.click()
+          await saveButtonLocator.waitFor({ state: 'hidden', timeout: 60000 })
+        }
+      }
+    } finally {
+      // Close detail page (Python lines 442-443)
+      await detailPage.close()
+    }
+
+    return detail
+  }
+
+  /**
+   * Wait for loading overlay to disappear
+   * Reference: Python lines 192-197
+   */
+  private async waitForLoading(frame: FrameLocator): Promise<void> {
+    const loadingLocator = frame
+      .locator('div')
+      .filter({ hasText: ERP_LOCATORS.extractor.loadingText })
+      .nth(1)
+
+    try {
+      await loadingLocator.waitFor({ state: 'visible', timeout: 3000 })
+      await loadingLocator.waitFor({ state: 'hidden', timeout: 60000 })
+    } catch {
+      // Loading completed quickly or never appeared
+    }
+  }
+
+  /**
+   * Get input value by label regex
+   * Reference: Python _get_input_value() lines 141-148
+   */
+  private async getInputValue(
+    container: FrameLocator | Locator,
+    labelRegex: RegExp
+  ): Promise<string> {
+    try {
+      return await container
+        .locator('div')
+        .filter({ hasText: labelRegex })
+        .locator('input')
+        .first()
+        .inputValue()
+    } catch {
+      return ''
+    }
+  }
+
+  /**
+   * Check if button is enabled
+   * Reference: Python _is_button_enabled() lines 133-139
+   */
+  private async isButtonEnabled(button: Locator): Promise<boolean> {
+    try {
+      return await button.isEnabled()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Wait for row number to change after deletion
+   * Reference: Python lines 306-324
+   */
+  private async waitForRowChange(
+    childForm: FrameLocator | Locator,
+    oldRowNumber: string,
+    maxWaitMs: number
+  ): Promise<boolean> {
+    const startTime = Date.now()
+
+    while (Date.now() - startTime < maxWaitMs) {
+      try {
+        const newRowNumber = await this.getInputValue(childForm, /^行号$/)
+        if (newRowNumber !== oldRowNumber) {
+          return true
+        }
+        await this.delay(200)
+      } catch {
+        await this.delay(200)
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Delay helper
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+}
diff --git a/src/main/types/cleaner.types.ts b/src/main/types/cleaner.types.ts
index 36094cc..4dbb150 100644
--- a/src/main/types/cleaner.types.ts
+++ b/src/main/types/cleaner.types.ts
@@ -1,21 +1,21 @@
 export interface CleanerInput {
-  orderNumbers: string[];
-  materialCodes: string[];
-  dryRun: boolean;
-  onProgress?: (message: string, progress: number) => void;
+  orderNumbers: string[]
+  materialCodes: string[]
+  dryRun: boolean
+  onProgress?: (message: string, progress?: number) => void
 }
 
 export interface CleanerResult {
-  ordersProcessed: number;
-  materialsDeleted: number;
-  materialsSkipped: number;
-  errors: string[];
-  details: OrderCleanDetail[];
+  ordersProcessed: number
+  materialsDeleted: number
+  materialsSkipped: number
+  errors: string[]
+  details: OrderCleanDetail[]
 }
 
 export interface OrderCleanDetail {
-  orderNumber: string;
-  materialsDeleted: number;
-  materialsSkipped: number;
-  errors: string[];
-}
\ No newline at end of file
+  orderNumber: string
+  materialsDeleted: number
+  materialsSkipped: number
+  errors: string[]
+}
diff --git a/tests/integration/cleaner.test.ts b/tests/integration/cleaner.test.ts
new file mode 100644
index 0000000..8b7d652
--- /dev/null
+++ b/tests/integration/cleaner.test.ts
@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest'
+import { CleanerService } from '../../src/main/services/erp/cleaner'
+import { ErpAuthService } from '../../src/main/services/erp/erp-auth'
+import type { ErpConfig } from '../../src/main/types/erp.types'
+import fs from 'fs/promises'
+import path from 'path'
+
+describe('Cleaner Service (Integration)', () => {
+  const config: ErpConfig = {
+    url: process.env.ERP_URL || '',
+    username: process.env.ERP_USERNAME || '',
+    password: process.env.ERP_PASSWORD || ''
+  }
+
+  // Test data paths
+  const productionIdFile = path.join(process.cwd(), '../references/demo/productionID.txt')
+  const materialCodeFile = path.join(process.cwd(), '../references/demo/materialCode.txt')
+
+  // Check if we have ERP credentials
+  const hasCredentials = !!(config.url && config.username && config.password)
+
+  describe('Dry-run mode', () => {
+    it('should initialize with dry-run mode', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      expect(cleaner.isDryRun()).toBe(true)
+
+      await authService.close()
+    }, 30000)
+
+    it('should track materials to delete without actually deleting (dry-run)', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      // Read test data
+      const orderContent = await fs.readFile(productionIdFile, 'utf-8')
+      const orderNumbers = orderContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(0, 2) // Test first 2 orders
+
+      const materialContent = await fs.readFile(materialCodeFile, 'utf-8')
+      const materialCodes = materialContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+
+      console.log(
+        `Testing dry-run with ${orderNumbers.length} orders and ${materialCodes.length} material codes`
+      )
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      const result = await cleaner.clean({
+        orderNumbers,
+        materialCodes,
+        dryRun: true
+      })
+
+      // In dry-run mode, materialsDeleted should be tracked but not actually deleted
+      console.log(`Dry-run result:`, {
+        ordersProcessed: result.ordersProcessed,
+        materialsDeleted: result.materialsDeleted,
+        materialsSkipped: result.materialsSkipped,
+        errors: result.errors.length
+      })
+
+      expect(result.ordersProcessed).toBeGreaterThan(0)
+      // In dry-run, no actual deletions should happen
+      expect(result.errors).toHaveLength(0)
+
+      await authService.close()
+    }, 120000)
+  })
+
+  describe('Order processing', () => {
+    it('should process single order and return details', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      const orderContent = await fs.readFile(productionIdFile, 'utf-8')
+      const orderNumbers = orderContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(0, 1) // Test single order
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      const result = await cleaner.clean({
+        orderNumbers,
+        materialCodes: [], // Empty list - nothing to delete
+        dryRun: true
+      })
+
+      expect(result.ordersProcessed).toBe(1)
+      expect(result.details).toHaveLength(1)
+      expect(result.details[0].orderNumber).toBe(orderNumbers[0])
+
+      await authService.close()
+    }, 60000)
+
+    it('should handle order with "审批通过" status', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      const orderContent = await fs.readFile(productionIdFile, 'utf-8')
+      const orderNumbers = orderContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(0, 1)
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      const result = await cleaner.clean({
+        orderNumbers,
+        materialCodes: [],
+        dryRun: true
+      })
+
+      // Order details should include status information
+      const detail = result.details[0]
+      console.log(
+        `Order ${detail.orderNumber} - Materials deleted: ${detail.materialsDeleted}, Skipped: ${detail.materialsSkipped}`
+      )
+
+      expect(detail).toBeDefined()
+
+      await authService.close()
+    }, 60000)
+
+    it('should handle multiple orders with progress callback', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      const orderContent = await fs.readFile(productionIdFile, 'utf-8')
+      const orderNumbers = orderContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(0, 3) // Test 3 orders
+
+      const progressMessages: string[] = []
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      const result = await cleaner.clean({
+        orderNumbers,
+        materialCodes: [],
+        dryRun: true,
+        onProgress: (message, progress) => {
+          progressMessages.push(`${progress?.toFixed(0)}%: ${message}`)
+        }
+      })
+
+      expect(result.ordersProcessed).toBe(3)
+      expect(progressMessages.length).toBeGreaterThan(0)
+
+      console.log('Progress messages:', progressMessages.slice(0, 5))
+
+      await authService.close()
+    }, 180000)
+  })
+
+  describe('Error handling', () => {
+    it('should continue processing after order error', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      const orderNumbers = ['INVALID_ORDER_12345', 'INVALID_ORDER_67890']
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      const result = await cleaner.clean({
+        orderNumbers,
+        materialCodes: [],
+        dryRun: true
+      })
+
+      // Should still process (even if with errors)
+      expect(result.details.length).toBeGreaterThan(0)
+
+      await authService.close()
+    }, 120000)
+  })
+
+  describe('Navigation', () => {
+    it('should navigate to discrete production order maintenance page', async () => {
+      if (!hasCredentials) {
+        console.warn('Skipping test: ERP credentials not configured')
+        return
+      }
+
+      const authService = new ErpAuthService(config)
+      await authService.login()
+
+      const cleaner = new CleanerService(authService, { dryRun: true })
+
+      // This tests the internal navigation method
+      const session = authService.getSession()
+      const { popupPage, workFrame } = await cleaner.navigateToCleanerPage(session)
+
+      expect(popupPage).toBeDefined()
+      expect(workFrame).toBeDefined()
+
+      // Cleanup
+      await popupPage.close()
+      await authService.close()
+    }, 60000)
+  })
+})
diff --git a/tests/unit/cleaner.test.ts b/tests/unit/cleaner.test.ts
new file mode 100644
index 0000000..a9b687f
--- /dev/null
+++ b/tests/unit/cleaner.test.ts
@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest'
+import { CleanerService } from '../../src/main/services/erp/cleaner'
+import type { ShouldDeleteParams } from '../../src/main/services/erp/cleaner'
+
+describe('Cleaner Service (Unit)', () => {
+  describe('shouldDeleteMaterial', () => {
+    // Create a mock cleaner service (no auth needed for this pure function test)
+    const mockCleaner = {
+      shouldDeleteMaterial: (params: ShouldDeleteParams): boolean => {
+        const { rowNumber, pendingQty, materialCode, deleteSet } = params
+
+        // Check if material is in delete list
+        if (!deleteSet.has(materialCode)) {
+          return false
+        }
+
+        // Check row number range (7000-7999 are protected)
+        if (rowNumber >= 7000 && rowNumber < 8000) {
+          return false
+        }
+
+        // Check pending quantity (must be empty)
+        if (pendingQty && pendingQty.trim() !== '') {
+          return false
+        }
+
+        return true
+      }
+    }
+
+    it('should skip materials with row number 7000-7999', () => {
+      const testCases = [
+        { rowNumber: 7000, pendingQty: '', materialCode: 'TEST001', expected: false },
+        { rowNumber: 7500, pendingQty: '', materialCode: 'TEST001', expected: false },
+        { rowNumber: 7999, pendingQty: '', materialCode: 'TEST001', expected: false },
+        { rowNumber: 6999, pendingQty: '', materialCode: 'TEST001', expected: true },
+        { rowNumber: 8000, pendingQty: '', materialCode: 'TEST001', expected: true }
+      ]
+
+      for (const tc of testCases) {
+        const shouldDelete = mockCleaner.shouldDeleteMaterial({
+          rowNumber: tc.rowNumber,
+          pendingQty: tc.pendingQty,
+          materialCode: tc.materialCode,
+          deleteSet: new Set(['TEST001'])
+        })
+        expect(shouldDelete).toBe(tc.expected)
+      }
+    })
+
+    it('should skip materials with non-empty pending quantity', () => {
+      const result = mockCleaner.shouldDeleteMaterial({
+        rowNumber: 100,
+        pendingQty: '5',
+        materialCode: 'TEST001',
+        deleteSet: new Set(['TEST001'])
+      })
+
+      expect(result).toBe(false)
+    })
+
+    it('should skip materials not in delete list', () => {
+      const result = mockCleaner.shouldDeleteMaterial({
+        rowNumber: 100,
+        pendingQty: '',
+        materialCode: 'NOT_IN_LIST',
+        deleteSet: new Set(['TEST001'])
+      })
+
+      expect(result).toBe(false)
+    })
+
+    it('should delete materials with empty pending qty and valid row number', () => {
+      const testCases = [
+        { rowNumber: 1, pendingQty: '', materialCode: 'TEST001', expected: true },
+        { rowNumber: 100, pendingQty: '', materialCode: 'TEST001', expected: true },
+        { rowNumber: 6999, pendingQty: '', materialCode: 'TEST001', expected: true },
+        { rowNumber: 8000, pendingQty: '', materialCode: 'TEST001', expected: true },
+        { rowNumber: 10000, pendingQty: '', materialCode: 'TEST001', expected: true }
+      ]
+
+      for (const tc of testCases) {
+        const shouldDelete = mockCleaner.shouldDeleteMaterial({
+          rowNumber: tc.rowNumber,
+          pendingQty: tc.pendingQty,
+          materialCode: tc.materialCode,
+          deleteSet: new Set(['TEST001'])
+        })
+        expect(shouldDelete).toBe(tc.expected)
+      }
+    })
+
+    it('should handle multiple conditions correctly', () => {
+      // Material in list, valid row, no pending qty = should delete
+      expect(
+        mockCleaner.shouldDeleteMaterial({
+          rowNumber: 100,
+          pendingQty: '',
+          materialCode: 'TEST001',
+          deleteSet: new Set(['TEST001'])
+        })
+      ).toBe(true)
+
+      // Material in list, protected row, no pending qty = should NOT delete
+      expect(
+        mockCleaner.shouldDeleteMaterial({
+          rowNumber: 7500,
+          pendingQty: '',
+          materialCode: 'TEST001',
+          deleteSet: new Set(['TEST001'])
+        })
+      ).toBe(false)
+
+      // Material in list, valid row, has pending qty = should NOT delete
+      expect(
+        mockCleaner.shouldDeleteMaterial({
+          rowNumber: 100,
+          pendingQty: '10',
+          materialCode: 'TEST001',
+          deleteSet: new Set(['TEST001'])
+        })
+      ).toBe(false)
+
+      // Material NOT in list = should NOT delete
+      expect(
+        mockCleaner.shouldDeleteMaterial({
+          rowNumber: 100,
+          pendingQty: '',
+          materialCode: 'OTHER',
+          deleteSet: new Set(['TEST001'])
+        })
+      ).toBe(false)
+    })
+  })
+})