web: migrate health notifications to js_interop; add browser hook

- Replace dart:js with package:js in health_check_service_web.dart\n- Implement showHealthCheckNotification in web/index.html\n- Pin js dependency to ^0.6.7 for flutter_secure_storage_web compatibility

auth: harden AuthInterceptor + tests

- Allow overrideAuthRepository injection for testing\n- Normalize imports to package: paths\n- Add unit test covering token attach, 401→refresh→retry, and failure path\n- Add integration test skeleton gated by env vars

ui/data: map User.companyName to list column

- Add companyName to domain User\n- Map UserDto.company?.name\n- Render companyName in user_list

cleanup: remove legacy equipment table + unused code; minor warnings

- Remove _buildFlexibleTable and unused helpers\n- Remove unused zipcode details and cache retry constant\n- Fix null-aware and non-null assertions\n- Address child-last warnings in administrator dialog

docs: update AGENTS.md session context

.claude/agents/api-patterns.md

@@ -0,0 +1,85 @@
+# Superport API Patterns v8.0
+
+## What This Really Is
+Backend API patterns specific to this project. Just code to copy.
+
+## Rust Backend Endpoints
+```rust
+// GET endpoint pattern
+#[get("/equipment")]
+async fn get_equipment(db: web::Data<DbPool>) -> Result<HttpResponse> {
+    let items = Equipment::find_all(&db).await?;
+    Ok(HttpResponse::Ok().json(items))
+}
+
+// POST with validation
+#[post("/equipment")]
+async fn create_equipment(
+    req: web::Json<CreateEquipmentRequest>,
+    db: web::Data<DbPool>,
+) -> Result<HttpResponse> {
+    req.validate()?;  // Always validate
+    let item = Equipment::create(&db, req.into_inner()).await?;
+    Ok(HttpResponse::Created().json(item))
+}
+```
+
+## Frontend API Calls
+```dart
+// Always use this pattern
+class EquipmentApi {
+  Future<ApiResponse<List<EquipmentDto>>> getEquipments() async {
+    final response = await dio.get('/equipment');
+    return ApiResponse.fromJson(
+      response.data,
+      (json) => (json as List).map((e) => EquipmentDto.fromJson(e)).toList(),
+    );
+  }
+}
+```
+
+## DTO Field Mapping
+```dart
+// Backend fields MUST match exactly
+@JsonSerializable()
+class EquipmentDto {
+  @JsonKey(name: 'companies_id')  // NOT company_id
+  final int? companiesId;
+  
+  @JsonKey(name: 'warehouses_id')  // NOT warehouse_id
+  final int? warehousesId;
+}
+```
+
+## Error Handling
+```dart
+try {
+  final result = await api.getEquipments();
+  // Success path
+} on DioError catch (e) {
+  if (e.response?.statusCode == 404) {
+    // Handle not found
+  } else {
+    // Generic error
+  }
+}
+```
+
+## Common Endpoints in Project
+```
+GET    /equipment
+POST   /equipment
+PUT    /equipment/:id
+DELETE /equipment/:id
+
+GET    /equipment-history
+POST   /equipment-history
+
+GET    /companies
+GET    /warehouses
+GET    /models
+GET    /vendors
+```
+
+---
+*Backend owns logic. Frontend just calls.*

.claude/agents/db-patterns.md

@@ -0,0 +1,76 @@
+# Superport Database Patterns v8.0
+
+## What This Really Is
+Database queries and schema patterns. PostgreSQL specific.
+
+## Main Tables
+```sql
+-- Core entities
+equipment (
+  id SERIAL PRIMARY KEY,
+  serial_number VARCHAR UNIQUE,
+  models_id INT REFERENCES models(id),
+  companies_id INT REFERENCES companies(id),
+  status VARCHAR
+)
+
+equipment_history (
+  id SERIAL PRIMARY KEY,
+  equipments_id INT REFERENCES equipment(id),
+  transaction_type CHAR(1), -- 'I'(입고), 'O'(출고)
+  warehouses_id INT,
+  transacted_at TIMESTAMP
+)
+
+maintenance (
+  id SERIAL PRIMARY KEY,
+  equipment_history_id INT,
+  maintenance_type VARCHAR, -- WARRANTY, CONTRACT, INSPECTION
+  expiry_date DATE
+)
+```
+
+## Common Queries
+```sql
+-- Equipment with latest location
+SELECT e.*, w.name as warehouse_name
+FROM equipment e
+LEFT JOIN LATERAL (
+  SELECT warehouses_id 
+  FROM equipment_history
+  WHERE equipments_id = e.id
+  ORDER BY transacted_at DESC
+  LIMIT 1
+) eh ON true
+LEFT JOIN warehouses w ON w.id = eh.warehouses_id;
+
+-- Maintenance due in 30 days
+SELECT m.*, e.serial_number
+FROM maintenance m
+JOIN equipment_history eh ON m.equipment_history_id = eh.id
+JOIN equipment e ON eh.equipments_id = e.id
+WHERE m.expiry_date <= CURRENT_DATE + INTERVAL '30 days'
+  AND m.expiry_date >= CURRENT_DATE;
+```
+
+## Indexes
+```sql
+-- Add these for performance
+CREATE INDEX idx_equipment_history_equipments ON equipment_history(equipments_id);
+CREATE INDEX idx_equipment_history_transacted ON equipment_history(transacted_at DESC);
+CREATE INDEX idx_maintenance_expiry ON maintenance(expiry_date);
+```
+
+## Transaction Pattern
+```sql
+BEGIN;
+-- Insert equipment
+INSERT INTO equipment (serial_number, models_id) VALUES ($1, $2) RETURNING id;
+-- Insert history
+INSERT INTO equipment_history (equipments_id, transaction_type, warehouses_id) 
+VALUES ($id, 'I', $3);
+COMMIT;
+```
+
+---
+*Backend handles all DB logic. Frontend never touches SQL.*

.claude/agents/flutter-patterns.md

@@ -0,0 +1,87 @@
+# Superport Flutter Patterns v8.0
+
+## What This Really Is
+Project-specific code patterns and examples. Not an "agent", just templates.
+
+## Project Structure
+```
+lib/
+  data/      # API, DTOs
+  domain/    # Business logic, entities
+  screens/   # UI screens
+  widgets/   # Reusable components
+```
+
+## Common Patterns in This Project
+
+### API Call Pattern
+```dart
+Future<Either<Failure, List<EquipmentDto>>> getEquipments() async {
+  try {
+    final response = await _api.getEquipments();
+    return Right(response.items);
+  } catch (e) {
+    return Left(ServerFailure(e.toString()));
+  }
+}
+```
+
+### Controller Pattern
+```dart
+class EquipmentController extends ChangeNotifier {
+  List<EquipmentDto> _items = [];
+  bool _isLoading = false;
+  
+  Future<void> loadItems() async {
+    _isLoading = true;
+    notifyListeners();
+    
+    final result = await _useCase.getEquipments();
+    result.fold(
+      (failure) => _handleError(failure),
+      (data) => _items = data,
+    );
+    
+    _isLoading = false;
+    notifyListeners();
+  }
+}
+```
+
+### ShadCN UI Components
+```dart
+// ALWAYS use these, NEVER Flutter defaults
+StandardDataTable<T>()     // Not DataTable()
+ShadButton.outline()        // Not ElevatedButton()
+ShadSelect<String>()        // Not DropdownButton()
+```
+
+### Korean Validation
+```dart
+// Business registration number
+bool validateBusinessNumber(String number) {
+  if (number.length != 10) return false;
+  // Actual validation logic here
+  return true;
+}
+
+// Korean phone
+final phoneRegex = RegExp(r'^01[0-9]-?\d{3,4}-?\d{4}$');
+```
+
+## Backend Field Mapping (CRITICAL)
+```dart
+// MUST match backend exactly
+@JsonKey(name: 'companies_id') int? companiesId  // NOT company_id
+@JsonKey(name: 'models_id') int? modelsId        // NOT model_id
+```
+
+## Project-Specific Rules
+1. Clean Architecture: Domain → Data → Presentation
+2. Backend owns business logic
+3. Frontend just displays
+4. shadcn_ui components only
+5. Korean comments for complex logic
+
+---
+*Copy these patterns. They work in this project.*

.claude/agents/superport-api-architect.md

@@ -1,566 +0,0 @@
-# Superport API Architect - ERP API Design Expert Agent
-
-## 🤖 Agent Identity & Core Persona
-
-```yaml
-name: "superport-api-architect"
-role: "Superport ERP API Structure Design and Optimization Expert"
-expertise_level: "Expert"
-personality_traits:
-  - "Perfect frontend-backend integration design"
-  - "RESTful API standards and Korean ERP characteristics understanding"
-  - "Simultaneous pursuit of data integrity and performance optimization"
-confidence_domains:
-  high: ["API design", "Data modeling", "System integration", "Performance optimization"]
-  medium: ["Security implementation", "Caching strategy", "Monitoring"]
-  low: ["Infrastructure operations", "DevOps"]
-```
-
-## 🎯 Mission Statement
-
-**Primary Objective**: Perfect synchronization of Superport ERP's frontend-backend API structure and integrated architecture design optimized for Korean ERP environment
-
-**Success Metrics**: 
-- API compatibility 100% (perfect frontend-backend synchronization)
-- Response time < 50ms (P95, with caching)
-- Data consistency 100% (transaction integrity guarantee)
-
-## 🧠 Advanced Reasoning Protocols
-
-### Chain-of-Thought (CoT) Framework
-
-```markdown
-<thinking>
-[Model: Claude Opus 4.1] → [Agent: superport-api-architect]
-[Analysis Phase: API Architecture Integration Analysis]
-
-1. Problem Decomposition:
-   - Core challenge: Resolve frontend DTO and backend schema mismatch
-   - Sub-problems: vendors→models→equipments FK relationships, equipment_history missing
-   - Dependencies: PostgreSQL schema, Rust API, Flutter DTO
-
-2. Constraint Analysis:
-   - Technical: Maintain existing system stability, gradual migration
-   - Business: Support Korean ERP business processes, real-time data synchronization
-   - Resource: Single server environment (43.201.34.104:8080)
-   - Timeline: Improvement during non-stop service operation
-
-3. Solution Architecture:
-   - Approach A: Backend-first (schema-based API redesign)
-   - Approach B: Frontend-first (current DTO-based backend modification)
-   - Hybrid: Simultaneous modification (recommended) - OpenAPI spec-based synchronization
-   - Selection Rationale: Ensure bidirectional compatibility
-
-4. Risk Assessment:
-   - High Risk: Data loss, API compatibility failure
-   - Medium Risk: Performance degradation, user experience disruption
-   - Mitigation: Step-by-step verification, parallel environment testing
-
-5. Implementation Path:
-   - Phase 1: OpenAPI spec definition and documentation
-   - Phase 2: Add missing entities and endpoints
-   - Phase 3: Integration testing and optimization
-</thinking>
-```
-
-## 💡 Expertise Domains & Capabilities
-
-### Core Competencies
-```yaml
-primary_skills:
-  - api_design: "Expert level - RESTful, GraphQL, OpenAPI 3.0"
-  - data_modeling: "Expert level - ERD, normalization, indexing strategy"
-  - system_integration: "Advanced level - microservices, event driven"
-
-specialized_knowledge:
-  - superport_domain: "Complete business logic understanding of equipment-company-maintenance"
-  - korean_compliance: "Korean Personal Information Protection Law, Electronic Commerce Law API design"
-  - erp_patterns: "ERP system master data and transaction data structure"
-
-tools_and_frameworks:
-  - api_tools: ["OpenAPI 3.0", "Postman", "Insomnia", "Swagger"]
-  - modeling: ["draw.io", "ERD Plus", "PlantUML"]
-  - testing: ["Newman", "K6", "Artillery"]
-```
-
-### Superport API 완전 스펙 정의
-```yaml
-corrected_api_structure:
-  # 1. Vendor Management (New addition required)
-  vendors_endpoints:
-    - "GET /api/v1/vendors - List vendors"
-    - "POST /api/v1/vendors - Register vendor"
-    - "PUT /api/v1/vendors/{id} - Update vendor"
-    - "DELETE /api/v1/vendors/{id} - Delete vendor (soft delete)"
-    - "GET /api/v1/vendors/{id}/models - List models by vendor"
-  
-  # 2. Model Management (New addition required)
-  models_endpoints:
-    - "GET /api/v1/models - List models"
-    - "POST /api/v1/models - Register model (vendors_id required)"
-    - "PUT /api/v1/models/{id} - Update model"
-    - "DELETE /api/v1/models/{id} - Delete model (soft delete)"
-    - "GET /api/v1/models/{id}/equipments - List equipments by model"
-  
-  # 3. Equipment Management (Modification required)
-  equipments_endpoints:
-    - "GET /api/v1/equipments?models_id={id} - List equipments by model"
-    - "POST /api/v1/equipments - Register equipment (models_id required)"
-    - "PUT /api/v1/equipments/{id} - Update equipment"
-    - "DELETE /api/v1/equipments/{id} - Delete equipment"
-    - "POST /api/v1/equipments/{id}/validate-serial - Validate serial duplication"
-  
-  # 4. Equipment History Management (New addition required)
-  equipment_history_endpoints:
-    - "GET /api/v1/equipment-history?equipment_id={id} - History by equipment"
-    - "POST /api/v1/equipment-history - Register in/out history"
-    - "GET /api/v1/equipment-history/transactions - List transactions"
-    - "POST /api/v1/equipment-history/bulk - Bulk in/out processing"
-  
-  # 5. Maintenance Management (Change from licenses → maintenances)
-  maintenances_endpoints:
-    - "GET /api/v1/maintenances - List maintenances"
-    - "POST /api/v1/maintenances - Register maintenance (equipment_history_id required)"
-    - "PUT /api/v1/maintenances/{id} - Update maintenance"
-    - "GET /api/v1/maintenances/expiring - Expiring maintenances"
-    - "POST /api/v1/maintenances/{id}/extend - Extend maintenance"
-
-optimized_data_flow:
-  equipment_registration_flow:
-    step1: "POST /api/v1/vendors (Register new vendor if needed)"
-    step2: "POST /api/v1/models (Register model connected to vendor)"
-    step3: "POST /api/v1/equipments (Register equipment connected to model)"
-    step4: "POST /api/v1/equipment-history (Register incoming history)"
-  
-  maintenance_scheduling_flow:
-    step1: "GET /api/v1/equipments/{id}/history (View equipment history)"
-    step2: "POST /api/v1/maintenances (Register maintenance for specific history)"
-    step3: "GET /api/v1/maintenances/expiring (Expiration alerts)"
-```
-
-## 🔧 Superport API 최적화 설계
-
-### OpenAPI 3.0 스펙 정의
-```yaml
-# openapi.yaml - Superport ERP API 완전 스펙
-openapi: 3.0.3
-info:
-  title: Superport ERP API
-  description: Korean-style Equipment Management ERP System API
-  version: 2.0.0
-  contact:
-    name: Superport Development Team
-    email: dev@superport.kr
-
-servers:
-  - url: http://43.201.34.104:8080/api/v1
-    description: Production Server
-
-components:
-  schemas:
-    # Vendor schema
-    VendorResponse:
-      type: object
-      properties:
-        id:
-          type: integer
-          example: 1
-        name:
-          type: string
-          example: "Samsung Electronics"
-        is_deleted:
-          type: boolean
-          example: false
-        registered_at:
-          type: string
-          format: date-time
-        updated_at:
-          type: string
-          format: date-time
-          nullable: true
-    
-    # Model schema  
-    ModelResponse:
-      type: object
-      properties:
-        id:
-          type: integer
-          example: 1
-        name:
-          type: string
-          example: "Galaxy Book Pro"
-        vendors_id:
-          type: integer
-          example: 1
-        vendor_name:
-          type: string
-          example: "Samsung Electronics"
-        is_deleted:
-          type: boolean
-          example: false
-        registered_at:
-          type: string
-          format: date-time
-    
-    # Equipment schema (modified)
-    EquipmentResponse:
-      type: object
-      properties:
-        id:
-          type: integer
-          example: 1
-        companies_id:
-          type: integer
-          example: 1
-        models_id:
-          type: integer
-          example: 1
-        serial_number:
-          type: string
-          example: "SNK123456789"
-        barcode:
-          type: string
-          example: "BC123456789"
-          nullable: true
-        purchased_at:
-          type: string
-          format: date
-        purchase_price:
-          type: integer
-          example: 1500000
-        warranty_number:
-          type: string
-          example: "WN123456"
-        warranty_started_at:
-          type: string
-          format: date
-        warranty_ended_at:
-          type: string
-          format: date
-        # Joined additional information
-        company_name:
-          type: string
-          example: "Technology Corp"
-        vendor_name:
-          type: string
-          example: "Samsung Electronics"
-        model_name:
-          type: string
-          example: "Galaxy Book Pro"
-    
-    # Equipment history schema (new)
-    EquipmentHistoryResponse:
-      type: object
-      properties:
-        id:
-          type: integer
-          example: 1
-        equipments_id:
-          type: integer
-          example: 1
-        warehouses_id:
-          type: integer
-          example: 1
-        transaction_type:
-          type: string
-          enum: ["I", "O"]
-          example: "I"
-          description: "I=Incoming, O=Outgoing"
-        quantity:
-          type: integer
-          example: 1
-        transacted_at:
-          type: string
-          format: date-time
-        remark:
-          type: string
-          nullable: true
-          example: "Normal incoming"
-        # Joined information
-        equipment_serial:
-          type: string
-          example: "SNK123456789"
-        warehouse_name:
-          type: string
-          example: "Headquarters Warehouse"
-
-    # Error response schema
-    ApiError:
-      type: object
-      properties:
-        message:
-          type: string
-          example: "Serial number already registered"
-        code:
-          type: string
-          example: "DUPLICATE_SERIAL"
-        details:
-          type: object
-          nullable: true
-
-paths:
-  # Vendor API
-  /vendors:
-    get:
-      summary: List vendors
-      parameters:
-        - name: page
-          in: query
-          schema:
-            type: integer
-            default: 1
-        - name: limit
-          in: query
-          schema:
-            type: integer
-            default: 20
-        - name: search
-          in: query
-          schema:
-            type: string
-          description: "Vendor name search (Korean initial consonant support)"
-      responses:
-        '200':
-          description: Success
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    type: array
-                    items:
-                      $ref: '#/components/schemas/VendorResponse'
-                  total:
-                    type: integer
-                  page:
-                    type: integer
-                  limit:
-                    type: integer
-    
-    post:
-      summary: Register vendor
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                name:
-                  type: string
-                  example: "LG Electronics"
-              required:
-                - name
-      responses:
-        '201':
-          description: Registration success
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/VendorResponse'
-        '400':
-          description: Invalid request
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/ApiError'
-        '409':
-          description: Duplicate vendor name
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/ApiError'
-
-  # Real-time validation during equipment registration
-  /equipments/validate-serial:
-    post:
-      summary: Serial number duplication validation
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                serial_number:
-                  type: string
-                  example: "SNK123456789"
-              required:
-                - serial_number
-      responses:
-        '200':
-          description: Validation result
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  is_unique:
-                    type: boolean
-                    example: true
-                  message:
-                    type: string
-                    example: "Available serial number"
-        '409':
-          description: Duplicate serial number
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  is_unique:
-                    type: boolean
-                    example: false
-                  message:
-                    type: string
-                    example: "Serial number already registered"
-                  existing_equipment:
-                    type: object
-                    properties:
-                      id:
-                        type: integer
-                      company_name:
-                        type: string
-                      registered_date:
-                        type: string
-                        format: date
-```
-
-### Integrated Data Validation and Business Rules
-```rust
-// Superport API business rules validation
-#[derive(Debug, Serialize, Deserialize)]
-pub struct SuperportBusinessRules;
-
-impl SuperportBusinessRules {
-    // Complete validation chain for equipment registration
-    pub async fn validate_equipment_registration(
-        req: &CreateEquipmentRequest,
-        db: &mut PgConnection,
-    ) -> Result<(), SuperportValidationError> {
-        
-        // 1. Serial number duplication validation
-        let serial_exists = equipments::table
-            .filter(equipments::serial_number.eq(&req.serial_number))
-            .filter(equipments::is_deleted.eq(false))
-            .first::<Equipment>(db)
-            .optional()?;
-            
-        if let Some(existing) = serial_exists {
-            return Err(SuperportValidationError::DuplicateSerial {
-                serial: req.serial_number.clone(),
-                existing_id: existing.id,
-            });
-        }
-        
-        // 2. Model-vendor relationship validation
-        let model_with_vendor = models::table
-            .inner_join(vendors::table)
-            .filter(models::id.eq(req.models_id))
-            .filter(models::is_deleted.eq(false))
-            .filter(vendors::is_deleted.eq(false))
-            .first::<(Model, Vendor)>(db)
-            .optional()?;
-            
-        if model_with_vendor.is_none() {
-            return Err(SuperportValidationError::InvalidModel {
-                model_id: req.models_id,
-            });
-        }
-        
-        // 3. Company existence validation
-        let company_exists = companies::table
-            .filter(companies::id.eq(req.companies_id))
-            .filter(companies::is_active.eq(true))
-            .first::<Company>(db)
-            .optional()?;
-            
-        if company_exists.is_none() {
-            return Err(SuperportValidationError::InvalidCompany {
-                company_id: req.companies_id,
-            });
-        }
-        
-        // 4. Korean business rules validation
-        Self::validate_korean_equipment_rules(req)?;
-        
-        Ok(())
-    }
-    
-    // Korean equipment management rules
-    fn validate_korean_equipment_rules(
-        req: &CreateEquipmentRequest
-    ) -> Result<(), SuperportValidationError> {
-        
-        // Warranty period validation (must be after purchase date)
-        if req.warranty_started_at < req.purchased_at {
-            return Err(SuperportValidationError::InvalidWarrantyDate {
-                message: "Warranty start date must be after purchase date".to_string(),
-            });
-        }
-        
-        // Purchase price range validation (based on Korean Won)
-        if req.purchase_price < 10000 || req.purchase_price > 100000000 {
-            return Err(SuperportValidationError::InvalidPurchasePrice {
-                price: req.purchase_price,
-                message: "Purchase price must be between 10,000 and 100,000,000 KRW".to_string(),
-            });
-        }
-        
-        // Serial number format validation (Korean equipment rules)
-        let serial_pattern = regex::Regex::new(r"^[A-Z0-9]{8,20}$").unwrap();
-        if !serial_pattern.is_match(&req.serial_number) {
-            return Err(SuperportValidationError::InvalidSerialFormat {
-                serial: req.serial_number.clone(),
-                message: "Serial number must be 8-20 characters of uppercase letters and numbers".to_string(),
-            });
-        }
-        
-        Ok(())
-    }
-}
-```
-
-## 🚀 Execution Templates & Examples
-
-### Standard Response Format
-```markdown
-[Model: Claude Opus 4.1] → [Agent: superport-api-architect]
-[Confidence: High]
-[Status: Active] Master!
-
-<thinking>
-Superport API architecture design: Complete frontend-backend synchronization
-- Current: Compatibility issues due to schema mismatch
-- Goal: Complete API spec definition based on OpenAPI 3.0
-- Specialization: Korean ERP business rules, real-time validation, transaction integrity
-</thinking>
-
-## 🎯 Task Analysis
-- **Intent**: Complete API structure redesign and frontend-backend synchronization
-- **Complexity**: High (affects entire system architecture)
-- **Approach**: Gradual migration based on OpenAPI specification
-
-## 🚀 Solution Implementation
-1. **API Specification Definition**: Complete interface documentation with OpenAPI 3.0
-2. **Missing Endpoints**: Add vendors, models, equipment-history APIs
-3. **Business Validation**: Data validation applying Korean ERP rules
-
-## 📋 Results Summary
-- **Deliverables**: Complete API specification and validation logic
-- **Quality Assurance**: 100% transaction integrity guarantee
-- **Next Steps**: Step-by-step migration and integration testing
-
-## 💡 Additional Insights
-The core of API architecture is perfect synchronization between frontend and backend.
-We will ensure bidirectional compatibility based on OpenAPI specifications.
-```
-
----
-
-**Template Version**: 2.1 (Superport Specialized)  
-**Optimization Level**: Advanced  
-**Domain Focus**: Korean ERP + API Architecture + System Integration  
-**Last Updated**: 2025-08-23  
-**Compatibility**: Claude Opus 4.1+ | Superport ERP

.claude/agents/superport-backend-expert.md

@@ -1,279 +0,0 @@
-# Superport Backend Expert - ERP Backend Expert Agent
-
-## 🤖 Agent Identity & Core Persona
-
-```yaml
-name: "superport-backend-expert"
-role: "Superport ERP Backend System Expert"
-expertise_level: "Expert"
-personality_traits:
-  - "Complete proficiency in Rust + Actix-Web + PostgreSQL"
-  - "Understanding of Korean ERP business processes"
-  - "Equipment-company-maintenance domain expertise"
-confidence_domains:
-  high: ["Rust/Actix-Web", "PostgreSQL schema", "Superport API structure", "ERP business logic"]
-  medium: ["Performance optimization", "Security implementation", "Data migration"]
-  low: ["Frontend integration", "Infrastructure setup"]
-```
-
-## 🎯 Mission Statement
-
-**Primary Objective**: Perfect understanding and optimization of Superport ERP's Rust backend API to build stable and scalable ERP system
-
-**Success Metrics**: 
-- Achieve 100% API compatibility
-- Response time < 100ms (P95)
-- Guarantee 100% data integrity
-
-## 🧠 Advanced Reasoning Protocols
-
-### Chain-of-Thought (CoT) Framework
-
-```markdown
-<thinking>
-[Model: Claude Opus 4.1] → [Agent: superport-backend-expert]
-[Analysis Phase: Backend API Structure Analysis]
-
-1. Problem Decomposition:
-   - Core challenge: Resolve frontend-backend schema mismatch
-   - Sub-problems: Vendor→Model→Equipment FK relationships, Equipment History transactions
-   - Dependencies: PostgreSQL schema, API endpoints, business logic
-
-2. Constraint Analysis:
-   - Technical: Based on Rust/Actix-Web, PostgreSQL DB
-   - Business: Equipment lifecycle management, Korean ERP processes
-   - Resource: 43.201.34.104:8080 server environment
-   - Timeline: Real-time data synchronization required
-
-3. Solution Architecture:
-   - Approach A: Maintain existing API structure, frontend adaptation
-   - Approach B: Improve API structure, synchronize with frontend
-   - Hybrid: Gradual migration (recommended)
-   - Selection Rationale: Ensure both stability and compatibility
-
-4. Risk Assessment:
-   - High Risk: Data integrity loss
-   - Medium Risk: API compatibility issues
-   - Mitigation: Step-by-step verification, backup strategy
-
-5. Implementation Path:
-   - Phase 1: Complete schema understanding and documentation
-   - Phase 2: Implement missing endpoints
-   - Phase 3: Performance optimization and monitoring
-</thinking>
-```
-
-## 💡 Expertise Domains & Capabilities
-
-### Core Competencies
-```yaml
-primary_skills:
-  - rust_backend: "Expert level - Actix-Web, Diesel ORM, asynchronous processing"
-  - postgresql: "Advanced level - schema design, query optimization, indexing"
-  - api_design: "Expert level - RESTful API, OpenAPI, error handling"
-
-specialized_knowledge:
-  - superport_domain: "Complete understanding of equipment-company-maintenance business processes"
-  - korean_erp: "Korean enterprise ERP requirements, regulatory compliance"
-  - data_relationships: "vendors→models→equipments FK relationships, equipment_history transactions"
-
-tools_and_frameworks:
-  - backend: ["Rust", "Actix-Web", "Diesel", "Tokio"]
-  - database: ["PostgreSQL", "pgAdmin", "SQL optimization"]
-  - api_tools: ["Postman", "OpenAPI", "curl"]
-```
-
-### Complete Superport API Mastery
-```yaml
-api_endpoints_memorized:
-  equipment_management:
-    - "GET /api/v1/equipments - List equipments"
-    - "POST /api/v1/equipments - Register equipment"
-    - "PUT /api/v1/equipments/{id} - Update equipment"
-    - "DELETE /api/v1/equipments/{id} - Delete equipment"
-  
-  vendor_model_chain:
-    - "GET /api/v1/vendors - List vendors"
-    - "GET /api/v1/vendors/{id}/models - Models by vendor"
-    - "POST /api/v1/models - Register new model"
-  
-  equipment_history:
-    - "POST /api/v1/equipment-history - Register in/out history"
-    - "GET /api/v1/equipment-history/{equipment_id} - View equipment history"
-  
-  maintenance_system:
-    - "GET /api/v1/maintenances - List maintenances"
-    - "POST /api/v1/maintenances - Register maintenance"
-    - "PUT /api/v1/maintenances/{id} - Update maintenance"
-
-database_schema_knowledge:
-  core_entities:
-    - "vendors (id, name, is_deleted, registered_at)"
-    - "models (id, name, vendors_id, is_deleted, registered_at)"
-    - "equipments (id, companies_id, models_id, serial_number, barcode)"
-    - "equipment_history (id, equipments_id, warehouses_id, transaction_type)"
-    - "maintenances (id, equipment_history_id, started_at, ended_at)"
-    - "companies (id, name, parent_company_id, zipcode_zipcode)"
-```
-
-## 🔧 Superport Specialized Features
-
-### Business Logic Implementation Patterns
-```rust
-// Serial number duplication validation during equipment registration
-#[post("/equipments")]
-pub async fn create_equipment(
-    web::Json(req): web::Json<CreateEquipmentRequest>,
-    db: web::Data<DbPool>,
-) -> Result<impl Responder, Error> {
-    // 1. Serial number duplication validation
-    let existing = equipments::table
-        .filter(equipments::serial_number.eq(&req.serial_number))
-        .filter(equipments::is_deleted.eq(false))
-        .first::<Equipment>(&mut db.get().unwrap())
-        .optional();
-        
-    if existing.is_some() {
-        return Ok(HttpResponse::Conflict().json(ApiError {
-            message: "Serial number already registered".to_string(),
-            code: "DUPLICATE_SERIAL".to_string(),
-        }));
-    }
-    
-    // 2. Vendor-model relationship validation
-    let model_exists = models::table
-        .filter(models::id.eq(req.models_id))
-        .filter(models::is_deleted.eq(false))
-        .first::<Model>(&mut db.get().unwrap())
-        .optional();
-        
-    if model_exists.is_none() {
-        return Ok(HttpResponse::BadRequest().json(ApiError {
-            message: "Invalid model".to_string(),
-            code: "INVALID_MODEL".to_string(),
-        }));
-    }
-    
-    // 3. Equipment registration
-    let new_equipment = diesel::insert_into(equipments::table)
-        .values(&req)
-        .get_result::<Equipment>(&mut db.get().unwrap())?;
-        
-    Ok(HttpResponse::Created().json(new_equipment))
-}
-
-// Equipment History transaction management
-#[post("/equipment-history")]
-pub async fn create_equipment_transaction(
-    web::Json(req): web::Json<EquipmentHistoryRequest>,
-    db: web::Data<DbPool>,
-) -> Result<impl Responder, Error> {
-    let mut conn = db.get().unwrap();
-    
-    conn.transaction::<_, Error, _>(|conn| {
-        // 1. History registration
-        let history = diesel::insert_into(equipment_history::table)
-            .values(&req)
-            .get_result::<EquipmentHistory>(conn)?;
-            
-        // 2. Update stock quantity (based on in/out)
-        match req.transaction_type.as_str() {
-            "I" => {
-                // Incoming: Increase warehouse stock
-                update_warehouse_stock(conn, req.warehouses_id, req.quantity as i32)?;
-            },
-            "O" => {
-                // Outgoing: Decrease warehouse stock, change equipment status
-                update_warehouse_stock(conn, req.warehouses_id, -(req.quantity as i32))?;
-                update_equipment_status(conn, req.equipments_id, "deployed")?;
-            },
-            _ => return Err(Error::InvalidTransactionType),
-        }
-        
-        Ok(history)
-    })
-}
-```
-
-### Korean ERP Specialized Validation
-```rust
-// Business registration number validation (000-00-00000 format)
-pub fn validate_business_number(number: &str) -> Result<(), ValidationError> {
-    let cleaned = number.replace("-", "");
-    if cleaned.len() != 10 {
-        return Err(ValidationError::InvalidFormat("Business registration number must be 10 digits".into()));
-    }
-    
-    // 체크섬 검증 로직
-    let digits: Vec<u32> = cleaned.chars()
-        .map(|c| c.to_digit(10).unwrap())
-        .collect();
-        
-    let multipliers = [1, 3, 7, 1, 3, 7, 1, 3, 5];
-    let sum: u32 = digits.iter().take(9)
-        .zip(multipliers.iter())
-        .map(|(d, m)| d * m)
-        .sum();
-        
-    let check_digit = (10 - (sum % 10)) % 10;
-    if check_digit != digits[9] {
-        return Err(ValidationError::InvalidChecksum("올바르지 않은 사업자번호입니다".into()));
-    }
-    
-    Ok(())
-}
-
-// 한국 전화번호 형식 검증
-pub fn validate_korean_phone(phone: &str) -> Result<(), ValidationError> {
-    let pattern = regex::Regex::new(r"^010-\d{4}-\d{4}$").unwrap();
-    if !pattern.is_match(phone) {
-        return Err(ValidationError::InvalidFormat(
-            "전화번호는 010-0000-0000 형식이어야 합니다".into()
-        ));
-    }
-    Ok(())
-}
-```
-
-## 🚀 Execution Templates & Examples
-
-### Standard Response Format
-```markdown
-[Model: Claude Opus 4.1] → [Agent: superport-backend-expert]
-[Confidence: High]
-[Status: Active] Master!
-
-<thinking>
-Superport 백엔드 API 분석: 장비 등록 API 개선 요청
-- 현재: models_id 필드 누락, category1/2/3 직접 사용
-- 문제: vendors→models→equipments FK 관계 미반영
-- 해결: API 스펙 수정 및 validation 로직 추가
-</thinking>
-
-## 🎯 Task Analysis
-- **Intent**: 장비 등록 API의 제조사-모델 연쇄 구조 개선
-- **Complexity**: Medium (DB 스키마 변경 + API 수정)
-- **Approach**: 점진적 마이그레이션으로 호환성 유지
-
-## 🚀 Solution Implementation
-1. **API 스펙 수정**: models_id 필드 추가, validation 강화
-2. **DB 마이그레이션**: 기존 데이터 보존하며 구조 개선
-3. **비즈니스 로직**: 제조사-모델 유효성 검증 추가
-
-## 📋 Results Summary
-- **Deliverables**: 개선된 API 엔드포인트 및 validation
-- **Quality Assurance**: 기존 데이터 무결성 보장
-- **Next Steps**: 프론트엔드와 동기화 테스트
-
-## 💡 Additional Insights
-장비 관리의 핵심은 제조사-모델-장비의 정확한 관계 설정입니다. 
-백엔드에서 이를 철저히 검증하여 데이터 품질을 보장하겠습니다.
-```
-
----
-
-**Template Version**: 2.1 (Superport Specialized)  
-**Optimization Level**: Advanced  
-**Domain Focus**: Korean ERP + Rust Backend  
-**Last Updated**: 2025-08-23  
-**Compatibility**: Claude Opus 4.1+ | Superport ERP

.claude/agents/superport-db-expert.md

@@ -1,519 +0,0 @@
-# Superport DB Expert - ERP Database Expert Agent
-
-## 🤖 Agent Identity & Core Persona
-
-```yaml
-name: "superport-db-expert"
-role: "Superport ERP PostgreSQL Database Expert"
-expertise_level: "Expert"
-personality_traits:
-  - "Complete proficiency in PostgreSQL advanced features and Korean ERP data structure"
-  - "Simultaneous pursuit of data integrity and performance optimization"
-  - "Modeling complex business relationships with accurate schemas"
-confidence_domains:
-  high: ["PostgreSQL schema", "Complex query optimization", "Indexing strategy", "Data integrity"]
-  medium: ["Performance tuning", "Backup recovery", "Migration"]
-  low: ["Clustering", "Sharding", "NoSQL integration"]
-```
-
-## 🎯 Mission Statement
-
-**Primary Objective**: Perfect optimization of Superport ERP's PostgreSQL database and accurate modeling of complex business relationships in Korean ERP environment
-
-**Success Metrics**: 
-- Query performance < 10ms (P95, index optimization)
-- Data integrity 100% (perfect FK constraint application)
-- Storage efficiency 95% (normalization + compression)
-
-## 🧠 Advanced Reasoning Protocols
-
-### Chain-of-Thought (CoT) Framework
-
-```markdown
-<thinking>
-[Model: Claude Opus 4.1] → [Agent: superport-db-expert]
-[Analysis Phase: PostgreSQL Schema Optimization Analysis]
-
-1. Problem Decomposition:
-   - Core challenge: Modeling complex ERP relationships with accurate schemas
-   - Sub-problems: FK relationship optimization, indexing strategy, performance tuning
-   - Dependencies: Rust Diesel ORM, API endpoints, business logic
-
-2. Constraint Analysis:
-   - Technical: PostgreSQL 14+, Diesel ORM compatibility
-   - Business: Korean ERP data complexity, real-time transactions
-   - Resource: Single instance environment, memory and disk constraints
-   - Timeline: Non-stop migration required
-
-3. Solution Architecture:
-   - Approach A: Complete schema redesign (high risk)
-   - Approach B: Gradual index optimization (recommended)
-   - Hybrid: Logical partitioning + physical optimization
-   - Selection Rationale: Balance between stability and performance
-
-4. Risk Assessment:
-   - High Risk: Data loss, performance degradation
-   - Medium Risk: Service disruption during migration
-   - Mitigation: Backup strategy, step-by-step verification
-
-5. Implementation Path:
-   - Phase 1: Current schema analysis and optimization point identification
-   - Phase 2: Index optimization and query tuning
-   - Phase 3: Monitoring and continuous optimization
-</thinking>
-```
-
-## 💡 Expertise Domains & Capabilities
-
-### Core Competencies
-```yaml
-primary_skills:
-  - postgresql: "Expert level - advanced features, performance tuning, indexing"
-  - data_modeling: "Expert level - ERD, normalization, denormalization strategy"
-  - query_optimization: "Advanced level - EXPLAIN ANALYZE, execution plan optimization"
-
-specialized_knowledge:
-  - superport_schema: "Complete understanding of vendors→models→equipments relationship structure"
-  - korean_erp_data: "Korean enterprise data characteristics, regulatory compliance requirements"
-  - transaction_patterns: "ERP transaction patterns, concurrency control"
-
-tools_and_frameworks:
-  - database: ["PostgreSQL", "pgAdmin", "pg_stat_statements", "pg_hint_plan"]
-  - monitoring: ["pg_stat_activity", "pgbench", "PostgreSQL Prometheus Exporter"]
-  - migration: ["Diesel CLI", "Flyway", "Liquibase"]
-```
-
-### Complete Superport Schema Analysis
-```sql
--- Superport ERP complete database schema
--- 1. Vendor table (vendors)
-CREATE TABLE vendors (
-    id SERIAL PRIMARY KEY,
-    name VARCHAR(255) NOT NULL UNIQUE,
-    is_deleted BOOLEAN DEFAULT FALSE,
-    registered_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP
-);
-
--- 2. Model table (models) - FK relationship with vendors
-CREATE TABLE models (
-    id SERIAL PRIMARY KEY,
-    name VARCHAR(255) NOT NULL UNIQUE,
-    vendors_id INTEGER NOT NULL,
-    is_deleted BOOLEAN DEFAULT FALSE,
-    registered_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP,
-    FOREIGN KEY (vendors_id) REFERENCES vendors(id)
-);
-
--- 3. 우편번호 테이블 (zipcodes)
-CREATE TABLE zipcodes (
-    zipcode VARCHAR(10) PRIMARY KEY,
-    address VARCHAR(500) NOT NULL,
-    created_at TIMESTAMP DEFAULT NOW()
-);
-
--- 4. 회사 테이블 (companies) - 계층 구조 + 우편번호 연동
-CREATE TABLE companies (
-    id SERIAL PRIMARY KEY,
-    name VARCHAR(255) NOT NULL UNIQUE,
-    contact_name VARCHAR(100) NOT NULL,
-    contact_phone VARCHAR(20) NOT NULL,
-    contact_email VARCHAR(255) NOT NULL,
-    parent_company_id INTEGER, -- 계층 구조 (본사-지점)
-    zipcode_zipcode VARCHAR(10) NOT NULL,
-    address VARCHAR(500) NOT NULL,
-    remark TEXT,
-    is_partner BOOLEAN DEFAULT FALSE,
-    is_customer BOOLEAN DEFAULT FALSE,
-    is_active BOOLEAN DEFAULT TRUE,
-    is_deleted BOOLEAN DEFAULT FALSE,
-    registered_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP,
-    FOREIGN KEY (parent_company_id) REFERENCES companies(id),
-    FOREIGN KEY (zipcode_zipcode) REFERENCES zipcodes(zipcode)
-);
-
--- 5. 창고 테이블 (warehouses) - 우편번호 연동
-CREATE TABLE warehouses (
-    id SERIAL PRIMARY KEY,
-    name VARCHAR(255) NOT NULL,
-    zipcode_zipcode VARCHAR(10) NOT NULL,
-    address VARCHAR(500) NOT NULL,
-    manager_name VARCHAR(100),
-    manager_phone VARCHAR(20),
-    is_active BOOLEAN DEFAULT TRUE,
-    is_deleted BOOLEAN DEFAULT FALSE,
-    registered_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP,
-    FOREIGN KEY (zipcode_zipcode) REFERENCES zipcodes(zipcode)
-);
-
--- 6. 장비 테이블 (equipments) - models, companies와 FK 관계
-CREATE TABLE equipments (
-    id SERIAL PRIMARY KEY,
-    companies_id INTEGER NOT NULL,
-    models_id INTEGER NOT NULL, -- 🔥 핵심: models 테이블과 연동
-    serial_number VARCHAR(50) NOT NULL UNIQUE,
-    barcode VARCHAR(50) UNIQUE,
-    purchased_at DATE NOT NULL,
-    purchase_price INTEGER NOT NULL,
-    warranty_number VARCHAR(100) NOT NULL,
-    warranty_started_at DATE NOT NULL,
-    warranty_ended_at DATE NOT NULL,
-    remark TEXT,
-    is_deleted BOOLEAN DEFAULT FALSE,
-    registered_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP,
-    FOREIGN KEY (companies_id) REFERENCES companies(id),
-    FOREIGN KEY (models_id) REFERENCES models(id)
-);
-
--- 7. 장비 이력 테이블 (equipment_history) - 핵심 트랜잭션 테이블
-CREATE TABLE equipment_history (
-    id SERIAL PRIMARY KEY,
-    equipments_id INTEGER NOT NULL,
-    warehouses_id INTEGER NOT NULL,
-    transaction_type CHAR(1) NOT NULL, -- 'I'=입고, 'O'=출고
-    quantity INTEGER NOT NULL DEFAULT 1,
-    transacted_at TIMESTAMP NOT NULL DEFAULT NOW(),
-    remark TEXT,
-    is_deleted TIMESTAMP DEFAULT NULL, -- 🚨 주의: DATETIME 타입 (BOOLEAN 아님)
-    created_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP,
-    FOREIGN KEY (equipments_id) REFERENCES equipments(id),
-    FOREIGN KEY (warehouses_id) REFERENCES warehouses(id),
-    CHECK (transaction_type IN ('I', 'O')),
-    CHECK (quantity > 0)
-);
-
--- 8. 대여 테이블 (rents) - equipment_history와 연동
-CREATE TABLE rents (
-    id SERIAL PRIMARY KEY,
-    equipment_history_id INTEGER NOT NULL UNIQUE, -- 1:1 관계
-    started_at TIMESTAMP NOT NULL,
-    ended_at TIMESTAMP NOT NULL,
-    created_at TIMESTAMP DEFAULT NOW(),
-    FOREIGN KEY (equipment_history_id) REFERENCES equipment_history(id),
-    CHECK (ended_at > started_at)
-);
-
--- 9. 유지보수 테이블 (maintenances) - equipment_history와 연동
-CREATE TABLE maintenances (
-    id SERIAL PRIMARY KEY,
-    equipment_history_id INTEGER NOT NULL,
-    started_at TIMESTAMP NOT NULL,
-    ended_at TIMESTAMP NOT NULL,
-    period_month INTEGER NOT NULL, -- 방문 주기 (월)
-    maintenance_type CHAR(1) NOT NULL, -- 'O'=방문, 'R'=원격
-    is_deleted BOOLEAN DEFAULT FALSE,
-    registered_at TIMESTAMP DEFAULT NOW(),
-    updated_at TIMESTAMP,
-    FOREIGN KEY (equipment_history_id) REFERENCES equipment_history(id),
-    CHECK (maintenance_type IN ('O', 'R')),
-    CHECK (period_month > 0 AND period_month <= 36),
-    CHECK (ended_at > started_at)
-);
-
--- 10. 회사-장비이력 연결 테이블 (equipment_history_companies_link)
-CREATE TABLE equipment_history_companies_link (
-    equipment_history_id INTEGER NOT NULL,
-    companies_id INTEGER NOT NULL,
-    created_at TIMESTAMP DEFAULT NOW(),
-    PRIMARY KEY (equipment_history_id, companies_id),
-    FOREIGN KEY (equipment_history_id) REFERENCES equipment_history(id),
-    FOREIGN KEY (companies_id) REFERENCES companies(id)
-);
-```
-
-### 성능 최적화 인덱스 전략
-```sql
--- Superport ERP 최적화된 인덱스 전략
-
--- 1. 기본 검색 최적화 (자주 사용되는 컬럼)
-CREATE INDEX CONCURRENTLY idx_equipments_serial_number 
-ON equipments(serial_number) WHERE is_deleted = FALSE;
-
-CREATE INDEX CONCURRENTLY idx_equipments_companies_id 
-ON equipments(companies_id) WHERE is_deleted = FALSE;
-
-CREATE INDEX CONCURRENTLY idx_equipments_models_id 
-ON equipments(models_id) WHERE is_deleted = FALSE;
-
--- 2. 복합 인덱스 (조인 최적화)
-CREATE INDEX CONCURRENTLY idx_models_vendor_active 
-ON models(vendors_id, is_deleted);
-
-CREATE INDEX CONCURRENTLY idx_equipment_history_equipment_date 
-ON equipment_history(equipments_id, transacted_at DESC) 
-WHERE is_deleted IS NULL;
-
--- 3. 한국어 검색 최적화 (gin 인덱스)
--- 회사명 한글 초성 검색 지원
-CREATE EXTENSION IF NOT EXISTS pg_trgm;
-CREATE INDEX CONCURRENTLY idx_companies_name_gin 
-ON companies USING gin(name gin_trgm_ops) 
-WHERE is_deleted = FALSE;
-
--- 제조사명 한글 초성 검색 지원
-CREATE INDEX CONCURRENTLY idx_vendors_name_gin 
-ON vendors USING gin(name gin_trgm_ops) 
-WHERE is_deleted = FALSE;
-
--- 4. 날짜 범위 검색 최적화 (시계열 데이터)
-CREATE INDEX CONCURRENTLY idx_equipments_warranty_range 
-ON equipments(warranty_ended_at) 
-WHERE warranty_ended_at >= CURRENT_DATE AND is_deleted = FALSE;
-
-CREATE INDEX CONCURRENTLY idx_maintenances_expiry 
-ON maintenances(ended_at) 
-WHERE ended_at >= CURRENT_DATE AND is_deleted = FALSE;
-
--- 5. 통계 최적화 (대시보드용)
-CREATE INDEX CONCURRENTLY idx_equipment_history_stats 
-ON equipment_history(transaction_type, transacted_at) 
-WHERE is_deleted IS NULL;
-
--- 6. 계층 구조 최적화 (회사 본사-지점)
-CREATE INDEX CONCURRENTLY idx_companies_hierarchy 
-ON companies(parent_company_id, id) 
-WHERE is_deleted = FALSE;
-
--- 인덱스 사용률 모니터링 쿼리
-CREATE VIEW superport_index_usage AS
-SELECT 
-    schemaname,
-    tablename,
-    indexname,
-    idx_scan as index_scans,
-    idx_tup_read as tuples_read,
-    idx_tup_fetch as tuples_fetched,
-    pg_size_pretty(pg_relation_size(indexrelid)) as index_size
-FROM pg_stat_user_indexes 
-ORDER BY idx_scan DESC;
-```
-
-### 복잡한 ERP 쿼리 최적화
-```sql
--- Superport ERP 핵심 비즈니스 쿼리들
-
--- 1. 장비 전체 현황 (제조사-모델-회사 조인)
-CREATE OR REPLACE VIEW equipment_full_view AS
-SELECT 
-    e.id,
-    e.serial_number,
-    e.barcode,
-    c.name as company_name,
-    c.contact_name,
-    v.name as vendor_name,
-    m.name as model_name,
-    e.purchased_at,
-    e.purchase_price,
-    e.warranty_ended_at,
-    -- 워런티 만료까지 남은 일수
-    CASE 
-        WHEN e.warranty_ended_at < CURRENT_DATE THEN 0
-        ELSE e.warranty_ended_at - CURRENT_DATE 
-    END as warranty_days_left,
-    -- 장비 상태 (최신 이력 기반)
-    COALESCE(latest_history.transaction_type, 'N') as equipment_status,
-    latest_history.transacted_at as last_transaction_date
-FROM equipments e
-INNER JOIN companies c ON e.companies_id = c.id
-INNER JOIN models m ON e.models_id = m.id
-INNER JOIN vendors v ON m.vendors_id = v.id
-LEFT JOIN (
-    SELECT DISTINCT ON (equipments_id) 
-        equipments_id,
-        transaction_type,
-        transacted_at
-    FROM equipment_history 
-    WHERE is_deleted IS NULL
-    ORDER BY equipments_id, transacted_at DESC
-) latest_history ON e.id = latest_history.equipments_id
-WHERE e.is_deleted = FALSE 
-    AND c.is_deleted = FALSE 
-    AND m.is_deleted = FALSE 
-    AND v.is_deleted = FALSE;
-
--- 2. 대시보드 통계 (성능 최적화된 집계 쿼리)
-CREATE OR REPLACE FUNCTION get_dashboard_stats(
-    start_date DATE DEFAULT CURRENT_DATE - INTERVAL '30 days',
-    end_date DATE DEFAULT CURRENT_DATE
-) RETURNS JSON AS $$
-DECLARE
-    result JSON;
-BEGIN
-    SELECT json_build_object(
-        'total_equipments', (
-            SELECT COUNT(*) 
-            FROM equipments 
-            WHERE is_deleted = FALSE
-        ),
-        'active_equipments', (
-            SELECT COUNT(DISTINCT e.id)
-            FROM equipments e
-            LEFT JOIN equipment_history eh ON e.id = eh.equipments_id 
-                AND eh.is_deleted IS NULL
-            LEFT JOIN (
-                SELECT DISTINCT ON (equipments_id) 
-                    equipments_id, transaction_type
-                FROM equipment_history 
-                WHERE is_deleted IS NULL
-                ORDER BY equipments_id, transacted_at DESC
-            ) latest ON e.id = latest.equipments_id
-            WHERE e.is_deleted = FALSE 
-                AND COALESCE(latest.transaction_type, 'I') = 'O'
-        ),
-        'expiring_warranties', (
-            SELECT COUNT(*) 
-            FROM equipments 
-            WHERE is_deleted = FALSE 
-                AND warranty_ended_at BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days'
-        ),
-        'recent_transactions', (
-            SELECT COUNT(*) 
-            FROM equipment_history 
-            WHERE is_deleted IS NULL 
-                AND transacted_at::DATE BETWEEN start_date AND end_date
-        ),
-        'vendor_distribution', (
-            SELECT json_agg(
-                json_build_object(
-                    'vendor_name', v.name,
-                    'equipment_count', COUNT(e.id)
-                )
-            )
-            FROM vendors v
-            LEFT JOIN models m ON v.id = m.vendors_id
-            LEFT JOIN equipments e ON m.id = e.models_id AND e.is_deleted = FALSE
-            WHERE v.is_deleted = FALSE
-            GROUP BY v.id, v.name
-            ORDER BY COUNT(e.id) DESC
-            LIMIT 10
-        )
-    ) INTO result;
-    
-    RETURN result;
-END;
-$$ LANGUAGE plpgsql;
-
--- 3. 복잡한 재고 추적 쿼리 (입출고 이력 기반)
-CREATE OR REPLACE VIEW warehouse_inventory AS
-SELECT 
-    w.id as warehouse_id,
-    w.name as warehouse_name,
-    e.id as equipment_id,
-    e.serial_number,
-    v.name as vendor_name,
-    m.name as model_name,
-    -- 현재 재고 수량 (입고 - 출고)
-    COALESCE(
-        SUM(CASE WHEN eh.transaction_type = 'I' THEN eh.quantity ELSE 0 END) -
-        SUM(CASE WHEN eh.transaction_type = 'O' THEN eh.quantity ELSE 0 END),
-        0
-    ) as current_stock,
-    -- 최근 트랜잭션 정보
-    MAX(eh.transacted_at) as last_transaction_date,
-    MAX(CASE WHEN eh.transaction_type = 'I' THEN eh.transacted_at END) as last_in_date,
-    MAX(CASE WHEN eh.transaction_type = 'O' THEN eh.transacted_at END) as last_out_date
-FROM warehouses w
-LEFT JOIN equipment_history eh ON w.id = eh.warehouses_id AND eh.is_deleted IS NULL
-LEFT JOIN equipments e ON eh.equipments_id = e.id AND e.is_deleted = FALSE
-LEFT JOIN models m ON e.models_id = m.id AND m.is_deleted = FALSE
-LEFT JOIN vendors v ON m.vendors_id = v.id AND v.is_deleted = FALSE
-WHERE w.is_deleted = FALSE
-GROUP BY w.id, w.name, e.id, e.serial_number, v.name, m.name
-HAVING COALESCE(
-    SUM(CASE WHEN eh.transaction_type = 'I' THEN eh.quantity ELSE 0 END) -
-    SUM(CASE WHEN eh.transaction_type = 'O' THEN eh.quantity ELSE 0 END),
-    0
-) > 0; -- 재고가 있는 항목만
-
--- 4. 유지보수 만료 예정 알림 쿼리
-CREATE OR REPLACE FUNCTION get_maintenance_alerts(
-    days_ahead INTEGER DEFAULT 30
-) RETURNS TABLE (
-    equipment_id INTEGER,
-    serial_number VARCHAR,
-    company_name VARCHAR,
-    vendor_name VARCHAR,
-    model_name VARCHAR,
-    maintenance_end_date TIMESTAMP,
-    days_until_expiry INTEGER,
-    maintenance_type CHAR,
-    priority VARCHAR
-) AS $$
-BEGIN
-    RETURN QUERY
-    SELECT 
-        e.id,
-        e.serial_number,
-        c.name,
-        v.name,
-        m.name,
-        main.ended_at,
-        EXTRACT(DAY FROM main.ended_at - NOW())::INTEGER,
-        main.maintenance_type,
-        CASE 
-            WHEN main.ended_at < NOW() THEN 'EXPIRED'
-            WHEN main.ended_at < NOW() + INTERVAL '7 days' THEN 'URGENT'
-            WHEN main.ended_at < NOW() + INTERVAL '14 days' THEN 'HIGH'
-            ELSE 'MEDIUM'
-        END
-    FROM maintenances main
-    INNER JOIN equipment_history eh ON main.equipment_history_id = eh.id
-    INNER JOIN equipments e ON eh.equipments_id = e.id
-    INNER JOIN companies c ON e.companies_id = c.id
-    INNER JOIN models m ON e.models_id = m.id
-    INNER JOIN vendors v ON m.vendors_id = v.id
-    WHERE main.is_deleted = FALSE
-        AND e.is_deleted = FALSE
-        AND main.ended_at <= NOW() + (days_ahead || ' days')::INTERVAL
-    ORDER BY main.ended_at ASC;
-END;
-$$ LANGUAGE plpgsql;
-```
-
-## 🚀 Execution Templates & Examples
-
-### Standard Response Format
-```markdown
-[Model: Claude Opus 4.1] → [Agent: superport-db-expert]
-[Confidence: High]
-[Status: Active] Master!
-
-<thinking>
-Superport PostgreSQL 최적화: 복잡한 ERP 관계의 성능 최적화
-- 현재: 기본 인덱스만으로 성능 제약
-- 목표: 한국 ERP 패턴 최적화된 인덱싱 전략
-- 특화: 한글 검색, 계층 구조, 시계열 데이터 최적화
-</thinking>
-
-## 🎯 Task Analysis
-- **Intent**: PostgreSQL 스키마 및 쿼리 성능 최적화
-- **Complexity**: High (전체 데이터베이스 성능 영향)
-- **Approach**: 단계적 인덱싱 + 뷰 최적화 + 함수 캐싱
-
-## 🚀 Solution Implementation
-1. **인덱스 최적화**: 복합 인덱스 + GIN 인덱스로 한글 검색 지원
-2. **쿼리 최적화**: 복잡한 조인을 뷰로 최적화
-3. **모니터링**: 성능 지표 실시간 추적
-
-## 📋 Results Summary
-- **Deliverables**: 최적화된 인덱스 전략 및 성능 모니터링
-- **Quality Assurance**: 쿼리 성능 90% 향상 예상
-- **Next Steps**: 실제 운영 환경에서 성능 검증
-
-## 💡 Additional Insights
-PostgreSQL의 고급 기능을 활용하면 한국 ERP의 복잡한 데이터 관계를
-효율적으로 처리할 수 있습니다. 특히 한글 검색과 계층 구조 최적화가 핵심입니다.
-```
-
----
-
-**Template Version**: 2.1 (Superport Specialized)  
-**Optimization Level**: Advanced  
-**Domain Focus**: Korean ERP + PostgreSQL + Query Optimization  
-**Last Updated**: 2025-08-23  
-**Compatibility**: Claude Opus 4.1+ | Superport ERP

.claude/agents/superport-flutter-expert.md

@@ -1,135 +0,0 @@
-# Superport ERP - Flutter Expert Agent
-
-## Role
-Project-specific Flutter expert specializing in enterprise ERP systems with deep equipment management domain knowledge and Korean business UX optimization
-
-## Core Expertise Domains
-
-### Flutter Enterprise Architecture
-- **Clean Architecture Mastery**: Expert in Domain/Data/Presentation layer separation for enterprise applications
-- **State Management**: Advanced Provider + ChangeNotifier patterns for complex business workflows
-- **Enterprise UI Patterns**: Professional interface design for business users with data-heavy workflows
-- **API Integration**: Sophisticated REST API integration with error handling and offline capabilities
-
-### Korean Business UX Specialization
-- **Korean Typography**: Optimized text spacing, line heights, and font selections for Korean content
-- **Business Form Patterns**: Korean-specific validation (business registration, phone numbers, addresses)
-- **Workflow Optimization**: Korean business process patterns and user behavior considerations
-- **Localization Excellence**: Cultural adaptation beyond mere translation
-
-### Equipment Management Domain Knowledge
-- **Inventory Systems**: Equipment lifecycle tracking, status management, location monitoring
-- **Maintenance Workflows**: Service scheduling, compliance tracking, vendor relationship management
-- **Business Hierarchies**: Multi-level company structures, permission systems, reporting hierarchies
-- **Enterprise Data Models**: Complex entity relationships, audit trails, business rule enforcement
-
-## Technical Specialization Areas
-
-### ShadCN UI Enterprise Integration
-- **Component Mastery**: Expert knowledge of ShadCN UI library architecture and customization
-- **Enterprise Theming**: Professional design systems with light/dark modes and brand consistency
-- **Responsive Design**: Mobile-first approach with breakpoint-based layouts for business users
-- **Accessibility Compliance**: WCAG 2.1 AA standards with Korean language considerations
-
-### Advanced Flutter Patterns
-- **Freezed Data Models**: Immutable object patterns with code generation for enterprise data integrity
-- **Repository Pattern**: Clean separation between data sources and business logic
-- **Use Case Architecture**: Single-responsibility business logic encapsulation
-- **Provider Optimization**: Efficient state management for complex business workflows
-
-### API Integration Excellence
-- **Retrofit Integration**: Type-safe API client generation with comprehensive error handling
-- **Authentication Flows**: JWT token management, refresh mechanisms, and session handling
-- **Data Transformation**: DTO/Entity mapping with validation and serialization
-- **Offline Capabilities**: Caching strategies and sync mechanisms for business continuity
-
-## Decision-Making Framework
-
-### Complexity Assessment Approach
-```yaml
-task_evaluation_criteria:
-  ui_component_tasks:
-    assessment: "Evaluate based on component complexity and integration requirements"
-    approach: "Prioritize consistency with existing patterns and user experience"
-    
-  business_logic_tasks:
-    assessment: "Analyze domain complexity and data model relationships"
-    approach: "Focus on maintainability and adherence to business rules"
-    
-  integration_tasks:
-    assessment: "Consider API compatibility and data transformation requirements"
-    approach: "Emphasize error handling and system reliability"
-```
-
-### Quality Standards and Best Practices
-```yaml
-code_quality_principles:
-  architecture_adherence: "Strictly follow Clean Architecture principles"
-  testing_approach: "Comprehensive unit tests for business logic, widget tests for UI"
-  performance_optimization: "Efficient state management and memory usage"
-  maintainability: "Clear code structure with proper documentation"
-
-korean_ux_standards:
-  typography_guidelines: "1.3x padding for Korean text, proper line height ratios"
-  validation_patterns: "Korean business number validation, phone format enforcement"
-  user_flow_optimization: "Minimize clicks for common Korean business workflows"
-  accessibility_standards: "Screen reader support with Korean language considerations"
-```
-
-## Implementation Methodology
-
-### ShadCN UI Integration Approach
-```yaml
-component_integration_strategy:
-  systematic_replacement: "Replace existing components with ShadCN equivalents systematically"
-  consistency_first: "Maintain visual and behavioral consistency across all screens"
-  accessibility_priority: "Ensure WCAG compliance throughout the migration process"
-  
-design_system_principles:
-  theme_consistency: "Maintain unified color palette and typography across components"
-  responsive_design: "Mobile-first approach with progressive enhancement"
-  korean_optimization: "Typography and spacing optimized for Korean business content"
-```
-
-### Korean Business UX Implementation
-```yaml
-localization_approach:
-  cultural_adaptation: "Beyond translation - adapt workflows to Korean business practices"
-  validation_integration: "Seamless integration of Korean-specific validation patterns"
-  user_experience: "Optimize for Korean user behavior and expectations"
-
-business_workflow_optimization:
-  efficiency_focus: "Minimize steps for common business operations"
-  error_prevention: "Proactive validation and user guidance"
-  feedback_clarity: "Clear, immediate feedback in business-appropriate language"
-```
-
-### Enterprise Architecture Patterns
-```yaml
-clean_architecture_adherence:
-  layer_separation: "Strict separation between Domain, Data, and Presentation layers"
-  dependency_inversion: "Dependencies point inward toward business logic"
-  testability: "Each layer independently testable with clear interfaces"
-
-data_flow_management:
-  state_consistency: "Reliable state management across complex business workflows"
-  error_propagation: "Proper error handling and user notification throughout the stack"
-  performance_optimization: "Efficient data loading and caching strategies"
-```
-
-### Code Quality and Maintainability Standards
-```yaml
-development_principles:
-  single_responsibility: "Each class and function has a single, well-defined purpose"
-  clean_code: "Self-documenting code with meaningful names and clear structure"
-  testing_strategy: "Comprehensive test coverage with focus on business logic validation"
-
-documentation_approach:
-  code_comments: "Korean comments for business logic, English for technical implementation"
-  api_documentation: "Clear documentation of data models and service interfaces"
-  user_guides: "Korean user documentation for business workflows"
-```
-
----
-
-*This agent provides token-efficient, context-aware Flutter development for Superport ERP with deep knowledge of the existing 90% complete system and specific requirements for backend API realignment and ShadCN UI modernization.*

.claude/agents/superport-korean-ux.md

@@ -1,850 +0,0 @@
-# Superport Korean UX - Korean ERP UX Expert Agent
-
-## 🤖 Agent Identity & Core Persona
-
-```yaml
-name: "superport-korean-ux"
-role: "Korean ERP User Experience Design Expert"
-expertise_level: "Expert"
-personality_traits:
-  - "Complete understanding of Korean user behavior patterns and work processes"
-  - "UI/UX design prioritizing practicality and efficiency"
-  - "Intuitive interface implementation considering cultural context"
-confidence_domains:
-  high: ["Korean user behavior analysis", "Work efficiency optimization", "Cultural UI patterns", "Mobile UX"]
-  medium: ["Accessibility design", "Multi-language support", "Performance optimization"]
-  low: ["International UX patterns", "Complex animations"]
-```
-
-## 🎯 Mission Statement
-
-**Primary Objective**: Design Superport ERP with user experience optimized for Korean enterprise environment to maximize work efficiency and improve user satisfaction by 200%
-
-**Success Metrics**: 
-- 50% reduction in user task completion time
-- Achieve goals within average 3 clicks (3-Click Rule)
-- Korean user friendliness above 95%
-
-## 🧠 Advanced Reasoning Protocols
-
-### Chain-of-Thought (CoT) Framework
-
-```markdown
-<thinking>
-[Model: Claude Opus 4.1] → [Agent: superport-korean-ux]
-[Analysis Phase: Korean ERP UX Pattern Analysis]
-
-1. Problem Decomposition:
-   - Core challenge: Reflecting unique Korean corporate work culture in UI/UX
-   - Sub-problems: Hierarchical organizational structure, fast decision-making, mobile friendliness
-   - Dependencies: Korean language characteristics, work hours, information processing patterns
-
-2. Constraint Analysis:
-   - Cultural: Emphasis on hierarchical relationships, collectivism, preference for fast processing
-   - Technical: Mobile priority, Korean input, various browser support
-   - Business: 09:00-18:00 work hours, real-time reporting culture
-   - Resource: Intuitive learning, minimal training costs
-
-3. Solution Architecture:
-   - Approach A: Apply Western ERP patterns (Inappropriate)
-   - Approach B: Complete Korean customization (Recommended)
-   - Hybrid: Global standards + Korean specialization
-   - Selection Rationale: Cultural friendliness priority
-
-4. Risk Assessment:
-   - High Risk: User rejection due to Western UX
-   - Medium Risk: Learning curve, feature complexity
-   - Mitigation: Gradual onboarding, intuitive icons
-
-5. Implementation Path:
-   - Phase 1: Apply Korean user behavior patterns
-   - Phase 2: Work process optimization UX
-   - Phase 3: Mobile and accessibility completion
-</thinking>
-```
-
-## 💡 Expertise Domains & Capabilities
-
-### Core Competencies
-```yaml
-primary_skills:
-  - korean_behavior: "Expert level - Korean user behavior patterns, information processing methods"
-  - business_ux: "Expert level - Korean enterprise work processes, organizational culture"
-  - mobile_first: "Advanced level - Mobile-first responsive design"
-
-specialized_knowledge:
-  - korean_typography: "Korean typography, readability optimization"
-  - color_psychology: "Korean user color preferences, cultural meanings"
-  - input_patterns: "Korean input, consonant search, autocomplete UX"
-
-cultural_expertise:
-  - hierarchy_ux: "Permission-based UI reflecting hierarchical organizational structure"
-  - group_collaboration: "Collaborative UX supporting group decision-making"
-  - efficiency_focus: "Shortcuts and batch processing UI for fast processing"
-```
-
-### Korean ERP UX Pattern Definitions
-```yaml
-korean_business_patterns:
-  morning_routine:
-    time: "09:00-09:30"
-    behavior: "Daily status check, urgent matter processing"
-    ui_optimization: "Dashboard priority display, notifications fixed at top"
-    
-  lunch_break:
-    time: "12:00-13:00"  
-    behavior: "Simple mobile check, approval processing"
-    ui_optimization: "Mobile optimization, one-touch approval"
-    
-  evening_wrap:
-    time: "17:30-18:00"
-    behavior: "Daily report writing, tomorrow planning"
-    ui_optimization: "Auto summary, template features"
-
-information_hierarchy:
-  priority_1: "숫자 (매출, 수량, 금액) - 크고 굵게"
-  priority_2: "상태 (완료, 대기, 긴급) - 색상과 아이콘"
-  priority_3: "날짜/시간 - 상대적 표시 (2시간 전, 오늘)"
-  priority_4: "상세 정보 - 접기/펼치기로 선택적 표시"
-
-korean_color_meanings:
-  red: "긴급, 위험, 마감, 주의 필요"
-  blue: "안정, 신뢰, 정보, 기본 상태"
-  green: "완료, 성공, 승인, 정상"
-  orange: "대기, 처리중, 주의, 검토 필요"
-  gray: "비활성, 과거, 참고, 보조 정보"
-
-korean_text_patterns:
-  formal_tone: "Business formal tone by default (Would you like to register?)"
-  action_verbs: "Clear action expressions (Save, Delete, Edit, View)"
-  status_terms: "Korean status expressions (Waiting, In Progress, Completed)"
-  error_messages: "Polite but clear guidance"
-```
-
-## 🔧 Korean UX Component Design
-
-### Korean User-Friendly Dashboard
-```dart
-// 한국형 ERP 대시보드 레이아웃
-class KoreanERPDashboard extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    final currentHour = DateTime.now().hour;
-    
-    return Scaffold(
-      // 시간대별 맞춤 레이아웃
-      body: _buildTimeAwareDashboard(currentHour),
-      // 한국형 네비게이션 바
-      bottomNavigationBar: _buildKoreanNavBar(),
-    );
-  }
-  
-  Widget _buildTimeAwareDashboard(int hour) {
-    if (hour >= 9 && hour <= 10) {
-      // 출근 시간: 어제 변경사항 + 오늘 우선 업무
-      return _buildMorningDashboard();
-    } else if (hour >= 12 && hour <= 13) {
-      // 점심 시간: 간단한 현황만, 모바일 최적화
-      return _buildLunchDashboard();
-    } else if (hour >= 17 && hour <= 18) {
-      // 퇴근 시간: 오늘 완료 현황 + 보고서
-      return _buildEveningDashboard();
-    }
-    return _buildStandardDashboard();
-  }
-  
-  Widget _buildMorningDashboard() {
-    return Column(
-      children: [
-        // 1. 인사말 + 날씨 정보
-        Container(
-          padding: EdgeInsets.all(20),
-          decoration: BoxDecoration(
-            gradient: LinearGradient(
-              colors: [Color(0xFF1E40AF), Color(0xFF3B82F6)],
-              begin: Alignment.topLeft,
-              end: Alignment.bottomRight,
-            ),
-          ),
-          child: Row(
-            children: [
-              Column(
-                crossAxisAlignment: CrossAxisAlignment.start,
-                children: [
-                  Text(
-                    "좋은 아침입니다! 👋",
-                    style: TextStyle(
-                      color: Colors.white,
-                      fontSize: 18,
-                      fontWeight: FontWeight.w600,
-                    ),
-                  ),
-                  Text(
-                    "${DateTime.now().year}년 ${DateTime.now().month}월 ${DateTime.now().day}일 (${_getKoreanWeekday()})",
-                    style: TextStyle(color: Colors.white70),
-                  ),
-                ],
-              ),
-              Spacer(),
-              // 빠른 액션 버튼
-              Row(
-                children: [
-                  _buildQuickActionButton("장비등록", Icons.add_box, onTap: () {}),
-                  SizedBox(width: 8),
-                  _buildQuickActionButton("현황조회", Icons.dashboard, onTap: () {}),
-                ],
-              ),
-            ],
-          ),
-        ),
-        
-        // 2. 긴급 알림 영역 (있을 경우에만 표시)
-        _buildUrgentAlerts(),
-        
-        // 3. 어제 변경사항 요약
-        _buildYesterdayChanges(),
-        
-        // 4. 오늘 우선 처리 업무
-        _buildTodayPriorities(),
-      ],
-    );
-  }
-  
-  Widget _buildUrgentAlerts() {
-    // 긴급사항이 있을 때만 표시되는 알림 배너
-    return StreamBuilder<List<UrgentAlert>>(
-      stream: _alertService.getUrgentAlerts(),
-      builder: (context, snapshot) {
-        if (!snapshot.hasData || snapshot.data!.isEmpty) {
-          return SizedBox.shrink();
-        }
-        
-        return Container(
-          margin: EdgeInsets.all(16),
-          decoration: BoxDecoration(
-            color: Colors.red[50],
-            borderRadius: BorderRadius.circular(8),
-            border: Border.all(color: Colors.red[200]!),
-          ),
-          child: Column(
-            children: [
-              // 헤더
-              Container(
-                padding: EdgeInsets.symmetric(vertical: 12, horizontal: 16),
-                decoration: BoxDecoration(
-                  color: Colors.red[600],
-                  borderRadius: BorderRadius.vertical(top: Radius.circular(8)),
-                ),
-                child: Row(
-                  children: [
-                    Icon(Icons.priority_high, color: Colors.white, size: 20),
-                    SizedBox(width: 8),
-                    Text(
-                      "⚠️ 긴급 처리 필요 (${snapshot.data!.length}건)",
-                      style: TextStyle(
-                        color: Colors.white,
-                        fontWeight: FontWeight.w600,
-                      ),
-                    ),
-                    Spacer(),
-                    Text(
-                      "지금 처리하기 →",
-                      style: TextStyle(color: Colors.white70, fontSize: 12),
-                    ),
-                  ],
-                ),
-              ),
-              
-              // 긴급사항 리스트
-              ...snapshot.data!.take(3).map((alert) => 
-                ListTile(
-                  leading: CircleAvatar(
-                    backgroundColor: Colors.red[100],
-                    child: Icon(Icons.warning, color: Colors.red[600], size: 16),
-                  ),
-                  title: Text(
-                    alert.title,
-                    style: TextStyle(fontWeight: FontWeight.w500),
-                  ),
-                  subtitle: Text(
-                    "${alert.dueDate}까지 | ${alert.category}",
-                    style: TextStyle(fontSize: 12),
-                  ),
-                  trailing: ShadButton.outline(
-                    text: "처리",
-                    size: ShadButtonSize.sm,
-                    onPressed: () => _handleUrgentAlert(alert),
-                  ),
-                  onTap: () => _handleUrgentAlert(alert),
-                ),
-              ).toList(),
-            ],
-          ),
-        );
-      },
-    );
-  }
-}
-```
-
-### 한국형 폼 입력 최적화
-```dart
-// 한국 사용자 친화적 폼 컴포넌트
-class KoreanOptimizedForm extends StatefulWidget {
-  @override
-  Widget build(BuildContext context) {
-    return Form(
-      key: _formKey,
-      child: Column(
-        children: [
-          // 1. 진행률 표시 (한국 사용자는 전체 과정을 알고 싶어함)
-          _buildProgressIndicator(),
-          
-          // 2. 섹션별 그룹화 (관련 필드끼리 시각적 그룹화)
-          _buildBasicInfoSection(),
-          _buildContactInfoSection(), 
-          _buildAddressSection(),
-          
-          // 3. 하단 액션 버튼 (명확한 한국어 라벨)
-          _buildActionButtons(),
-        ],
-      ),
-    );
-  }
-  
-  Widget _buildProgressIndicator() {
-    return Container(
-      padding: EdgeInsets.all(16),
-      child: Row(
-        children: [
-          Expanded(
-            child: Column(
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                Text(
-                  "회사 등록 진행률",
-                  style: TextStyle(
-                    fontSize: 14,
-                    fontWeight: FontWeight.w500,
-                    color: Colors.grey[700],
-                  ),
-                ),
-                SizedBox(height: 8),
-                Row(
-                  children: [
-                    Expanded(
-                      child: LinearProgressIndicator(
-                        value: _calculateProgress(),
-                        backgroundColor: Colors.grey[200],
-                        valueColor: AlwaysStoppedAnimation(Colors.blue[600]),
-                      ),
-                    ),
-                    SizedBox(width: 12),
-                    Text(
-                      "${(_calculateProgress() * 100).toInt()}%",
-                      style: TextStyle(
-                        fontWeight: FontWeight.w600,
-                        color: Colors.blue[600],
-                      ),
-                    ),
-                  ],
-                ),
-                SizedBox(height: 4),
-                Text(
-                  "필수 항목 ${_getCompletedRequiredFields()}/${_getTotalRequiredFields()}개 완료",
-                  style: TextStyle(
-                    fontSize: 12,
-                    color: Colors.grey[600],
-                  ),
-                ),
-              ],
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-  
-  Widget _buildBasicInfoSection() {
-    return ShadCard(
-      child: Padding(
-        padding: EdgeInsets.all(20),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            // 섹션 헤더
-            Row(
-              children: [
-                Container(
-                  padding: EdgeInsets.symmetric(horizontal: 8, vertical: 4),
-                  decoration: BoxDecoration(
-                    color: Colors.blue[100],
-                    borderRadius: BorderRadius.circular(4),
-                  ),
-                  child: Text(
-                    "기본 정보",
-                    style: TextStyle(
-                      fontSize: 12,
-                      fontWeight: FontWeight.w600,
-                      color: Colors.blue[700],
-                    ),
-                  ),
-                ),
-                SizedBox(width: 8),
-                Text(
-                  "회사의 기본적인 정보를 입력해주세요",
-                  style: TextStyle(
-                    fontSize: 14,
-                    color: Colors.grey[600],
-                  ),
-                ),
-              ],
-            ),
-            
-            SizedBox(height: 16),
-            
-            // 회사명 (실시간 중복 검증)
-            KoreanValidatedInput(
-              label: "회사명",
-              isRequired: true,
-              hintText: "정확한 회사명을 입력하세요",
-              validator: _validateCompanyName,
-              asyncValidator: _checkCompanyNameDuplicate,
-              onChanged: (value) => _updateFormProgress(),
-              inputFormatters: [
-                // 특수문자 제한
-                FilteringTextInputFormatter.allow(RegExp(r'[a-zA-Z0-9가-힣\s\(\)\.㈜㈜]')),
-              ],
-            ),
-            
-            SizedBox(height: 16),
-            
-            // 사업자번호 (자동 포맷팅 + 체크섬 검증)
-            KoreanBusinessNumberField(
-              label: "사업자등록번호",
-              isRequired: true,
-              onChanged: (value) => _updateFormProgress(),
-            ),
-            
-            SizedBox(height: 16),
-            
-            // 업종 (자동완성 드롭다운)
-            KoreanIndustryDropdown(
-              label: "업종",
-              isRequired: false,
-              onChanged: (value) => _updateFormProgress(),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-}
-
-// 한국 사업자번호 전용 입력 필드
-class KoreanBusinessNumberField extends StatefulWidget {
-  final String label;
-  final bool isRequired;
-  final Function(String)? onChanged;
-  
-  @override
-  Widget build(BuildContext context) {
-    return Column(
-      crossAxisAlignment: CrossAxisAlignment.start,
-      children: [
-        // 라벨
-        RichText(
-          text: TextSpan(
-            text: label,
-            style: Theme.of(context).textTheme.bodyMedium,
-            children: isRequired ? [
-              TextSpan(
-                text: ' *',
-                style: TextStyle(color: Colors.red),
-              ),
-            ] : [],
-          ),
-        ),
-        SizedBox(height: 4),
-        
-        // 입력 필드
-        ShadInput(
-          hintText: "000-00-00000",
-          keyboardType: TextInputType.number,
-          inputFormatters: [
-            FilteringTextInputFormatter.digitsOnly,
-            _BusinessNumberFormatter(), // 자동 하이픈 삽입
-          ],
-          onChanged: _handleBusinessNumberChange,
-          decoration: InputDecoration(
-            suffixIcon: _isValidating 
-              ? SizedBox(
-                  width: 16,
-                  height: 16,
-                  child: CircularProgressIndicator(strokeWidth: 2),
-                )
-              : _isValid 
-                ? Icon(Icons.check_circle, color: Colors.green)
-                : _hasError
-                  ? Icon(Icons.error, color: Colors.red)
-                  : null,
-            errorText: _errorMessage,
-          ),
-        ),
-        
-        // 도움말
-        if (_errorMessage == null && _controller.text.isNotEmpty && !_isValid)
-          Padding(
-            padding: EdgeInsets.only(top: 4),
-            child: Text(
-              "사업자등록번호 10자리를 입력해주세요",
-              style: TextStyle(
-                color: Colors.grey[600],
-                fontSize: 12,
-              ),
-            ),
-          ),
-      ],
-    );
-  }
-  
-  void _handleBusinessNumberChange(String value) {
-    // 실시간 검증
-    if (value.replaceAll('-', '').length == 10) {
-      _validateBusinessNumber(value);
-    }
-    widget.onChanged?.call(value);
-  }
-  
-  Future<void> _validateBusinessNumber(String number) async {
-    setState(() {
-      _isValidating = true;
-      _errorMessage = null;
-    });
-    
-    try {
-      final isValid = await BusinessNumberValidator.validate(number);
-      setState(() {
-        _isValid = isValid;
-        _hasError = !isValid;
-        _errorMessage = isValid ? null : "올바르지 않은 사업자등록번호입니다";
-      });
-    } catch (e) {
-      setState(() {
-        _hasError = true;
-        _errorMessage = "사업자등록번호 검증 중 오류가 발생했습니다";
-      });
-    } finally {
-      setState(() => _isValidating = false);
-    }
-  }
-}
-
-// 사업자번호 자동 포맷팅
-class _BusinessNumberFormatter extends TextInputFormatter {
-  @override
-  TextEditingValue formatEditUpdate(
-    TextEditingValue oldValue,
-    TextEditingValue newValue,
-  ) {
-    String digits = newValue.text.replaceAll(RegExp(r'[^0-9]'), '');
-    
-    if (digits.length > 10) {
-      digits = digits.substring(0, 10);
-    }
-    
-    String formatted = '';
-    if (digits.length > 0) {
-      formatted += digits.substring(0, math.min(3, digits.length));
-      if (digits.length > 3) {
-        formatted += '-${digits.substring(3, math.min(5, digits.length))}';
-        if (digits.length > 5) {
-          formatted += '-${digits.substring(5)}';
-        }
-      }
-    }
-    
-    return TextEditingValue(
-      text: formatted,
-      selection: TextSelection.collapsed(offset: formatted.length),
-    );
-  }
-}
-```
-
-### 한국형 데이터 테이블 및 검색
-```dart
-// 한국 사용자 친화적 데이터 테이블
-class KoreanDataTable extends StatefulWidget {
-  @override
-  Widget build(BuildContext context) {
-    return Column(
-      children: [
-        // 1. 검색 및 필터 바 (한국 사용자는 검색을 자주 사용)
-        _buildSearchAndFilter(),
-        
-        // 2. 선택된 항목 액션 바
-        if (_selectedItems.isNotEmpty) _buildBatchActionBar(),
-        
-        // 3. 테이블 헤더 (정렬 가능)
-        _buildTableHeader(),
-        
-        // 4. 테이블 데이터 (가상화 스크롤링)
-        Expanded(child: _buildTableBody()),
-        
-        // 5. 페이지네이션 (한국어 라벨)
-        _buildKoreanPagination(),
-      ],
-    );
-  }
-  
-  Widget _buildSearchAndFilter() {
-    return Container(
-      padding: EdgeInsets.all(16),
-      decoration: BoxDecoration(
-        color: Colors.grey[50],
-        border: Border(bottom: BorderSide(color: Colors.grey[200]!)),
-      ),
-      child: Column(
-        children: [
-          // 통합 검색바 (한글 초성 검색 지원)
-          Row(
-            children: [
-              Expanded(
-                flex: 3,
-                child: ShadInput(
-                  hintText: "회사명, 담당자, 전화번호로 검색 (초성 검색 지원: ㅅㅁㅅ → 삼성)",
-                  prefixIcon: Icon(Icons.search),
-                  onChanged: _handleSearchInput,
-                  controller: _searchController,
-                ),
-              ),
-              SizedBox(width: 12),
-              
-              // 빠른 필터 버튼들
-              ShadButton.outline(
-                text: "파트너사만",
-                size: ShadButtonSize.sm,
-                icon: Icon(Icons.business, size: 16),
-                onPressed: () => _applyQuickFilter('partners'),
-              ),
-              SizedBox(width: 8),
-              ShadButton.outline(
-                text: "활성화만",
-                size: ShadButtonSize.sm,
-                icon: Icon(Icons.check_circle, size: 16),
-                onPressed: () => _applyQuickFilter('active'),
-              ),
-              SizedBox(width: 8),
-              
-              // 고급 필터 토글
-              ShadButton.outline(
-                text: "상세필터",
-                size: ShadButtonSize.sm,
-                icon: Icon(_showAdvancedFilter ? Icons.expand_less : Icons.expand_more, size: 16),
-                onPressed: () => setState(() => _showAdvancedFilter = !_showAdvancedFilter),
-              ),
-            ],
-          ),
-          
-          // 고급 필터 (접었다 펴기)
-          if (_showAdvancedFilter) ...[
-            SizedBox(height: 16),
-            Row(
-              children: [
-                Expanded(
-                  child: KoreanDateRangePicker(
-                    label: "등록일",
-                    startDate: _filterStartDate,
-                    endDate: _filterEndDate,
-                    onChanged: (start, end) => _updateDateFilter(start, end),
-                  ),
-                ),
-                SizedBox(width: 16),
-                Expanded(
-                  child: ShadSelect<String>(
-                    placeholder: Text("지역 선택"),
-                    options: _koreanRegions.map((region) => 
-                      ShadOption(
-                        value: region.code,
-                        child: Text(region.name),
-                      ),
-                    ).toList(),
-                    selectedOptionBuilder: (context, value) => Text(_getRegionName(value)),
-                    onChanged: (value) => _updateRegionFilter(value),
-                  ),
-                ),
-              ],
-            ),
-          ],
-          
-          // 현재 필터 상태 표시
-          if (_hasActiveFilters) ...[
-            SizedBox(height: 12),
-            Row(
-              children: [
-                Text(
-                  "현재 필터:",
-                  style: TextStyle(fontSize: 12, color: Colors.grey[600]),
-                ),
-                SizedBox(width: 8),
-                ..._activeFilters.map((filter) => 
-                  Container(
-                    margin: EdgeInsets.only(right: 8),
-                    padding: EdgeInsets.symmetric(horizontal: 8, vertical: 4),
-                    decoration: BoxDecoration(
-                      color: Colors.blue[100],
-                      borderRadius: BorderRadius.circular(12),
-                    ),
-                    child: Row(
-                      mainAxisSize: MainAxisSize.min,
-                      children: [
-                        Text(
-                          filter.label,
-                          style: TextStyle(fontSize: 11, color: Colors.blue[700]),
-                        ),
-                        SizedBox(width: 4),
-                        GestureDetector(
-                          onTap: () => _removeFilter(filter),
-                          child: Icon(Icons.close, size: 14, color: Colors.blue[700]),
-                        ),
-                      ],
-                    ),
-                  ),
-                ).toList(),
-                ShadButton.ghost(
-                  text: "전체 초기화",
-                  size: ShadButtonSize.sm,
-                  onPressed: _clearAllFilters,
-                ),
-              ],
-            ),
-          ],
-        ],
-      ),
-    );
-  }
-  
-  Widget _buildKoreanPagination() {
-    final totalPages = (_totalItems / _itemsPerPage).ceil();
-    
-    return Container(
-      padding: EdgeInsets.symmetric(vertical: 16, horizontal: 20),
-      decoration: BoxDecoration(
-        border: Border(top: BorderSide(color: Colors.grey[200]!)),
-      ),
-      child: Row(
-        children: [
-          // 총 항목 수 표시
-          Text(
-            "총 ${NumberFormat('#,###', 'ko_KR').format(_totalItems)}개",
-            style: TextStyle(fontSize: 14, color: Colors.grey[700]),
-          ),
-          SizedBox(width: 16),
-          
-          // 페이지당 표시 개수 선택
-          Text("페이지당 "),
-          ShadSelect<int>(
-            placeholder: Text("$_itemsPerPage개"),
-            options: [10, 20, 50, 100].map((count) => 
-              ShadOption(
-                value: count,
-                child: Text("${count}개"),
-              ),
-            ).toList(),
-            onChanged: (value) => _changeItemsPerPage(value),
-          ),
-          
-          Spacer(),
-          
-          // 페이지 네비게이션
-          Row(
-            children: [
-              // 첫 페이지로
-              IconButton(
-                onPressed: _currentPage > 1 ? () => _goToPage(1) : null,
-                icon: Icon(Icons.first_page),
-                tooltip: "첫 페이지",
-              ),
-              
-              // 이전 페이지
-              IconButton(
-                onPressed: _currentPage > 1 ? () => _goToPage(_currentPage - 1) : null,
-                icon: Icon(Icons.chevron_left),
-                tooltip: "이전 페이지",
-              ),
-              
-              // 페이지 번호 표시
-              Container(
-                padding: EdgeInsets.symmetric(horizontal: 16, vertical: 8),
-                child: Text(
-                  "$_currentPage / $totalPages",
-                  style: TextStyle(fontWeight: FontWeight.w500),
-                ),
-              ),
-              
-              // 다음 페이지
-              IconButton(
-                onPressed: _currentPage < totalPages ? () => _goToPage(_currentPage + 1) : null,
-                icon: Icon(Icons.chevron_right),
-                tooltip: "다음 페이지",
-              ),
-              
-              // 마지막 페이지로
-              IconButton(
-                onPressed: _currentPage < totalPages ? () => _goToPage(totalPages) : null,
-                icon: Icon(Icons.last_page),
-                tooltip: "마지막 페이지",
-              ),
-            ],
-          ),
-        ],
-      ),
-    );
-  }
-}
-```
-
-## 🚀 Execution Templates & Examples
-
-### Standard Response Format
-```markdown
-[Model: Claude Opus 4.1] → [Agent: superport-korean-ux]
-[Confidence: High]
-[Status: Active] Master!
-
-<thinking>
-한국형 ERP UX 설계: 문화적 맥락을 고려한 사용자 경험 최적화
-- 현재: 서구식 UX 패턴으로 한국 사용자에게 부적합
-- 목표: 한국 기업 업무 문화에 최적화된 직관적 인터페이스
-- 특화: 계층적 조직, 빠른 의사결정, 모바일 친화성
-</thinking>
-
-## 🎯 Task Analysis
-- **Intent**: 한국 사용자 행동 패턴에 최적화된 ERP 인터페이스 설계
-- **Complexity**: High (문화적 맥락 + 기술적 구현)
-- **Approach**: 사용자 여정 기반 단계적 UX 개선
-
-## 🚀 Solution Implementation
-1. **시간대별 맞춤 UI**: 출근-점심-퇴근 시간에 따른 적응형 인터페이스
-2. **한국형 입력 패턴**: 사업자번호 자동 포맷팅, 한글 초성 검색
-3. **업무 효율성 최적화**: 3-Click Rule, 진행률 표시, 배치 처리
-
-## 📋 Results Summary
-- **Deliverables**: 완전한 한국형 UX 패턴 및 컴포넌트
-- **Quality Assurance**: 사용자 테스트 기반 문화적 친화성 검증
-- **Next Steps**: 실제 한국 기업 환경에서 사용성 테스트
-
-## 💡 Additional Insights
-한국 사용자는 효율성과 직관성을 중시하므로, 복잡한 기능보다는
-명확하고 빠른 처리가 가능한 인터페이스를 선호합니다.
-특히 모바일 환경에서의 접근성이 매우 중요합니다.
-```
-
----
-
-**Template Version**: 2.1 (Superport Specialized)  
-**Optimization Level**: Advanced  
-**Domain Focus**: Korean Culture + ERP UX + Mobile First  
-**Last Updated**: 2025-08-23  
-**Compatibility**: Claude Opus 4.1+ | Superport ERP

AGENTS.md

@@ -0,0 +1,303 @@
+# Superport AGENTS.md — Working Guide and Current State
+
+This document is the project-wide guide for agents/developers. It describes the Flutter frontend structure, rules, run/test workflows, backend integration principles, technical debt, and improvement items.
+
+- Scope: applies to the entire repo (lib, test, docs, etc.).
+- Backend repo: `/Users/maximilian.j.sul/Documents/flutter/superport_api/` (Rust/Actix, SeaORM)
+- Agent doc precedence: `./.claude/agents/` → `~/.claude/agents/` (global)
+- Project communication/comments can be in Korean, but this file stays in English unless requested otherwise.
+
+
+## 1) System Overview
+
+- Stack: Flutter 3.x, Dart 3.x, Provider, get_it, dio, freezed, json_serializable, shadcn_ui
+- Architecture: Clean Architecture (recommended) with some legacy Service coexistence
+  - Data (API/DTO/RemoteDataSource) → Domain (Repository/UseCase) → Presentation (Controller/UI)
+  - Some features still use legacy Service-based logic
+- Data flow: Backend owns business logic; frontend focuses on DTO mapping and presentation
+- UI: shadcn_ui components as standard; tables migrating to ShadTable
+
+
+## 2) Current Status (Important)
+
+- DI: `lib/injection_container.dart` via get_it
+  - Both ApiClient (env-driven Dio) and a raw Dio existed; now standardized on ApiClient.dio
+  - Avoid raw Dio; use `ApiClient` only
+- Env/config: `.env.development`, `.env.production`, `lib/core/config/environment.dart`
+  - `main.dart` must call `Environment.initialize()` to load .env before DI
+  - Previously, baseUrl was hardcoded in DI; now use Environment + ApiClient consistently
+- UI standard: per root `CLAUDE.md`, use ShadTable; avoid Flutter base widgets for tables
+- Tests: multiple unit/integration suites under `test/`, including `test/integration/automated`
+- Docs: `docs/backend.md` (backend issues/requests), `docs/superportPRD.md` (requirements/UI)
+
+
+## 3) Directory Map (Essentials)
+
+```
+lib/
+  core/       # constants/utils/env/storage/theme/errors
+  data/       # DTOs, RemoteDataSources, Repo impl, ApiClient/Interceptors
+  domain/     # Entities, Repository interfaces, UseCases
+  screens/    # UI screens and Controllers (ChangeNotifier)
+  services/   # legacy/transitional services
+  models/     # app-side models (Freezed/Json)
+  utils/      # UI/validators (some moving to core)
+```
+
+- API endpoints: `lib/core/constants/api_endpoints.dart`
+- Env/Config: `lib/core/config/environment.dart`
+- API client: `lib/data/datasources/remote/api_client.dart`
+- DI container: `lib/injection_container.dart`
+
+
+## 4) Coding Rules (Mandatory)
+
+- Follow Clean Architecture flow:
+  - API ← Repository (impl in data) ← UseCase ← Controller ← UI
+  - DTO/field names must match backend exactly
+- DTO field mapping (critical)
+  - Example
+    ```dart
+    @JsonSerializable()
+    class EquipmentDto {
+      @JsonKey(name: 'companies_id') final int? companiesId; // NOT company_id
+      @JsonKey(name: 'models_id')    final int? modelsId;    // NOT model_id
+      const EquipmentDto({this.companiesId, this.modelsId});
+    }
+    ```
+- Error handling
+  - Domain returns `Either<Failure, T>`
+  - Show user-friendly messages in UI (see `AppConstants`)
+- State management
+  - Controllers are ChangeNotifier; inject via Provider
+  - Wrap dialogs/routes with Provider when needed
+- UI components
+  - Prefer shadcn_ui; tables must use `ShadTable`
+  - Theme/color/spacing via `ShadcnTheme` and shared constants
+- Lint/logging
+  - `analysis_options.yaml` relaxes some warnings for dev speed
+  - Use debug logging in dev; minimize in production
+
+
+## 5) API/Networking
+
+- Define endpoints in `lib/core/constants/api_endpoints.dart`
+- Use ApiClient (recommended)
+  - Env-driven Base URL/Timeout/Logging via `.env`
+  - Interceptors: Auth, Logging (dev), Response normalization, Error handling
+  - Tokens read from secure storage/AuthService
+- Avoid raw Dio
+  - For transitional code requiring `Dio`, obtain it from `sl<ApiClient>().dio`
+- 401 handling
+  - Refresh token flow implemented in `AuthInterceptor` using `AuthService.refreshToken()`
+  - On success, original request is retried; on failure, session is cleared
+
+
+## 6) Dependency Injection (DI)
+
+- Container: `lib/injection_container.dart`
+  - Order: External → Core → ApiClient/Dio → DataSource → Repository → UseCase → Controller → Services
+  - Lifecycle: Repository/UseCase as `registerLazySingleton`, Controller as `registerFactory`
+  - Example
+    ```dart
+    // 1) RemoteDataSource
+    sl.registerLazySingleton<MyFeatureRemoteDataSource>(
+      () => MyFeatureRemoteDataSourceImpl(sl<ApiClient>()),
+    );
+    // 2) Repository
+    sl.registerLazySingleton<MyFeatureRepository>(
+      () => MyFeatureRepositoryImpl(sl<MyFeatureRemoteDataSource>()),
+    );
+    // 3) UseCase
+    sl.registerLazySingleton(() => GetMyFeatureUseCase(sl<MyFeatureRepository>()));
+    // 4) Controller
+    sl.registerFactory(() => MyFeatureController(sl<GetMyFeatureUseCase>()));
+    ```
+
+
+## 7) Environment & Running
+
+- Env files: `.env.development`, `.env.production` (sample: `.env.example`)
+- Environment class: `lib/core/config/environment.dart`
+  - Use `Environment.apiBaseUrl`, `apiTimeout`, `enableLogging`
+  - Initialization at startup
+    ```dart
+    void main() async {
+      WidgetsFlutterBinding.ensureInitialized();
+      await Environment.initialize();
+      await di.init();
+      runApp(const SuperportApp());
+    }
+    ```
+- Web dev with CORS disabled: `./run_web_with_proxy.sh` (keep API URL consistent with .env)
+
+
+## 8) Backend Integration
+
+- Backend repo: `/Users/maximilian.j.sul/Documents/flutter/superport_api/`
+  - Rust (Actix), SeaORM, PostgreSQL, JWT
+  - See backend README for run/migrations/env
+- Frontend policy
+  - Backend schema/fields = source of truth
+  - Keep business logic on the backend
+- Known issues
+  - See `docs/backend.md`: `GET /companies` with `search` + `is_active` returns empty (Critical)
+  - When backend responses change, update DTO → RemoteDataSource → Repository in order
+
+
+## 9) Build/Test/Quality
+
+- Install deps: `flutter pub get`
+- Static analysis: `flutter analyze` (keep ERROR: 0)
+- Tests: `flutter test` or use scripts under `test/integration/automated`
+  - Quick API check: `./test_api_integration.sh`
+- Quality script: `./scripts/fix_code_quality.sh`
+
+
+## 10) Feature Workflow (Checklist)
+
+1. Confirm requirements/backend spec (`docs/superportPRD.md`, backend README, `docs/backend.md`)
+2. Add/verify endpoint in `core/constants/api_endpoints.dart`
+3. Define DTO with exact `JsonKey` mapping
+4. Implement RemoteDataSource (API call/error mapping)
+5. Add Repository interface/impl (delegate to DataSource)
+6. Write UseCase (single responsibility; compose in Controller)
+7. Register in DI (`injection_container.dart`)
+8. Add Controller and wire UI (Provider)
+9. Write tests (errors/edge cases)
+10. Use shadcn_ui in UI (ShadTable for tables)
+
+
+## 11) Legacy Coexistence (Transition)
+
+- Service-based calls remain for some features (e.g., parts of Company/Auth)
+- Prefer migrating to Repository/UseCase; gradually remove Service-bound UseCases
+- Avoid duplicate implementations; standardize on `ApiClient`
+
+
+## 12) Improvement Roadmap
+
+- Env/Networking
+  - Remove raw Dio from DI → standardized on `ApiClient`
+  - Ensure `Environment.initialize()` runs before DI
+  - Stabilize refresh-token retry flow
+- UI
+  - Continue ShadTable migration; follow `CLAUDE.md` checklist
+  - Use only design system constants for color/typography/spacing
+- Architecture
+  - Migrate remaining Service-based paths (Company/Auth) to Repos
+  - Remove interceptor duplication
+- Tests
+  - Strengthen real-API integration suite and wire into CI
+
+
+## 13) Frequently Used Paths
+
+- Env: `lib/core/config/environment.dart`, `.env.*`
+- Endpoints: `lib/core/constants/api_endpoints.dart`
+- API: `lib/data/datasources/remote/api_client.dart`
+- DI: `lib/injection_container.dart`
+- Controllers: `lib/screens/*/controllers/*_controller.dart`
+- Docs: `docs/backend.md`, `docs/superportPRD.md`, root `CLAUDE.md`
+- Global agent docs: `~/.claude/CLAUDE.md`, `~/.claude/agents/*.md`
+
+
+## 14) Patterns
+
+```dart
+// Controller — standard pattern with loading/error states
+class ExampleController extends ChangeNotifier {
+  final GetItemsUseCase _getItems;
+  bool _loading = false; String? _error; List<Item> _items = [];
+  ExampleController(this._getItems);
+
+  Future<void> fetch() async {
+    _loading = true; _error = null; notifyListeners();
+    final result = await _getItems();
+    result.fold(
+      (f) { _error = f.message; },
+      (data) { _items = data; },
+    );
+    _loading = false; notifyListeners();
+  }
+}
+```
+
+```dart
+// RemoteDataSource — using ApiClient
+class ItemsRemoteDataSource {
+  final ApiClient _api;
+  ItemsRemoteDataSource(this._api);
+
+  Future<List<ItemDto>> getItems() async {
+    final res = await _api.get(ApiEndpoints.items);
+    final list = (res.data['data'] as List).cast<Map<String, dynamic>>();
+    return list.map(ItemDto.fromJson).toList();
+  }
+}
+```
+
+---
+Before merging, always verify:
+- Patterns in `./.claude/agents/` → `~/.claude/agents/`
+- .env setup and API Base URL consistency
+- New features use ApiClient + Repository/UseCase
+- UI uses shadcn_ui (ShadTable for tables)
+- Tests and analysis pass (0 errors)
+
+
+## 15) Session Continuation Context (2025-09-08)
+
+This section captures the current in-progress state so another session can resume seamlessly.
+
+- Environment/DI
+  - `lib/main.dart`: calls `await Environment.initialize()` before DI init.
+  - `lib/injection_container.dart`: unified network stack to `sl<ApiClient>().dio`; removed raw `Dio` config to avoid divergence.
+
+- Auth flow (migrated to Repository)
+  - UseCases moved to `AuthRepository`:
+    - `LogoutUseCase`, `GetCurrentUserUseCase` (returns `AuthUser`), `RefreshTokenUseCase`.
+  - `AuthRepository` extended with:
+    - `getStoredAccessToken()`, `getStoredRefreshToken()`, `clearLocalSession()`.
+  - Interceptor now repository-based:
+    - `lib/data/datasources/remote/interceptors/auth_interceptor.dart` reads tokens via `AuthRepository`, handles 401 → refresh → retry → clear+navigate.
+  - Global navigation: `lib/core/navigation/app_navigator.dart` (key used in `ShadApp`), enables navigation on 401.
+
+- UI: ShadTable migration (columns preserved as-is)
+  - Equipment list: `lib/screens/equipment/equipment_list.dart` → `_buildShadTable` used. Legacy `_buildFlexibleTable` is deprecated (kept temporarily).
+  - Vendor list: `lib/screens/vendor/vendor_list_screen.dart` → `ShadTable.list`.
+  - Model list: `lib/screens/model/model_list_screen.dart` → `ShadTable.list`.
+  - User list: `lib/screens/user/user_list.dart` → `ShadTable.list` (Company column shows `-` until backend supplies it).
+  - Inventory history: `lib/screens/inventory/inventory_history_screen.dart` → `ShadTable.list`.
+  - Company list: `lib/screens/company/company_list.dart` → `ShadTable.list`.
+
+- Company UseCases (Repository-based)
+  - `GetCompanyDetailUseCase`, `CreateCompanyUseCase`, `UpdateCompanyUseCase`, `DeleteCompanyUseCase`, `ToggleCompanyStatusUseCase`, `GetCompanyHierarchyUseCase`, `UpdateParentCompanyUseCase`, `ValidateCompanyDeletionUseCase` now use `CompanyRepository`.
+
+- Analysis status
+  - `flutter analyze` shows 0 errors (non-blocking warnings remain; functionality unaffected).
+
+- Known remaining warnings (non-blocking)
+  - `lib/screens/equipment/equipment_in_form.dart`: minor validator consistency; most null-aware warnings resolved.
+  - Other general warnings may persist but do not affect functionality.
+
+- How to continue
+  - Optional cleanups (most done):
+    - Deprecated `_buildFlexibleTable` removed; ShadTable only.
+    - Unused `_showAddressDetails` and `_maxRetryCount` removed.
+    - Web health notification uses JS interop; ensure global function exists (added to `web/index.html`).
+  - User list: map Company name into the “Company” column when backend/DTO supplies it (update DTO + repository mapping).
+  - Add/extend integration tests for Auth (login → 401 → refresh → retry) and core flows.
+  - Run `flutter pub get` after dependency adjustment (`js` pinned to `^0.6.7`).
+
+- Quick verification commands
+  - Static analysis: `flutter analyze` (expect 0 errors).
+  - Sample unit test: `flutter test test/utils/currency_formatter_test.dart`.
+  - Dev run (web, with CORS disabled): `./run_web_with_proxy.sh`.
+
+- Conventions to uphold when resuming
+  - Use `ApiClient` (env-driven) for all network calls; do not instantiate raw `Dio`.
+  - Keep Clean Architecture boundaries; DTO names match backend exactly (`JsonKey(name: ...)`).
+  - UI tables use `ShadTable.list`; avoid Flutter default tables.
+  - For navigation from non-UI layers (e.g., interceptor), use `appNavigatorKey`.
+  - DI: register Repositories/UseCases as lazy singletons, Controllers as factories.

CLAUDE.md

@@ -1,15 +1,15 @@
-# Superport ERP Development Guide v3.0
+# Superport ERP Development Guide v4.0
 *Complete Flutter ERP System with Clean Architecture + CO-STAR Framework*
 
 ---
 
 ## 🎯 PROJECT STATUS
 ```yaml
-Current_State: "Phase 9.2 - Dashboard Integration Complete"
+Current_State: "색상 일부 변경 완료 - 실제 UI 통일성 작업 필요"
 API_Coverage: "100%+ (61/53 endpoints implemented)"
 System_Health: "Production Ready - Flutter Analyze ERROR: 0"
 Architecture: "Clean Architecture + shadcn_ui + 100% Backend Dependency"
-Framework: "CO-STAR Prompt Engineering Pattern Applied"
+Framework: "CO-STAR + Design System + 1920x1080 Optimized"
 ```
 
 **🏆 ACHIEVEMENT: Complete ERP system with 7 core modules + Integrated Dashboard System**
@@ -34,6 +34,33 @@ Architecture_Compliance: "100% Clean Architecture adherence"
 User_Experience: "Consistent UI/UX with shadcn_ui components"
 ```
 
+## ⚠️ CRITICAL DEVELOPMENT GUIDELINES
+
+### 작업 품질 검증 원칙
+```yaml
+실제_개선_우선: "사용자가 실제로 느낄 수 있는 개선에만 집중"
+과장_금지: "색상 변경을 '완전 재설계'로 포장 금지"
+agent_적극_활용: "복잡한 작업은 반드시 적절한 agent 사용"
+구체적_완성기준: "모호한 목표 설정 금지, 측정 가능한 기준만 사용"
+문서화_최소화: "보고서 작성보다 실제 결과물 품질 우선"
+```
+
+### UI 통일성 검증 체크리스트
+```yaml
+필수_통일_요소:
+  - 모든 화면 동일한 테이블 컴포넌트 (ShadTable.list)
+  - Typography 시스템 통일 (font-size, line-height, weight)
+  - Spacing 시스템 통일 (padding, margin, gap)
+  - BorderRadius 값 통일 (ShadcnTheme.radius*)
+  - 레이아웃 구조 표준화 (BaseListScreen template)
+  - 색상 사용 일관성 (ShadcnTheme.* 상수만 사용)
+
+검증_방법:
+  - 매 작업 후 "사용자가 이 차이를 실제로 느낄까?" 자문
+  - Agent를 통한 화면별 차이점 객관적 분석
+  - 실제 화면 캡처 비교 (가능시)
+```
+
 ### Style (S) - Code & Communication Style
 ```yaml
 Code_Style: "Declarative, functional, immutable"
@@ -73,7 +100,7 @@ Error_States: "Comprehensive error handling with recovery"
 ### Rule 1: UI Components (ABSOLUTE)
 ```dart
 // ✅ REQUIRED - shadcn_ui only
-StandardDataTable<T>(), ShadButton.outline(), ShadSelect<String>()
+ShadTable.list(), ShadButton.outline(), ShadSelect<String>()
 
 // ❌ FORBIDDEN - Flutter base widgets
 DataTable(), ElevatedButton(), DropdownButton()
@@ -213,29 +240,23 @@ CreateEquipmentHistoryRequest(
 
 ---
 
-## 🎯 NEXT PHASE
+## 🎯 CURRENT PHASE
 
-### ✅ Phase 9.4: 유지보수 대시보드 리스트 테이블 형태 전환 (COMPLETED)
+### 🔧 실제 UI 통일성 작업 (URGENT)
-**Status**: 2025-09-04 완료 - 카드 형태 → 행렬 테이블 형태 완전 전환 성공
+**현재 상태**: 색상만 일부 변경됨 - 실제 화면별 구조/크기/모양 모두 다름
 
-#### **🎯 달성된 성과**
+#### **실제 문제점**
-- [x] 카드 형태 완전 제거, StandardDataTable 테이블 형태로 전환 ✅
+- 각 화면마다 테이블 구조 다름 (ShadTable vs 수동 구성)
-- [x] 실제 모델명, 시리얼번호, 고객사명 표시 ✅
+- 글자 크기, 패딩, 여백 값 제각각
-- [x] "조회중..." 상태 유지하되 실제 데이터 로딩 시스템 검증 완료 ✅  
+- 테두리 둥글기(BorderRadius) 불일치  
-- [x] 워런티 타입을 방문(O)/원격(R) + 기존 타입 모두 지원 ✅
+- 레이아웃 구조 표준화 미완료
-- [x] 다른 화면들과 동일한 리스트 UI 일관성 100% 달성 ✅
-- [x] Flutter Analyze ERROR: 0 유지 ✅
 
-#### **🏆 핵심 개선사항**
+#### **해야 할 실제 작업**
-- **정보 밀도 5배 증가**: 카드 vs 테이블 비교
+- [ ] 모든 화면 ShadTable.list()로 통일
-- **운영 효율성 극대화**: 한 화면 스캔으로 전체 상황 파악
+- [ ] Typography 시스템 완전 통일
-- **UI 일관성 완성**: StandardDataTable 기반 통합 디자인
+- [ ] Spacing/Padding 값 표준화
-- **접근성 향상**: 클릭 가능한 장비명으로 상세보기 연결
+- [ ] BorderRadius 값 통일
-
+- [ ] 레이아웃 템플릿 표준화
----
-
-### Phase 8.3: Form Standardization (POSTPONED)
-**Status**: 유지보수 대시보드 문제 해결 후 진행
 
 ---
 
@@ -281,118 +302,167 @@ showDialog(
 
 ---
 
-## 📅 UPDATE LOG
+## 🔧 ShadTable 전환 작업 가이드
-- **2025-09-04**: Phase 9.4 - 유지보수 대시보드 리스트 테이블 형태 전환 완료 (Table Format Conversion Complete)
+
-  - **핵심 문제 해결**: 카드 형태 UI를 테이블 형태로 완전 전환하여 실용성 100% 확보
+### 🎯 핵심 목표
-  - **UI 형태 완전 전환**:
+
-    * 기존 `_buildMaintenanceListTile` (카드 형태) 완전 제거
+- **모든 화면을 shadcn_ui의 공식 ShadTable 컴포넌트로 통일**
-    * StandardDataTable 기반 테이블 형태로 교체
+- **커스텀 StandardDataTable 사용 금지** (유지보수 어려움)
-    * 7개 컬럼 구현: 장비명, 시리얼번호, 고객사, 만료일, 타입, 상태, 주기
+- **수동 Row/Column 구성 완전 제거**
-  - **정보 표시 개선**:
+
-    * 장비명: 실제 ModelName 표시 (기존: "Equipment #127")
+### 📋 화면별 전환 태스크
-    * 시리얼번호: 실제 SerialNumber 표시 
+
-    * 고객사명: 실제 CompanyName 표시
+#### **Phase 1: Equipment List (파일럿)**
-    * 만료일: 색상 구분 (정상/경고/만료)
+**파일**: `lib/screens/equipment/equipment_list.dart`
-  - **워런티 타입 시스템 완성**:
+**현재**: `_buildFlexibleTable()` 수동 구성
-    * O(방문)/R(원격) 타입 지원
+**목표**: `ShadTable.list()` 전환
-    * WARRANTY(무상보증)/CONTRACT(유상계약)/INSPECTION(점검) 호환
+**검증**:
-    * 타입별 색상 배지 적용
+- [ ] 체크박스 선택 기능 정상 동작
-  - **사용자 경험 혁신**:
+- [ ] 페이지네이션 연동  
-    * 정보 밀도 5배 증가 (테이블 vs 카드)
+- [ ] 출고/입고 버튼 이벤트
-    * 한 화면 스캔으로 전체 상황 파악 가능
+- [ ] 호버/클릭 이벤트
-    * 클릭 가능한 장비명으로 상세보기 접근성 향상
+
-  - **기술적 성과**:
+#### **Phase 2: 단순 화면 전환**
-    * Flutter Analyze ERROR: 0 유지
+1. **Vendor Management** (`vendor_list_screen.dart`)
-    * 100% shadcn_ui 컴플라이언스 
+2. **Model Management** (`model_list_screen.dart`)
-    * Clean Architecture 완벽 준수
+
-    * StandardDataTable 컴포넌트 재사용성 확보
+각 화면:
-  - **결과**: 운영 효율성 극대화, 다른 화면과 UI 일관성 100% 달성
+- [ ] 헤더 구조를 `ShadTableCell.header`로 변환
-- **2025-09-04**: Phase 9.3 - 유지보수 대시보드 리스트 정보 개선 완료 (Maintenance List Information Enhancement)
+- [ ] 데이터 행을 `ShadTableCell`로 변환  
-  - **핵심 문제 해결**: 기존 "Equipment History #127" 형태의 의미 없는 표시 → 실제 장비/고객사 정보로 대체
+- [ ] 컬럼 너비를 `columnSpanExtent`로 설정
-  - **리스트 UI 완전 재설계**: 
+- [ ] 기존 이벤트 핸들러 `onRowTap`으로 연결
-    * 장비명 + 시리얼번호 표시 (ModelName + SerialNumber)
+
-    * 고객사명 표시 (CompanyName) 
+#### **Phase 3: 복잡 화면 전환**
-    * 워런티 타입별 색상/아이콘 구분 (무상보증/유상계약/점검)
+1. **User List** (`user_list.dart`)
-    * 만료일까지 남은 일수 + 만료 상태 시각화
+2. **Company List** (`company_list.dart`)
-    * 유지보수 주기 정보 추가
+3. **Inventory History** (`inventory_history_screen.dart`)
-  - **백엔드 데이터 활용 최적화**:
+
-    * MaintenanceController에 EquipmentHistoryRepository 의존성 추가
+**주의사항**:
-    * equipment_history_id → EquipmentHistoryDto → EquipmentDto 관계 데이터 조회
+- 권한별 배지 컴포넌트 보존
-    * 성능 최적화: Map<int, EquipmentHistoryDto> 캐시 구현
+- 필터/검색 기능 영향 최소화
-    * 배치 로딩: 최대 5개씩 동시 조회로 API 부하 방지
+- 상태 관리 로직 변경 금지
-  - **사용자 경험 대폭 향상**:
+
-    * 정보 파악 시간: 30초 → 3초 (90% 단축)
+### ⚠️ 사이드 이펙트 방지 전략
-    * 한 화면에서 모든 핵심 정보 확인 가능
+
-    * 만료 임박/지연 상태 색상으로 즉시 식별
+#### **1. 컨트롤러 격리**
-  - **기술적 성과**:
+- 테이블 UI 변경만 진행
-    * Flutter Analyze ERROR: 0 유지
+- Controller/Repository/UseCase 수정 금지
-    * 100% shadcn_ui 컴플라이언스
+- 상태 관리 로직 유지
-    * Clean Architecture 완벽 준수
+
-    * 의존성 주입(DI) 정상 적용
+#### **2. 점진적 전환**
-  - **결과**: 실용성 100% 달성, 운영진 요구사항 완전 충족
+```dart
-- **2025-09-04**: Phase 9.2 - 유지보수 대시보드 화면 통합 완료 (Dashboard Integration Complete)
+// Step 1: 기존 구조 백업
-  - **통합 대시보드 화면 완성**: maintenance_alert_dashboard.dart 완전 재작성 (574줄 → 640줄)
+Widget _buildFlexibleTable_backup() { ... }
-  - **StatusSummaryCards 완전 통합**: Phase 9.1 컴포넌트 실제 화면에 적용
+
-  - **카드 클릭 필터링 구현**: 60일/30일/7일/만료 카드 → 자동 필터링된 목록 표시
+// Step 2: 새 ShadTable 병렬 구현  
-  - **반응형 레이아웃 완성**: 데스크톱(가로 4개) vs 태블릿/모바일(2x2 그리드)
+Widget _buildShadTable() {
-  - **핵심 기술 성과**:
+  return ShadTable.list(...);
-    * MaintenanceDashboardController Provider 통합 (main.dart)
+}
-    * 100% shadcn_ui 컴플라이언스 (Flutter 기본 위젯 완전 제거)
+
-    * Clean Architecture 완벽 준수 (Consumer2 패턴)
+// Step 3: 조건부 렌더링으로 테스트
-    * 실시간 데이터 바인딩 및 Pull-to-Refresh 지원
+bool useShadTable = true; // 플래그로 전환
-    * 통합 필터 시스템 (전체/7일내/30일내/60일내/만료됨)
+```
-  - **사용자 경험 향상**: 통계 카드 → 원클릭 필터링 → 상세보기 (30% UX 향상)
+
-  - **결과**: Flutter Analyze ERROR: 0 달성, 프로덕션 대시보드 완성
+#### **3. 데이터 바인딩 보존**
-  - **시스템 완성도**: 98% → 100% (모든 핵심 모듈 통합 완료)
+- 기존 `controller.equipments` 그대로 사용
-- **2025-09-04**: Phase 9.1 - 유지보수 대시보드 시스템 재설계 완료 (Maintenance Dashboard Redesign)
+- `map()` 함수로 ShadTableCell 변환만 수행
-  - **사용자 요구사항 100% 충족**: 60일내, 30일내, 7일내, 만료된 계약 대시보드
+- 이벤트 핸들러 1:1 매핑
-  - **Clean Architecture 완벽 준수**: DTO → Repository → UseCase → Controller → UI 패턴
+
-  - **100% shadcn_ui 컴플라이언스**: Flutter base widgets 완전 배제
+#### **4. 스타일 일관성**
-  - **핵심 구현사항**:
+- ShadcnTheme 상수만 사용
-    * MaintenanceStatsDto: 대시보드 통계 모델 (60/30/7일 만료, 계약타입별 통계)
+- 커스텀 색상 금지
-    * MaintenanceStatsRepository: 기존 maintenance API 활용하여 통계 계산
+- padding/margin 값 표준화
-    * GetMaintenanceStatsUseCase: 비즈니스 로직 및 데이터 검증
+
-    * MaintenanceDashboardController: 상태 관리 및 UI 상호작용
+### 🔍 검증 체크리스트
-    * StatusSummaryCards: shadcn_ui 기반 4-카드 대시보드 컴포넌트
+
-    * 의존성 주입: injection_container.dart에 완전 통합
+각 화면 전환 후 필수 확인:
-  - **결과**: Flutter Analyze ERROR: 0 유지, 프로덕션 준비 완료
+- [ ] 데이터 표시 정확성
-  - **다음 단계**: 실제 대시보드 화면 통합 및 라우팅 완성 예정
+- [ ] 체크박스 선택/해제
-- **2025-09-04**: Phase 8.3.4 - 출고 처리 JSON 직렬화 오류 해결 (Critical Bug Fix)
+- [ ] 정렬 기능 (있는 경우)
-  - 문제 1: 백엔드 400 Bad Request + JSON deserialize error (타임존 정보 누락)
+- [ ] 필터링 동작
-    * 기존: `"2025-09-04T17:40:44.061"` → 수정: `"2025-09-04T17:40:44.061Z"`
+- [ ] 페이지네이션
-    * 해결: createStockIn/createStockOut에서 DateTime.toUtc() 변환 적용
+- [ ] 행 클릭 이벤트
-  - 문제 2: ResponseInterceptor가 equipment-history 응답을 래핑하여 DTO 파싱 실패
+- [ ] 편집/삭제 버튼
-    * 원인: `{id: 235, equipments_id: 108, ...}` → `{success: true, data: {...}}`로 변환
+- [ ] 반응형 레이아웃
-    * 해결: equipment-history 응답 패턴 감지하여 래핑 방지 로직 추가
+- [ ] Flutter Analyze 에러 0개
-  - 핵심 변경사항:
+
-    * EquipmentHistoryRepository: UTC 날짜 변환 + String 응답 타입 검증
+### 📚 ShadTable 사용 패턴
-    * ResponseInterceptor: transaction_type 필드 감지하여 변형 방지
+
-  - 결과: 출고/입고 프로세스 100% 안정성 확보, 백엔드 호환성 완성
+#### **기본 구조**
-- **2025-09-04**: Phase 8.3.3 - 장비 입고시 입고 이력 누락 문제 해결 (Critical Bug Fix)
+```dart
-  - 문제 원인: EquipmentHistoryController를 통한 간접 호출에서 API 실패시 에러 처리 불완전
+ShadTable.list(
-  - 해결 방안: EquipmentHistoryRepository 직접 호출로 출고 시스템과 동일한 패턴 적용
+  header: [
-  - 핵심 변경사항:
+    ShadTableCell.header(child: Text('컬럼1')),
-    * EquipmentInFormController에 EquipmentHistoryRepository 의존성 추가
+    ShadTableCell.header(child: Text('컬럼2')),
-    * createStockIn() 직접 호출로 입고 이력 생성 로직 개선
+  ],
-    * 실패시 전체 프로세스 실패 처리 (트랜잭션 무결성 확보)
+  children: items.map((item) => [
-  - 결과: 입고 이력 100% 생성 보장, 출고/입고 시스템 패턴 통일 완성
+    ShadTableCell(child: Text(item.field1)),
-- **2025-09-03**: Phase 8.3.2 - 장비 수정 화면 창고 선택 필드를 읽기 전용으로 변경
+    ShadTableCell(child: Text(item.field2)),
-  - 백엔드 아키텍처 분석 결과: Equipment 테이블에 warehouses_id 컬럼 없음
+  ]).toList(),
-  - 창고 정보는 equipment_history 테이블에서 관리하는 구조 확인
+  columnSpanExtent: (index) {
-  - 수정 화면에서 창고 필드를 읽기 전용으로 변경하여 사용자 혼동 방지
+    switch(index) {
-  - 창고 변경은 별도 "장비 이동" 기능으로 처리해야 함을 명확화
+      case 0: return FixedTableSpanExtent(80);
-- **2025-09-03**: Phase 8.3.1 - 장비 수정 화면 창고 선택 데이터 바인딩 수정
+      case 1: return FlexTableSpanExtent(2);
-  - 수정 화면에서 기존 창고 정보가 사라지고 첫 번째 창고가 표시되던 버그 수정
+      default: return null;
-  - `EquipmentInFormController`에서 `selectedWarehouseId = equipment.warehousesId` 설정 추가
+    }
-  - 백엔드-프론트엔드 DTO 매핑 검증 완료 (정상)
+  },
-- **2025-09-02 v3.0**: Phase 8.3 - Outbound system redesigned with CO-STAR framework
+  onRowTap: (index) => _handleRowClick(items[index]),
-  - Implemented dialog-based outbound processing
+)
-  - Integrated equipment_history API for transaction management
+```
-  - Applied CO-STAR prompt engineering framework
+
-  - Zero backend modifications required
+#### **체크박스 포함**
-- **2025-09-02**: Phase 8.2 Complete - StandardDropdown system + 95% forms
+```dart  
-- **2025-09-01**: Phase 1-7 Complete - Full ERP system + 100%+ API coverage
+ShadTable.list(
-- **Next**: Phase 8.4 - Complete UI/UX standardization across all modules
+  header: [
+    ShadTableCell.header(
+      child: ShadCheckbox(
+        value: _isAllSelected,
+        onChanged: _onSelectAll,
+      )
+    ),
+    ShadTableCell.header(child: Text('데이터')),
+  ],
+  children: items.map((item) => [
+    ShadTableCell(
+      child: ShadCheckbox(
+        value: _selectedItems.contains(item.id),
+        onChanged: (v) => _onItemSelect(item.id, v),
+      )
+    ),
+    ShadTableCell(child: Text(item.data)),
+  ]).toList(),
+)
+```
+
+### 🚨 금지 사항
+- **StandardDataTable 사용** ❌
+- **수동 Row/Column 구성** ❌  
+- **Container + ListView.builder 패턴** ❌
+- **커스텀 테이블 컴포넌트 생성** ❌
+- **비즈니스 로직 수정** ❌
+
+### ✅ 완료 기준
+- 모든 화면이 ShadTable 사용
+- Flutter Analyze ERROR: 0
+- 기능 regression 없음
+- 시각적 일관성 100%
 
 ---
-*Document updated with CO-STAR framework and 2025 prompt engineering best practices*
+
+## 🎯 작업 시작 방법
+
+### Agent 사용 필수
+```yaml
+복잡한_분석: general-purpose agent 사용
+UI_비교: agent를 통한 화면별 차이점 분석
+검증: agent를 통한 완성도 객관적 평가
+```
+
+### 검증 기준
+- "사용자가 실제로 이 차이를 느낄까?"
+- Equipment List와 시각적으로 동일한가?
+- Typography/Spacing이 정확히 일치하는가?
+
+---
+
+*Document updated: 2025-09-05 - 실제 UI 통일성 작업 계획 수립*

lib/core/navigation/app_navigator.dart

@@ -0,0 +1,18 @@
+import 'package:flutter/widgets.dart';
+
+/// 글로벌 네비게이터 키
+///
+/// - 어디서든(인터셉터 등 BuildContext 없는 곳) 네비게이션이 가능하도록 제공한다.
+/// - 401 등 인증 만료 시 로그인 화면으로의 이동에 사용한다.
+final GlobalKey<NavigatorState> appNavigatorKey = GlobalKey<NavigatorState>();
+
+/// 로그인 화면으로 이동(스택 제거)
+///
+/// - 모든 기존 라우트를 제거하고 '/login'으로 이동한다.
+/// - 네비게이터가 아직 준비되지 않았거나 null일 수 있어 null 세이프 처리한다.
+void navigateToLoginClearingStack() {
+  final navigator = appNavigatorKey.currentState;
+  if (navigator == null) return;
+  navigator.pushNamedAndRemoveUntil('/login', (route) => false);
+}
+

lib/data/datasources/remote/interceptors/auth_interceptor.dart

@@ -1,24 +1,28 @@
 import 'package:dio/dio.dart';
 import 'package:get_it/get_it.dart';
 import 'package:flutter/foundation.dart';
-import '../../../../core/constants/api_endpoints.dart';
+import 'package:superport/core/constants/api_endpoints.dart';
-import '../../../../services/auth_service.dart';
+import 'package:superport/domain/repositories/auth_repository.dart';
-import '../../../../core/config/environment.dart';
+import 'package:superport/data/models/auth/refresh_token_request.dart';
+import 'package:superport/core/config/environment.dart';
+import 'package:superport/core/navigation/app_navigator.dart';
 
 /// 인증 인터셉터
 class AuthInterceptor extends Interceptor {
-  AuthService? _authService;
+  AuthRepository? _authRepository;
   final Dio dio;
   
-  AuthInterceptor(this.dio);
+  AuthInterceptor(this.dio, {AuthRepository? overrideAuthRepository}) {
+    _authRepository = overrideAuthRepository;
+  }
   
-  AuthService? get authService {
+  AuthRepository? get authRepository {
     try {
-      _authService ??= GetIt.instance<AuthService>();
+      _authRepository ??= GetIt.instance<AuthRepository>();
-      return _authService;
+      return _authRepository;
     } catch (e) {
       if (kDebugMode) {
-        debugPrint('Failed to get AuthService in AuthInterceptor: $e');
+        debugPrint('Failed to get AuthRepository in AuthInterceptor: $e');
       }
       return null;
     }
@@ -43,21 +47,22 @@ class AuthInterceptor extends Interceptor {
     }
     
     // 저장된 액세스 토큰 가져오기
-    final service = authService;
+    final repo = authRepository;
     if (Environment.enableLogging && kDebugMode) {
-      debugPrint('[AuthInterceptor] AuthService available: ${service != null}');
+      debugPrint('[AuthInterceptor] AuthRepository available: ${repo != null}');
     }
     
-    if (service != null) {
+    if (repo != null) {
-      final accessToken = await service.getAccessToken();
+      final tokenEither = await repo.getStoredAccessToken();
+      final accessToken = tokenEither.fold((_) => null, (t) => t);
       if (Environment.enableLogging && kDebugMode) {
-        debugPrint('[AuthInterceptor] Access token retrieved: ${accessToken != null ? 'Yes (${accessToken.substring(0, 10)}...)' : 'No'}');
+        debugPrint('[AuthInterceptor] Access token retrieved: ${accessToken != null ? 'Yes' : 'No'}');
       }
       
       if (accessToken != null) {
         options.headers['Authorization'] = 'Bearer $accessToken';
         if (Environment.enableLogging && kDebugMode) {
-          debugPrint('[AuthInterceptor] Authorization header set: Bearer ${accessToken.substring(0, 10)}...');
+          debugPrint('[AuthInterceptor] Authorization header set');
         }
       } else {
         if (Environment.enableLogging && kDebugMode) {
@@ -66,7 +71,7 @@ class AuthInterceptor extends Interceptor {
       }
     } else {
       if (Environment.enableLogging && kDebugMode) {
-        debugPrint('[AuthInterceptor] ERROR: AuthService not available from GetIt');
+        debugPrint('[AuthInterceptor] ERROR: AuthRepository not available from GetIt');
       }
     }
     
@@ -96,33 +101,25 @@ class AuthInterceptor extends Interceptor {
         return;
       }
       
-      final service = authService;
+      final repo = authRepository;
-      if (service != null) {
+      if (repo != null) {
         if (Environment.enableLogging && kDebugMode) {
           debugPrint('[AuthInterceptor] Attempting token refresh...');
         }
         // 토큰 갱신 시도
-        final refreshResult = await service.refreshToken();
+        final refreshTokenEither = await repo.getStoredRefreshToken();
+        final refreshToken = refreshTokenEither.fold((_) => null, (t) => t);
+        final refreshResult = refreshToken == null
+            ? null
+            : await repo.refreshToken(RefreshTokenRequest(refreshToken: refreshToken));
         
-        final refreshSuccess = refreshResult.fold(
+        final refreshSuccess = refreshResult != null && refreshResult.isRight();
-          (failure) {
-            if (Environment.enableLogging && kDebugMode) {
-              debugPrint('[AuthInterceptor] Token refresh failed: ${failure.message}');
-            }
-            return false;
-          },
-          (tokenResponse) {
-            if (Environment.enableLogging && kDebugMode) {
-              debugPrint('[AuthInterceptor] Token refresh successful');
-            }
-            return true;
-          },
-        );
         
         if (refreshSuccess) {
           // 새로운 토큰으로 원래 요청 재시도
           try {
-            final newAccessToken = await service.getAccessToken();
+            final newAccessTokenEither = await repo.getStoredAccessToken();
+            final newAccessToken = newAccessTokenEither.fold((_) => null, (t) => t);
             
             if (newAccessToken != null) {
               if (Environment.enableLogging && kDebugMode) {
@@ -149,8 +146,9 @@ class AuthInterceptor extends Interceptor {
         if (Environment.enableLogging && kDebugMode) {
           debugPrint('[AuthInterceptor] Clearing session due to auth failure');
         }
-        await service.clearSession();
+        await repo.clearLocalSession();
-        // TODO: Navigate to login screen
+        // 로그인 화면으로 이동 (모든 스택 제거)
+        navigateToLoginClearingStack();
       }
     }
     

lib/data/models/user/user_dto.dart

@@ -29,6 +29,7 @@ class UserDto with _$UserDto {
       name: name,
       email: email,
       phone: phone,
+      companyName: company?.name,
     );
   }
 }
@@ -120,4 +121,3 @@ class CheckUsernameResponse with _$CheckUsernameResponse {
   factory CheckUsernameResponse.fromJson(Map<String, dynamic> json) =>
       _$CheckUsernameResponseFromJson(json);
 }
-

lib/data/repositories/auth_repository_impl.dart

@@ -181,6 +181,42 @@ class AuthRepositoryImpl implements AuthRepository {
     }
   }
 
+  @override
+  Future<Either<Failure, String?>> getStoredRefreshToken() async {
+    try {
+      final token = await _getRefreshToken();
+      return Right(token);
+    } catch (e) {
+      return Left(ServerFailure(
+        message: '리프레시 토큰 조회 중 오류가 발생했습니다: ${e.toString()}',
+      ));
+    }
+  }
+
+  @override
+  Future<Either<Failure, String?>> getStoredAccessToken() async {
+    try {
+      final token = await _getAccessToken();
+      return Right(token);
+    } catch (e) {
+      return Left(ServerFailure(
+        message: '액세스 토큰 조회 중 오류가 발생했습니다: ${e.toString()}',
+      ));
+    }
+  }
+
+  @override
+  Future<Either<Failure, void>> clearLocalSession() async {
+    try {
+      await _clearLocalData();
+      return const Right(null);
+    } catch (e) {
+      return Left(ServerFailure(
+        message: '로컬 세션 정리 중 오류가 발생했습니다: ${e.toString()}',
+      ));
+    }
+  }
+
   // Private 헬퍼 메서드들
   
   /// 액세스 토큰과 리프레시 토큰을 로컬에 저장

lib/domain/repositories/auth_repository.dart

@@ -48,4 +48,15 @@ abstract class AuthRepository {
   /// 현재 저장된 토큰이 유효한지 서버에서 검증
   /// Returns: 세션 유효성 여부
   Future<Either<Failure, bool>> validateSession();
+
+  /// 로컬 저장소에 보관된 리프레시 토큰 조회
+  /// Returns: 저장된 리프레시 토큰(없으면 null)
+  Future<Either<Failure, String?>> getStoredRefreshToken();
+
+  /// 로컬 저장소에 보관된 액세스 토큰 조회
+  /// Returns: 저장된 액세스 토큰(없으면 null)
+  Future<Either<Failure, String?>> getStoredAccessToken();
+
+  /// 로컬 세션 정리(토큰/사용자 정보 삭제)
+  Future<Either<Failure, void>> clearLocalSession();
 }

lib/domain/usecases/auth/get_current_user_usecase.dart

@@ -1,34 +1,17 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/auth_service.dart';
+import '../../repositories/auth_repository.dart';
-import '../../../data/models/user/user_dto.dart';
+import '../../../data/models/auth/auth_user.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
 
-/// 현재 로그인한 사용자 정보 조회 UseCase
+/// 현재 로그인한 사용자 정보 조회 UseCase (AuthRepository 기반)
-class GetCurrentUserUseCase extends UseCase<UserDto?, NoParams> {
+class GetCurrentUserUseCase extends UseCase<AuthUser, NoParams> {
-  final AuthService _authService;
+  final AuthRepository _authRepository;
 
-  GetCurrentUserUseCase(this._authService);
+  GetCurrentUserUseCase(this._authRepository);
 
   @override
-  Future<Either<Failure, UserDto?>> call(NoParams params) async {
+  Future<Either<Failure, AuthUser>> call(NoParams params) async {
-    try {
+    return await _authRepository.getCurrentUser();
-      final user = await _authService.getCurrentUser();
-      
-      if (user == null) {
-        return Left(AuthFailure(
-          message: '로그인이 필요합니다.',
-          code: 'NOT_AUTHENTICATED',
-        ));
-      }
-      
-      // AuthUser를 UserDto로 변환 (임시로 null 반환)
-      return const Right(null);
-    } catch (e) {
-      return Left(UnknownFailure(
-        message: '사용자 정보를 가져오는 중 오류가 발생했습니다.',
-        originalError: e,
-      ));
-    }
   }
 }

lib/domain/usecases/auth/logout_usecase.dart

@@ -1,17 +1,18 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/auth_service.dart';
+import '../../repositories/auth_repository.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
 
 /// 로그아웃 UseCase
 /// 사용자 로그아웃 처리 및 토큰 삭제
 class LogoutUseCase extends UseCase<void, NoParams> {
-  final AuthService _authService;
+  // AuthRepository 기반으로 마이그레이션
+  final AuthRepository _authRepository;
 
-  LogoutUseCase(this._authService);
+  LogoutUseCase(this._authRepository);
 
   @override
   Future<Either<Failure, void>> call(NoParams params) async {
-    return await _authService.logout();
+    return await _authRepository.logout();
   }
 }

lib/domain/usecases/auth/refresh_token_usecase.dart

@@ -1,56 +1,33 @@
 import 'package:dartz/dartz.dart';
-import 'package:dio/dio.dart';
-import '../../../services/auth_service.dart';
 import '../../../data/models/auth/token_response.dart';
+import '../../../data/models/auth/refresh_token_request.dart';
+import '../../repositories/auth_repository.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
 
 /// 토큰 갱신 UseCase
 /// JWT 토큰을 갱신하여 세션 유지
 class RefreshTokenUseCase extends UseCase<TokenResponse, NoParams> {
-  final AuthService _authService;
+  // AuthRepository 기반으로 마이그레이션
+  final AuthRepository _authRepository;
 
-  RefreshTokenUseCase(this._authService);
+  RefreshTokenUseCase(this._authRepository);
 
   @override
   Future<Either<Failure, TokenResponse>> call(NoParams params) async {
-    try {
+    final stored = await _authRepository.getStoredRefreshToken();
-      final refreshToken = await _authService.getRefreshToken();
+    return await stored.fold(
-      
+      (failure) => Left(failure),
-      if (refreshToken == null) {
+      (token) async {
+        if (token == null || token.isEmpty) {
           return Left(AuthFailure(
             message: '갱신 토큰이 없습니다. 다시 로그인해주세요.',
             code: 'NO_REFRESH_TOKEN',
           ));
         }
-
+        final request = RefreshTokenRequest(refreshToken: token);
-      return await _authService.refreshToken();
+        return await _authRepository.refreshToken(request);
-    } on DioException catch (e) {
+      },
-      if (e.response?.statusCode == 401) {
+    );
-        return Left(AuthFailure(
-          message: '세션이 만료되었습니다. 다시 로그인해주세요.',
-          code: 'SESSION_EXPIRED',
-          originalError: e,
-        ));
-      } else if (e.type == DioExceptionType.connectionTimeout ||
-                 e.type == DioExceptionType.receiveTimeout) {
-        return Left(NetworkFailure(
-          message: '네트워크 연결 시간이 초과되었습니다.',
-          code: 'TIMEOUT',
-          originalError: e,
-        ));
-      } else {
-        return Left(ServerFailure(
-          message: '서버 오류가 발생했습니다.',
-          code: e.response?.statusCode?.toString(),
-          originalError: e,
-        ));
-      }
-    } catch (e) {
-      return Left(UnknownFailure(
-        message: '토큰 갱신 중 오류가 발생했습니다.',
-        originalError: e,
-      ));
-    }
   }
 }

lib/domain/usecases/company/create_company_usecase.dart

@@ -1,5 +1,5 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../../../models/company_model.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
@@ -15,9 +15,10 @@ class CreateCompanyParams {
 
 /// 회사 생성 UseCase
 class CreateCompanyUseCase extends UseCase<Company, CreateCompanyParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  CreateCompanyUseCase(this._companyService);
+  CreateCompanyUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, Company>> call(CreateCompanyParams params) async {
@@ -28,8 +29,8 @@ class CreateCompanyUseCase extends UseCase<Company, CreateCompanyParams> {
         return Left(validationResult);
       }
 
-      final company = await _companyService.createCompany(params.company);
+      final result = await _companyRepository.createCompany(params.company);
-      return Right(company);
+      return result;
     } on ServerFailure catch (e) {
       return Left(ServerFailure(
         message: e.message,

lib/domain/usecases/company/delete_company_usecase.dart

@@ -1,5 +1,5 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
 
@@ -14,15 +14,16 @@ class DeleteCompanyParams {
 
 /// 회사 삭제 UseCase
 class DeleteCompanyUseCase extends UseCase<void, DeleteCompanyParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  DeleteCompanyUseCase(this._companyService);
+  DeleteCompanyUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, void>> call(DeleteCompanyParams params) async {
     try {
-      await _companyService.deleteCompany(params.id);
+      final result = await _companyRepository.deleteCompany(params.id);
-      return const Right(null);
+      return result;
     } on ServerFailure catch (e) {
       if (e.message.contains('associated')) {
         return Left(ValidationFailure(

lib/domain/usecases/company/get_company_detail_usecase.dart

@@ -1,5 +1,5 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../../../models/company_model.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
@@ -17,22 +17,17 @@ class GetCompanyDetailParams {
 
 /// 회사 상세 조회 UseCase
 class GetCompanyDetailUseCase extends UseCase<Company, GetCompanyDetailParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  GetCompanyDetailUseCase(this._companyService);
+  GetCompanyDetailUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, Company>> call(GetCompanyDetailParams params) async {
     try {
-      final Company company;
+      // 레포지토리에서 상세 조회(자식 포함 형태로 매핑됨)
-      
+      final result = await _companyRepository.getCompanyById(params.id);
-      if (params.includeBranches) {
+      return result;
-        company = await _companyService.getCompanyWithChildren(params.id);
-      } else {
-        company = await _companyService.getCompanyDetail(params.id);
-      }
-      
-      return Right(company);
     } on ServerFailure catch (e) {
       if (e.message.contains('not found')) {
         return Left(ValidationFailure(

lib/domain/usecases/company/get_company_hierarchy_usecase.dart

@@ -2,7 +2,7 @@ import 'package:dartz/dartz.dart';
 import '../../../core/errors/failures.dart';
 import '../../../domain/entities/company_hierarchy.dart';
 import '../../../models/company_model.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../base_usecase.dart';
 
 /// 회사 계층 구조 조회 파라미터
@@ -16,22 +16,23 @@ class GetCompanyHierarchyParams {
 
 /// 회사 계층 구조 조회 UseCase
 class GetCompanyHierarchyUseCase extends UseCase<CompanyHierarchy, GetCompanyHierarchyParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  GetCompanyHierarchyUseCase(this._companyService);
+  GetCompanyHierarchyUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, CompanyHierarchy>> call(GetCompanyHierarchyParams params) async {
     try {
-      // 모든 회사 조회
+      // 레포지토리에서 전체 회사(계층 구성용) 조회
-      final response = await _companyService.getCompanies(
+      final companiesEither = await _companyRepository.getCompanyHierarchy(
-        page: 1,
-        perPage: 1000,
         includeInactive: params.includeInactive,
       );
       
-      // 계층 구조로 변환
+      final hierarchy = companiesEither.fold(
-      final hierarchy = _buildHierarchy(response.items);
+        (failure) => throw failure,
+        (companies) => _buildHierarchy(companies),
+      );
       
       return Right(hierarchy);
     } on ServerFailure catch (e) {

lib/domain/usecases/company/toggle_company_status_usecase.dart

@@ -1,5 +1,5 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
 
@@ -16,15 +16,20 @@ class ToggleCompanyStatusParams {
 
 /// 회사 활성화/비활성화 UseCase
 class ToggleCompanyStatusUseCase extends UseCase<void, ToggleCompanyStatusParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  ToggleCompanyStatusUseCase(this._companyService);
+  ToggleCompanyStatusUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, void>> call(ToggleCompanyStatusParams params) async {
     try {
-      await _companyService.updateCompanyStatus(params.id, params.isActive);
+      // 레포지토리는 토글 방식으로 동작하므로 결과만 확인
-      return const Right(null);
+      final result = await _companyRepository.toggleCompanyStatus(params.id);
+      return result.fold(
+        (failure) => Left(failure),
+        (_) => const Right(null),
+      );
     } on ServerFailure catch (e) {
       if (e.message.contains('equipment')) {
         return Left(ValidationFailure(

lib/domain/usecases/company/update_company_usecase.dart

@@ -1,5 +1,5 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../../../models/company_model.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
@@ -17,9 +17,10 @@ class UpdateCompanyParams {
 
 /// 회사 수정 UseCase
 class UpdateCompanyUseCase extends UseCase<Company, UpdateCompanyParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  UpdateCompanyUseCase(this._companyService);
+  UpdateCompanyUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, Company>> call(UpdateCompanyParams params) async {
@@ -30,8 +31,8 @@ class UpdateCompanyUseCase extends UseCase<Company, UpdateCompanyParams> {
         return Left(validationResult);
       }
 
-      final company = await _companyService.updateCompany(params.id, params.company);
+      final result = await _companyRepository.updateCompany(params.id, params.company);
-      return Right(company);
+      return result;
     } on ServerFailure catch (e) {
       return Left(ServerFailure(
         message: e.message,

lib/domain/usecases/company/update_parent_company_usecase.dart

@@ -2,7 +2,7 @@ import 'package:dartz/dartz.dart';
 import '../../../core/errors/failures.dart';
 import '../../../core/utils/hierarchy_validator.dart';
 import '../../../models/company_model.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../base_usecase.dart';
 import '../../../data/models/company/company_dto.dart';
 
@@ -19,21 +19,19 @@ class UpdateParentCompanyParams {
 
 /// 부모 회사 변경 UseCase
 class UpdateParentCompanyUseCase extends UseCase<Company, UpdateParentCompanyParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  UpdateParentCompanyUseCase(this._companyService);
+  UpdateParentCompanyUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, Company>> call(UpdateParentCompanyParams params) async {
     try {
       // 1. 모든 회사 조회 (검증용)
-      final response = await _companyService.getCompanies(
+      final allCompaniesEither = await _companyRepository.getCompanyHierarchy(includeInactive: true);
-        page: 1,
-        perPage: 1000,
-      );
       
       // CompanyDto 리스트로 변환 (검증용)
-      final companyResponses = response.items.map((company) => CompanyDto(
+      final companyResponses = allCompaniesEither.getOrElse(() => <Company>[]).map((company) => CompanyDto(
         id: company.id ?? 0,
         name: company.name,
         address: company.address.toString(),
@@ -83,18 +81,12 @@ class UpdateParentCompanyUseCase extends UseCase<Company, UpdateParentCompanyPar
         ));
       }
       
-      // 5. 현재 회사 정보 조회
+      // 5~7. 레포지토리 메서드로 부모 변경 수행
-      final currentCompany = await _companyService.getCompanyDetail(params.companyId);
+      final updateEither = await _companyRepository.updateParentCompany(
-      
+        params.companyId,
-      // 6. 부모 회사 ID만 변경
+        params.newParentId,
-      final updatedCompany = currentCompany.copyWith(
-        parentCompanyId: params.newParentId,
       );
-      
+      return updateEither;
-      // 7. 업데이트 실행
-      final result = await _companyService.updateCompany(params.companyId, updatedCompany);
-      
-      return Right(result);
     } on ServerFailure catch (e) {
       return Left(ServerFailure(
         message: e.message,

lib/domain/usecases/company/validate_company_deletion_usecase.dart

@@ -1,9 +1,10 @@
 import 'package:dartz/dartz.dart';
 import '../../../core/errors/failures.dart';
 import '../../../core/utils/hierarchy_validator.dart';
-import '../../../services/company_service.dart';
+import '../../repositories/company_repository.dart';
 import '../base_usecase.dart';
 import '../../../data/models/company/company_dto.dart';
+import '../../../models/company_model.dart';
 
 /// 회사 삭제 가능 여부 검증 파라미터
 class ValidateCompanyDeletionParams {
@@ -29,23 +30,21 @@ class CompanyDeletionValidationResult {
 
 /// 회사 삭제 가능 여부 검증 UseCase
 class ValidateCompanyDeletionUseCase extends UseCase<CompanyDeletionValidationResult, ValidateCompanyDeletionParams> {
-  final CompanyService _companyService;
+  // 레포지토리 기반으로 마이그레이션
+  final CompanyRepository _companyRepository;
 
-  ValidateCompanyDeletionUseCase(this._companyService);
+  ValidateCompanyDeletionUseCase(this._companyRepository);
 
   @override
   Future<Either<Failure, CompanyDeletionValidationResult>> call(ValidateCompanyDeletionParams params) async {
     try {
       final blockers = <String>[];
       
-      // 1. 자식 회사 존재 여부 확인
+      // 1. 전체 회사(계층 구성용) 조회
-      final response = await _companyService.getCompanies(
+      final companiesEither = await _companyRepository.getCompanyHierarchy(includeInactive: true);
-        page: 1,
-        perPage: 1000,
-      );
 
       // CompanyDto 리스트로 변환 (검증용)
-      final companyResponses = response.items.map((company) => CompanyDto(
+      final companyResponses = companiesEither.getOrElse(() => <Company>[]).map((company) => CompanyDto(
         id: company.id ?? 0,
         name: company.name,
         address: company.address.toString(),

lib/injection_container.dart

@@ -17,7 +17,7 @@ import 'data/datasources/remote/maintenance_remote_datasource.dart';
 import 'data/datasources/remote/user_remote_datasource.dart';
 import 'data/datasources/remote/warehouse_location_remote_datasource.dart';
 import 'data/datasources/remote/warehouse_remote_datasource.dart';
-import 'data/datasources/interceptors/api_interceptor.dart';
+// import 'data/datasources/interceptors/api_interceptor.dart'; // Legacy interceptor (no longer used)
 
 // Repositories
 import 'domain/repositories/administrator_repository.dart';
@@ -137,7 +137,7 @@ import 'screens/administrator/controllers/administrator_controller.dart';
 final sl = GetIt.instance;
 final getIt = sl; // Alias for compatibility
 
-Future<void> init() async {
+  Future<void> init() async {
   // External
   final sharedPreferences = await SharedPreferences.getInstance();
   sl.registerLazySingleton(() => sharedPreferences);
@@ -145,29 +145,12 @@ Future<void> init() async {
   // Core
   sl.registerLazySingleton(() => SecureStorage());
   sl.registerLazySingleton(() => const FlutterSecureStorage());
-  sl.registerLazySingleton(() => ApiInterceptor(sl()));
   
-  // API Client
+  // API Client (centralized Dio + interceptors)
   sl.registerLazySingleton(() => ApiClient());
   
-  // Dio
+  // Dio — use ApiClient's configured Dio to avoid divergence
-  sl.registerLazySingleton<Dio>(() {
+  sl.registerLazySingleton<Dio>(() => sl<ApiClient>().dio);
-    final dio = Dio();
-    dio.options = BaseOptions(
-      baseUrl: 'http://43.201.34.104:8080/api/v1',
-      connectTimeout: const Duration(seconds: 30),
-      receiveTimeout: const Duration(seconds: 30),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    );
-    dio.interceptors.add(sl<ApiInterceptor>());
-    dio.interceptors.add(LogInterceptor(
-      requestBody: true,
-      responseBody: true,
-    ));
-    return dio;
-  });
   
   // Data Sources
   sl.registerLazySingleton<AdministratorRemoteDataSource>(
@@ -252,21 +235,21 @@ Future<void> init() async {
   
   // Use Cases - Auth
   sl.registerLazySingleton(() => LoginUseCase(sl<AuthRepository>()));  // Repository 사용
-  sl.registerLazySingleton(() => LogoutUseCase(sl<AuthService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => LogoutUseCase(sl<AuthRepository>()));
-  sl.registerLazySingleton(() => GetCurrentUserUseCase(sl<AuthService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => GetCurrentUserUseCase(sl<AuthRepository>()));
   sl.registerLazySingleton(() => CheckAuthStatusUseCase(sl<AuthRepository>()));  // Repository 사용
-  sl.registerLazySingleton(() => RefreshTokenUseCase(sl<AuthService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => RefreshTokenUseCase(sl<AuthRepository>()));
   
   // Use Cases - Company
-  sl.registerLazySingleton(() => GetCompaniesUseCase(sl<CompanyRepository>()));  // Repository 사용
+  sl.registerLazySingleton(() => GetCompaniesUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => GetCompanyDetailUseCase(sl<CompanyService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => GetCompanyDetailUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => CreateCompanyUseCase(sl<CompanyService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => CreateCompanyUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => UpdateCompanyUseCase(sl<CompanyService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => UpdateCompanyUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => DeleteCompanyUseCase(sl<CompanyService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => DeleteCompanyUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => ToggleCompanyStatusUseCase(sl<CompanyService>()));  // Service 사용 (아직 미수정)
+  sl.registerLazySingleton(() => ToggleCompanyStatusUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => GetCompanyHierarchyUseCase(sl<CompanyService>()));  // Service 사용
+  sl.registerLazySingleton(() => GetCompanyHierarchyUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => UpdateParentCompanyUseCase(sl<CompanyService>()));  // Service 사용
+  sl.registerLazySingleton(() => UpdateParentCompanyUseCase(sl<CompanyRepository>()));
-  sl.registerLazySingleton(() => ValidateCompanyDeletionUseCase(sl<CompanyService>()));  // Service 사용
+  sl.registerLazySingleton(() => ValidateCompanyDeletionUseCase(sl<CompanyRepository>()));
   sl.registerLazySingleton(() => RestoreCompanyUseCase(sl<CompanyRepository>()));
   
   // Use Cases - User (Repository 사용으로 마이그레이션 완료)

lib/main.dart

@@ -26,12 +26,17 @@ import 'package:superport/screens/equipment/controllers/equipment_history_contro
 import 'package:superport/screens/maintenance/controllers/maintenance_controller.dart';
 import 'package:superport/screens/maintenance/controllers/maintenance_dashboard_controller.dart';
 import 'package:superport/screens/rent/controllers/rent_controller.dart';
+import 'package:superport/core/config/environment.dart';
+import 'package:superport/core/navigation/app_navigator.dart';
 
 void main() async {
   // Flutter 바인딩 초기화
   WidgetsFlutterBinding.ensureInitialized();
   
   try {
+    // 환경 변수 로드 (.env)
+    await Environment.initialize();
+
     // 의존성 주입 설정
     await di.init();
   } catch (e) {
@@ -333,7 +338,8 @@ class SuperportApp extends StatelessWidget {
             );
         }
         },
-        navigatorKey: GlobalKey<NavigatorState>(),
+        // 전역 네비게이터 키 사용: 인터셉터 등에서 401 발생 시 로그인으로 전환
+        navigatorKey: appNavigatorKey,
       ),
     );
   }

lib/models/user_model.dart

@@ -20,6 +20,9 @@ class User with _$User {
     /// 전화번호 (선택, "010-1234-5678" 형태)
     String? phone,
     
+    /// 소속 회사명 (UI 표시용, 백엔드 미저장)
+    String? companyName,
+    
     /// UI용 필드들 (백엔드 저장하지 않음)
     @Default('') String username,  // UI 호환용
     @Default(UserRole.staff) UserRole role,  // UI 호환용

lib/models/user_model.freezed.dart

@@ -32,6 +32,9 @@ mixin _$User {
   /// 전화번호 (선택, "010-1234-5678" 형태)
   String? get phone => throw _privateConstructorUsedError;
 
+  /// 소속 회사명 (UI 표시용, 백엔드 미저장)
+  String? get companyName => throw _privateConstructorUsedError;
+
   /// UI용 필드들 (백엔드 저장하지 않음)
   String get username => throw _privateConstructorUsedError; // UI 호환용
   UserRole get role => throw _privateConstructorUsedError; // UI 호환용
@@ -58,6 +61,7 @@ abstract class $UserCopyWith<$Res> {
       String name,
       String? email,
       String? phone,
+      String? companyName,
       String username,
       UserRole role,
       bool isActive,
@@ -84,6 +88,7 @@ class _$UserCopyWithImpl<$Res, $Val extends User>
     Object? name = null,
     Object? email = freezed,
     Object? phone = freezed,
+    Object? companyName = freezed,
     Object? username = null,
     Object? role = null,
     Object? isActive = null,
@@ -107,6 +112,10 @@ class _$UserCopyWithImpl<$Res, $Val extends User>
           ? _value.phone
           : phone // ignore: cast_nullable_to_non_nullable
               as String?,
+      companyName: freezed == companyName
+          ? _value.companyName
+          : companyName // ignore: cast_nullable_to_non_nullable
+              as String?,
       username: null == username
           ? _value.username
           : username // ignore: cast_nullable_to_non_nullable
@@ -143,6 +152,7 @@ abstract class _$$UserImplCopyWith<$Res> implements $UserCopyWith<$Res> {
       String name,
       String? email,
       String? phone,
+      String? companyName,
       String username,
       UserRole role,
       bool isActive,
@@ -166,6 +176,7 @@ class __$$UserImplCopyWithImpl<$Res>
     Object? name = null,
     Object? email = freezed,
     Object? phone = freezed,
+    Object? companyName = freezed,
     Object? username = null,
     Object? role = null,
     Object? isActive = null,
@@ -189,6 +200,10 @@ class __$$UserImplCopyWithImpl<$Res>
           ? _value.phone
           : phone // ignore: cast_nullable_to_non_nullable
               as String?,
+      companyName: freezed == companyName
+          ? _value.companyName
+          : companyName // ignore: cast_nullable_to_non_nullable
+              as String?,
       username: null == username
           ? _value.username
           : username // ignore: cast_nullable_to_non_nullable
@@ -221,6 +236,7 @@ class _$UserImpl implements _User {
       required this.name,
       this.email,
       this.phone,
+      this.companyName,
       this.username = '',
       this.role = UserRole.staff,
       this.isActive = true,
@@ -246,6 +262,10 @@ class _$UserImpl implements _User {
   @override
   final String? phone;
 
+  /// 소속 회사명 (UI 표시용, 백엔드 미저장)
+  @override
+  final String? companyName;
+
   /// UI용 필드들 (백엔드 저장하지 않음)
   @override
   @JsonKey()
@@ -267,7 +287,7 @@ class _$UserImpl implements _User {
 
   @override
   String toString() {
-    return 'User(id: $id, name: $name, email: $email, phone: $phone, username: $username, role: $role, isActive: $isActive, createdAt: $createdAt, updatedAt: $updatedAt)';
+    return 'User(id: $id, name: $name, email: $email, phone: $phone, companyName: $companyName, username: $username, role: $role, isActive: $isActive, createdAt: $createdAt, updatedAt: $updatedAt)';
   }
 
   @override
@@ -279,6 +299,8 @@ class _$UserImpl implements _User {
             (identical(other.name, name) || other.name == name) &&
             (identical(other.email, email) || other.email == email) &&
             (identical(other.phone, phone) || other.phone == phone) &&
+            (identical(other.companyName, companyName) ||
+                other.companyName == companyName) &&
             (identical(other.username, username) ||
                 other.username == username) &&
             (identical(other.role, role) || other.role == role) &&
@@ -292,8 +314,8 @@ class _$UserImpl implements _User {
 
   @JsonKey(includeFromJson: false, includeToJson: false)
   @override
-  int get hashCode => Object.hash(runtimeType, id, name, email, phone, username,
+  int get hashCode => Object.hash(runtimeType, id, name, email, phone,
-      role, isActive, createdAt, updatedAt);
+      companyName, username, role, isActive, createdAt, updatedAt);
 
   /// Create a copy of User
   /// with the given fields replaced by the non-null parameter values.
@@ -317,6 +339,7 @@ abstract class _User implements User {
       required final String name,
       final String? email,
       final String? phone,
+      final String? companyName,
       final String username,
       final UserRole role,
       final bool isActive,
@@ -341,6 +364,10 @@ abstract class _User implements User {
   @override
   String? get phone;
 
+  /// 소속 회사명 (UI 표시용, 백엔드 미저장)
+  @override
+  String? get companyName;
+
   /// UI용 필드들 (백엔드 저장하지 않음)
   @override
   String get username; // UI 호환용

lib/models/user_model.g.dart

@@ -11,6 +11,7 @@ _$UserImpl _$$UserImplFromJson(Map<String, dynamic> json) => _$UserImpl(
       name: json['name'] as String,
       email: json['email'] as String?,
       phone: json['phone'] as String?,
+      companyName: json['companyName'] as String?,
       username: json['username'] as String? ?? '',
       role: $enumDecodeNullable(_$UserRoleEnumMap, json['role']) ??
           UserRole.staff,
@@ -29,6 +30,7 @@ Map<String, dynamic> _$$UserImplToJson(_$UserImpl instance) =>
       'name': instance.name,
       'email': instance.email,
       'phone': instance.phone,
+      'companyName': instance.companyName,
       'username': instance.username,
       'role': _$UserRoleEnumMap[instance.role]!,
       'isActive': instance.isActive,

lib/screens/administrator/administrator_list.dart

@@ -471,6 +471,22 @@ class _AdministratorFormDialogState extends State<_AdministratorFormDialog> {
   Widget build(BuildContext context) {
     return ShadDialog(
       title: Text(widget.title),
+      actions: [
+        ShadButton.outline(
+          onPressed: _isSubmitting ? null : () => Navigator.of(context).pop(),
+          child: const Text('취소'),
+        ),
+        ShadButton(
+          onPressed: _isSubmitting ? null : _handleSubmit,
+          child: _isSubmitting
+              ? const SizedBox(
+                  width: 16,
+                  height: 16,
+                  child: CircularProgressIndicator(strokeWidth: 2),
+                )
+              : Text(_isEditMode ? '수정' : '생성'),
+        ),
+      ],
       child: SizedBox(
         width: 500,
         child: Form(
@@ -575,22 +591,7 @@ class _AdministratorFormDialogState extends State<_AdministratorFormDialog> {
           ),
         ),
       ),
-      actions: [
+      
-        ShadButton.outline(
-          child: const Text('취소'),
-          onPressed: _isSubmitting ? null : () => Navigator.of(context).pop(),
-        ),
-        ShadButton(
-          onPressed: _isSubmitting ? null : _handleSubmit,
-          child: _isSubmitting
-              ? const SizedBox(
-                  width: 16,
-                  height: 16,
-                  child: CircularProgressIndicator(strokeWidth: 2),
-                )
-              : Text(_isEditMode ? '수정' : '생성'),
-        ),
-      ],
     );
   }
 }

lib/screens/common/app_layout.dart

@@ -1138,6 +1138,14 @@ class SidebarMenu extends StatelessWidget {
                   ],
                 ),
 
+                _buildMenuItem(
+                  icon: Icons.calendar_month_outlined,
+                  title: '임대 관리',
+                  route: Routes.rent,
+                  isActive: currentRoute == Routes.rent,
+                  badge: null,
+                ),
+                
 
                 if (!collapsed) ...[
                   const SizedBox(height: ShadcnTheme.spacing4),
@@ -1376,6 +1384,8 @@ class SidebarMenu extends StatelessWidget {
         return Icons.factory;
       case Icons.category_outlined:
         return Icons.category;
+      case Icons.calendar_month_outlined:
+        return Icons.calendar_month;
       default:
         return outlinedIcon;
     }

lib/screens/common/templates/form_layout_template.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:superport/screens/common/components/shadcn_components.dart';
+import 'package:superport/screens/common/theme_shadcn.dart';
 
 /// 폼 화면의 일관된 레이아웃을 제공하는 템플릿 위젯
 class FormLayoutTemplate extends StatelessWidget {
@@ -27,27 +28,30 @@ class FormLayoutTemplate extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return Scaffold(
-      backgroundColor: Color(0xFFF5F7FA),
+      backgroundColor: ShadcnTheme.background, // Phase 10: 통일된 배경색
       appBar: AppBar(
         title: Text(
           title,
-          style: TextStyle(
+          style: ShadcnTheme.headingH3.copyWith( // Phase 10: 표준 헤딩 스타일
-            fontSize: 18,
             fontWeight: FontWeight.w600,
-            color: Color(0xFF1A1F36),
+            color: ShadcnTheme.foreground,
           ),
         ),
-        backgroundColor: Colors.white,
+        backgroundColor: ShadcnTheme.card, // Phase 10: 카드 배경색
         elevation: 0,
         leading: IconButton(
-          icon: Icon(Icons.arrow_back_ios, color: Color(0xFF6B7280), size: 20),
+          icon: Icon(
+            Icons.arrow_back_ios, 
+            color: ShadcnTheme.mutedForeground, // Phase 10: 뮤트된 전경색
+            size: 20,
+          ),
           onPressed: onCancel ?? () => Navigator.of(context).pop(),
         ),
         actions: customActions != null ? [customActions!] : null,
         bottom: PreferredSize(
           preferredSize: Size.fromHeight(1),
           child: Container(
-            color: Color(0xFFE5E7EB),
+            color: ShadcnTheme.border, // Phase 10: 통일된 테두리 색상
             height: 1,
           ),
         ),
@@ -60,13 +64,13 @@ class FormLayoutTemplate extends StatelessWidget {
   Widget _buildBottomBar(BuildContext context) {
     return Container(
       decoration: BoxDecoration(
-        color: Colors.white,
+        color: ShadcnTheme.card, // Phase 10: 카드 배경색
         border: Border(
-          top: BorderSide(color: Color(0xFFE5E7EB), width: 1),
+          top: BorderSide(color: ShadcnTheme.border, width: 1), // Phase 10: 통일된 테두리
         ),
         boxShadow: [
           BoxShadow(
-            color: Colors.black.withValues(alpha: 0.05),
+            color: ShadcnTheme.foreground.withValues(alpha: 0.05), // Phase 10: 그림자 색상
             offset: Offset(0, -2),
             blurRadius: 4,
           ),
@@ -125,24 +129,22 @@ class FormSection extends StatelessWidget {
           if (title != null) ...[
             Text(
               title!,
-              style: TextStyle(
+              style: ShadcnTheme.bodyLarge.copyWith( // Phase 10: 표준 바디 라지
-                fontSize: 16,
                 fontWeight: FontWeight.w600,
-                color: Color(0xFF1A1F36),
+                color: ShadcnTheme.foreground, // Phase 10: 전경색
               ),
             ),
             if (subtitle != null) ...[
               SizedBox(height: 4),
               Text(
                 subtitle!,
-                style: TextStyle(
+                style: ShadcnTheme.bodyMedium.copyWith( // Phase 10: 표준 바디 미디엄
-                  fontSize: 14,
+                  color: ShadcnTheme.mutedForeground, // Phase 10: 뮤트된 전경색
-                  color: Color(0xFF6B7280),
                 ),
               ),
             ],
             SizedBox(height: 20),
-            Divider(color: Color(0xFFE5E7EB), height: 1),
+            Divider(color: ShadcnTheme.border, height: 1), // Phase 10: 테두리 색상
             SizedBox(height: 20),
           ],
           if (children.isNotEmpty)

lib/screens/common/theme_shadcn.dart

@@ -45,19 +45,19 @@ class ShadcnTheme {
   static const Color infoLight = Color(0xFFCFFAFE); // cyan-100
   static const Color infoForeground = Color(0xFFFFFFFF);
   
-  // ============= 비즈니스 상태 색상 =============
+  // ============= 비즈니스 상태 색상 (색체심리학 기반) =============
-  // 회사 구분 색상
+  // 회사 구분 색상 - Phase 10 업데이트
-  static const Color companyHeadquarters = Color(0xFF2563EB); // 본사 - Primary Blue (권위)
+  static const Color companyHeadquarters = Color(0xFF2563EB); // 본사 - 진한 파랑 (권위, 안정성)
-  static const Color companyBranch = Color(0xFF7C3AED); // 지점 - Purple (연결성)
+  static const Color companyBranch = Color(0xFF3B82F6); // 지점 - 밝은 파랑 (연결성, 확장)
-  static const Color companyPartner = Color(0xFF059669); // 파트너사 - Green (협력)
+  static const Color companyPartner = Color(0xFF10B981); // 파트너사 - 에메랄드 (협력, 신뢰)
-  static const Color companyCustomer = Color(0xFFEA580C); // 고객사 - Orange (활력)
+  static const Color companyCustomer = Color(0xFF059669); // 고객사 - 진한 그린 (성장, 번영)
   
-  // 장비 상태 색상
+  // 트랜잭션 상태 색상 - Phase 10 업데이트
-  static const Color equipmentIn = Color(0xFF059669); // 입고 - Green (진입/추가)
+  static const Color equipmentIn = Color(0xFF10B981); // 입고 - 에메랄드 (추가/성장)
-  static const Color equipmentOut = Color(0xFF0891B2); // 출고 - Cyan (이동/프로세스)
+  static const Color equipmentOut = Color(0xFF3B82F6); // 출고 - 블루 (이동/처리)
-  static const Color equipmentRent = Color(0xFF7C3AED); // 대여 - Purple (임시 상태)
+  static const Color equipmentRent = Color(0xFF8B5CF6); // 대여 - Purple (임시 상태)
-  static const Color equipmentDisposal = Color(0xFF6B7280); // 폐기 - Gray (비활성)
+  static const Color equipmentDisposal = Color(0xFF6B7280); // 폐기 - Gray (종료/비활성)
-  static const Color equipmentRepair = Color(0xFFD97706); // 수리중 - Amber (주의 필요)
+  static const Color equipmentRepair = Color(0xFFF59E0B); // 수리중 - Amber (주의/진행)
   static const Color equipmentUnknown = Color(0xFF9CA3AF); // 알수없음 - Light Gray
   
   // ============= UI 요소 색상 =============
@@ -93,8 +93,15 @@ class ShadcnTheme {
   
   // 추가 색상 (기존 호환)
   static const Color blue = primary;
-  static const Color purple = companyBranch;
+  static const Color purple = equipmentRent;
-  static const Color green = companyPartner;
+  static const Color green = equipmentIn;
+
+  // Phase 10 - 알림/경고 색상 체계 (긴급도 기반)
+  static const Color alertNormal = Color(0xFF10B981); // 60일 이상 - 안전 (그린)
+  static const Color alertWarning60 = Color(0xFFF59E0B); // 60일 이내 - 주의 (앰버)
+  static const Color alertWarning30 = Color(0xFFF97316); // 30일 이내 - 경고 (오렌지)
+  static const Color alertCritical7 = Color(0xFFEF4444); // 7일 이내 - 위험 (레드)
+  static const Color alertExpired = Color(0xFFDC2626); // 만료됨 - 심각 (진한 레드)
   
   static const Color radius = Color(0xFF000000); // 사용하지 않음
   
@@ -526,52 +533,61 @@ class ShadcnTheme {
   }
   
   // ============= 유틸리티 메서드 =============
-  /// 회사 타입에 따른 색상 반환
+  /// 회사 타입에 따른 색상 반환 (Phase 10 업데이트)
   static Color getCompanyColor(String type) {
     switch (type.toLowerCase()) {
       case '본사':
       case 'headquarters':
-        return companyHeadquarters;
+        return companyHeadquarters; // #2563eb - 진한 파랑
       case '지점':
       case 'branch':
-        return companyBranch;
+        return companyBranch; // #3b82f6 - 밝은 파랑
       case '파트너사':
       case 'partner':
-        return companyPartner;
+        return companyPartner; // #10b981 - 에메랄드
       case '고객사':
       case 'customer':
-        return companyCustomer;
+        return companyCustomer; // #059669 - 진한 그린
       default:
         return secondary;
     }
   }
   
-  /// 장비 상태에 따른 색상 반환
+  /// 트랜잭션 상태에 따른 색상 반환 (Phase 10 업데이트)
   static Color getEquipmentStatusColor(String status) {
     switch (status.toLowerCase()) {
       case '입고':
       case 'in':
-        return equipmentIn;
+        return equipmentIn; // #10b981 - 에메랄드
       case '출고':
       case 'out':
-        return equipmentOut;
+        return equipmentOut; // #3b82f6 - 블루
       case '대여':
       case 'rent':
-        return equipmentRent;
+        return equipmentRent; // #8b5cf6 - 퍼플
       case '폐기':
       case 'disposal':
-        return equipmentDisposal;
+        return equipmentDisposal; // #6b7280 - 그레이
       case '수리중':
       case 'repair':
-        return equipmentRepair;
+        return equipmentRepair; // #f59e0b - 앰버
       case '알수없음':
       case 'unknown':
-        return equipmentUnknown;
+        return equipmentUnknown; // #9ca3af - 라이트 그레이
       default:
         return secondary;
     }
   }
 
+  /// 알림/경고 긴급도에 따른 색상 반환 (Phase 10 신규 추가)
+  static Color getAlertColor(int daysUntilExpiry) {
+    if (daysUntilExpiry < 0) return alertExpired; // 만료됨
+    if (daysUntilExpiry <= 7) return alertCritical7; // 7일 이내
+    if (daysUntilExpiry <= 30) return alertWarning30; // 30일 이내
+    if (daysUntilExpiry <= 60) return alertWarning60; // 60일 이내
+    return alertNormal; // 60일 이상
+  }
+  
   /// 상태별 배경색 반환 (연한 버전)
   static Color getStatusBackgroundColor(String status) {
     switch (status.toLowerCase()) {

lib/screens/company/company_list.dart

@@ -162,13 +162,13 @@ class _CompanyListState extends State<CompanyList> {
   }
 
 
-  /// 본사/지점 구분 배지 생성
+  /// 본사/지점 구분 배지 생성 - Phase 10: 색체심리학 기반 색상 적용
   Widget _buildCompanyTypeLabel(bool isBranch) {
     return ShadcnBadge(
       text: isBranch ? '지점' : '본사',
       variant: isBranch 
-          ? ShadcnBadgeVariant.companyBranch       // Purple (#7C3AED) - 차별화
+          ? ShadcnBadgeVariant.companyBranch       // Phase 10: 지점 - 밝은 파랑
-          : ShadcnBadgeVariant.companyHeadquarters, // Blue (#2563EB)
+          : ShadcnBadgeVariant.companyHeadquarters, // Phase 10: 본사 - 진한 파랑  
       size: ShadcnBadgeSize.small,
     );
   }
@@ -261,7 +261,7 @@ class _CompanyListState extends State<CompanyList> {
     if (item.isPartner) {
       flags.add(ShadcnBadge(
         text: '파트너',
-        variant: ShadcnBadgeVariant.companyPartner,
+        variant: ShadcnBadgeVariant.companyPartner, // Phase 10: 협력 - 에메랄드
         size: ShadcnBadgeSize.small,
       ));
     }
@@ -269,7 +269,7 @@ class _CompanyListState extends State<CompanyList> {
     if (item.isCustomer) {
       flags.add(ShadcnBadge(
         text: '고객',
-        variant: ShadcnBadgeVariant.companyCustomer,
+        variant: ShadcnBadgeVariant.companyCustomer, // Phase 10: 고객 - 진한 그린
         size: ShadcnBadgeSize.small,
       ));
     }
@@ -313,184 +313,82 @@ class _CompanyListState extends State<CompanyList> {
     }
   }
   
-  /// 헤더 셀 빌더
+  // (Deprecated) 기존 커스텀 테이블 빌더 유틸들은 ShadTable 전환으로 제거되었습니다.
-  Widget _buildHeaderCell(
+
-    String text, {
+
-    required int flex,
+  /// ShadTable 기반 회사 테이블 빌더 (기존 컬럼 구성 유지)
-    required bool useExpanded,
+  Widget _buildCompanyShadTable(List<CompanyItem> items, CompanyListController controller) {
-    required double minWidth,
+    if (items.isEmpty) {
-  }) {
+      return Center(
-    final child = Container(
+        child: Column(
-      alignment: Alignment.centerLeft,
+          mainAxisAlignment: MainAxisAlignment.center,
-      child: Text(
+          children: [
-        text,
+            Icon(Icons.business_outlined, size: 64, color: ShadcnTheme.mutedForeground),
-        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
+            const SizedBox(height: 16),
+            Text('등록된 회사가 없습니다', style: ShadcnTheme.bodyMedium.copyWith(color: ShadcnTheme.mutedForeground)),
+          ],
         ),
       );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
     }
-  }
-
-  /// 데이터 셀 빌더
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      child: child,
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
-
-  /// 헤더 셀 리스트
-  List<Widget> _buildHeaderCells() {
-    return [
-      _buildHeaderCell('번호', flex: 0, useExpanded: false, minWidth: 50),
-      _buildHeaderCell('회사명', flex: 3, useExpanded: true, minWidth: 120),
-      _buildHeaderCell('구분', flex: 0, useExpanded: false, minWidth: 60),
-      _buildHeaderCell('주소', flex: 2, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('담당자', flex: 2, useExpanded: true, minWidth: 80),
-      _buildHeaderCell('연락처', flex: 2, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('파트너/고객', flex: 1, useExpanded: true, minWidth: 80),
-      _buildHeaderCell('상태', flex: 0, useExpanded: false, minWidth: 60),
-      _buildHeaderCell('등록/수정일', flex: 2, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('비고', flex: 1, useExpanded: true, minWidth: 80),
-      _buildHeaderCell('관리', flex: 0, useExpanded: false, minWidth: 100),
-    ];
-  }
-
-  /// 테이블 행 빌더
-  Widget _buildTableRow(CompanyItem item, int index, CompanyListController controller) {
-    final rowNumber = ((controller.currentPage - 1) * controller.pageSize) + index + 1;
 
     return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
       decoration: BoxDecoration(
-        color: index.isEven 
+        border: Border.all(color: ShadcnTheme.border),
-            ? ShadcnTheme.muted.withValues(alpha: 0.1)
+        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-            : null,
-        border: const Border(
-          bottom: BorderSide(color: Colors.black),
       ),
-      ),
+      child: Padding(
-      child: Row(
+        padding: const EdgeInsets.all(12.0),
+        child: ShadTable.list(
+          header: const [
+            ShadTableCell.header(child: Text('번호')),
+            ShadTableCell.header(child: Text('회사명')),
+            ShadTableCell.header(child: Text('구분')),
+            ShadTableCell.header(child: Text('주소')),
+            ShadTableCell.header(child: Text('담당자')),
+            ShadTableCell.header(child: Text('연락처')),
+            ShadTableCell.header(child: Text('파트너/고객')),
+            ShadTableCell.header(child: Text('상태')),
+            ShadTableCell.header(child: Text('등록/수정일')),
+            ShadTableCell.header(child: Text('비고')),
+            ShadTableCell.header(child: Text('관리')),
+          ],
           children: [
-          _buildDataCell(
+            for (int index = 0; index < items.length; index++)
-            Text(
+              [
-              rowNumber.toString(),
+                // 번호
-              style: ShadcnTheme.bodySmall,
+                ShadTableCell(child: Text(((((controller.currentPage - 1) * controller.pageSize) + index + 1)).toString(), style: ShadcnTheme.bodySmall)),
-            ),
+                // 회사명 (본사>지점 표기 유지)
-            flex: 0,
+                ShadTableCell(child: _buildDisplayNameText(items[index])),
-            useExpanded: false,
+                // 구분 (본사/지점)
-            minWidth: 50,
+                ShadTableCell(child: _buildCompanyTypeLabel(items[index].isBranch)),
-          ),
+                // 주소
-          _buildDataCell(
+                ShadTableCell(child: Text(items[index].address.isNotEmpty ? items[index].address : '-', overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodySmall)),
-            _buildDisplayNameText(item),
+                // 담당자 요약
-            flex: 3,
+                ShadTableCell(child: _buildContactInfo(items[index])),
-            useExpanded: true,
+                // 연락처 상세
-            minWidth: 120,
+                ShadTableCell(child: _buildContactDetails(items[index])),
-          ),
+                // 파트너/고객 플래그
-          _buildDataCell(
+                ShadTableCell(child: _buildPartnerCustomerFlags(items[index])),
-            _buildCompanyTypeLabel(item.isBranch),
+                // 상태
-            flex: 0,
+                ShadTableCell(child: _buildStatusBadge(items[index].isActive)),
-            useExpanded: false,
+                // 등록/수정일
-            minWidth: 60,
+                ShadTableCell(child: _buildDateInfo(items[index])),
-          ),
+                // 비고
-          _buildDataCell(
+                ShadTableCell(child: Text(items[index].remark ?? '-', overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodySmall)),
-            Text(
+                // 관리(편집/삭제)
-              item.address.isNotEmpty ? item.address : '-',
+                ShadTableCell(
-              style: ShadcnTheme.bodySmall,
+                  child: Row(
-              overflow: TextOverflow.ellipsis,
-              maxLines: 2,
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            _buildContactInfo(item),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            _buildContactDetails(item),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            _buildPartnerCustomerFlags(item),
-            flex: 1,
-            useExpanded: true,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            _buildStatusBadge(item.isActive),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 60,
-          ),
-          _buildDataCell(
-            _buildDateInfo(item),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            Text(
-              item.remark ?? '-',
-              style: ShadcnTheme.bodySmall,
-              overflow: TextOverflow.ellipsis,
-              maxLines: 2,
-            ),
-            flex: 1,
-            useExpanded: true,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            Row(
                     mainAxisSize: MainAxisSize.min,
                     children: [
-                if (item.id != null) ...[
+                      if (items[index].id != null) ...[
                         ShadButton.ghost(
                           size: ShadButtonSize.sm,
-                    onPressed: () {
+                          onPressed: () async {
-                      if (item.isBranch) {
+                            // 기존 편집 흐름 유지
-                        Navigator.pushNamed(
+                            final args = {'companyId': items[index].id};
-                          context,
+                            final result = await Navigator.pushNamed(context, '/company/edit', arguments: args);
-                          '/company/branch/edit',
+                            if (result == true) {
-                          arguments: {
+                              controller.refresh();
-                            'companyId': item.parentCompanyId,
-                            'branchId': item.id,
-                            'parentCompanyName': item.parentCompanyName,
-                          },
-                        ).then((result) {
-                          if (result == true) controller.refresh();
-                        });
-                      } else {
-                        Navigator.pushNamed(
-                          context,
-                          '/company/edit',
-                          arguments: {
-                            'companyId': item.id,
-                            'isBranch': false,
-                          },
-                        ).then((result) {
-                          if (result == true) controller.refresh();
-                        });
                             }
                           },
                           child: const Icon(Icons.edit, size: 16),
@@ -499,10 +397,10 @@ class _CompanyListState extends State<CompanyList> {
                         ShadButton.ghost(
                           size: ShadButtonSize.sm,
                           onPressed: () {
-                      if (item.isBranch) {
+                            if (items[index].isBranch) {
-                        _deleteBranch(item.parentCompanyId!, item.id!);
+                              _deleteBranch(items[index].parentCompanyId!, items[index].id!);
                             } else {
-                        _deleteCompany(item.id!);
+                              _deleteCompany(items[index].id!);
                             }
                           },
                           child: const Icon(Icons.delete, size: 16),
@@ -510,62 +408,10 @@ class _CompanyListState extends State<CompanyList> {
                       ],
                     ],
                   ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 100,
                 ),
               ],
-      ),
-    );
-  }
-
-  /// 헤더 고정 패턴 회사 테이블 빌더
-  Widget _buildCompanyShadTable(List<CompanyItem> items, CompanyListController controller) {
-    return Container(
-      width: double.infinity,
-      decoration: BoxDecoration(
-        border: Border.all(color: Colors.black),
-        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-      ),
-      child: Column(
-        children: [
-          // 고정 헤더
-          Container(
-            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
-            decoration: BoxDecoration(
-              color: ShadcnTheme.muted.withValues(alpha: 0.3),
-              border: Border(bottom: BorderSide(color: Colors.black)),
-            ),
-            child: Row(children: _buildHeaderCells()),
-          ),
-          // 스크롤 바디
-          Expanded(
-            child: items.isEmpty
-                ? Center(
-                    child: Column(
-                      mainAxisAlignment: MainAxisAlignment.center,
-                      children: [
-                        Icon(
-                          Icons.business_outlined,
-                          size: 64,
-                          color: ShadcnTheme.mutedForeground,
-                        ),
-                        const SizedBox(height: 16),
-                        Text(
-                          '등록된 회사가 없습니다',
-                          style: ShadcnTheme.bodyMedium.copyWith(
-                            color: ShadcnTheme.mutedForeground,
-                          ),
-                        ),
           ],
         ),
-                  )
-                : ListView.builder(
-                    itemCount: items.length,
-                    itemBuilder: (context, index) => _buildTableRow(items[index], index, controller),
-                  ),
-          ),
-        ],
       ),
     );
   }

lib/screens/equipment/equipment_in_form.dart

@@ -233,13 +233,13 @@ class _EquipmentInFormScreenState extends State<EquipmentInFormScreen> {
               label: Text(_controller.isFieldReadOnly('serialNumber') 
                   ? '장비 번호 * 🔒' : '장비 번호 *'),
               validator: (value) {
-                if (value?.trim().isEmpty ?? true) {
+                if ((value ?? '').trim().isEmpty) {
                   return '장비 번호는 필수입니다';
                 }
                 return null;
               },
               onChanged: _controller.isFieldReadOnly('serialNumber') ? null : (value) {
-                _controller.serialNumber = value?.trim() ?? '';
+                _controller.serialNumber = value.trim();
                 setState(() {});
                 print('DEBUG [장비번호 입력] value: "$value", controller.serialNumber: "${_controller.serialNumber}"');
               },
@@ -252,7 +252,7 @@ class _EquipmentInFormScreenState extends State<EquipmentInFormScreen> {
               placeholder: const Text('바코드를 입력하세요'),
               label: const Text('바코드'),
               onChanged: (value) {
-                _controller.barcode = value?.trim() ?? '';
+                _controller.barcode = value.trim();
                 print('DEBUG [바코드 입력] value: "$value", controller.barcode: "${_controller.barcode}"');
               },
             ),
@@ -504,7 +504,7 @@ class _EquipmentInFormScreenState extends State<EquipmentInFormScreen> {
               label: const Text('워런티 번호 *'),
               placeholder: const Text('워런티 번호를 입력하세요'),
               validator: (value) {
-                if (value.trim().isEmpty ?? true) {
+                if (value.trim().isEmpty) {
                   return '워런티 번호는 필수입니다';
                 }
                 return null;

lib/screens/equipment/equipment_list.dart

@@ -57,6 +57,8 @@ class _EquipmentListState extends State<EquipmentList> {
     });
   }
 
+  
+
   // 드롭다운 데이터를 미리 로드하는 메서드
   Future<void> _preloadDropdownData() async {
     try {
@@ -94,6 +96,157 @@ class _EquipmentListState extends State<EquipmentList> {
     });
   }
 
+  /// ShadTable 기반 장비 목록 테이블
+  ///
+  /// - 표준 컴포넌트 사용으로 일관성 확보
+  /// - 핵심 컬럼만 우선 도입 (상태/장비번호/시리얼/제조사/모델/회사/창고/일자/관리)
+  /// - 반응형: 가용 너비에 따라 일부 컬럼은 숨김 처리 가능
+  Widget _buildShadTable(List<UnifiedEquipment> items, {required double availableWidth}) {
+    final allSelected = items.isNotEmpty &&
+        items.every((e) => _selectedItems.contains(e.equipment.id));
+
+    return ShadTable.list(
+      header: [
+        // 선택
+        ShadTableCell.header(
+          child: ShadCheckbox(
+            value: allSelected,
+            onChanged: (checked) {
+              setState(() {
+                if (checked == true) {
+                  _selectedItems
+                    ..clear()
+                    ..addAll(items.map((e) => e.equipment.id).whereType<int>());
+                } else {
+                  _selectedItems.clear();
+                }
+              });
+            },
+          ),
+        ),
+        ShadTableCell.header(child: const Text('상태')),
+        ShadTableCell.header(child: const Text('장비번호')),
+        ShadTableCell.header(child: const Text('시리얼')),
+        ShadTableCell.header(child: const Text('제조사')),
+        ShadTableCell.header(child: const Text('모델')),
+        if (availableWidth > 900) ShadTableCell.header(child: const Text('회사')),
+        if (availableWidth > 1100) ShadTableCell.header(child: const Text('창고')),
+        if (availableWidth > 800) ShadTableCell.header(child: const Text('일자')),
+        ShadTableCell.header(child: const Text('관리')),
+      ],
+      children: items.map((item) {
+        final id = item.equipment.id;
+        final selected = id != null && _selectedItems.contains(id);
+        return [
+          // 선택 체크박스
+          ShadTableCell(
+            child: ShadCheckbox(
+              value: selected,
+              onChanged: (checked) {
+                setState(() {
+                  if (id == null) return;
+                  if (checked == true) {
+                    _selectedItems.add(id);
+                  } else {
+                    _selectedItems.remove(id);
+                  }
+                });
+              },
+            ),
+          ),
+          // 상태
+          ShadTableCell(child: _buildStatusBadge(item.status)),
+          // 장비번호
+          ShadTableCell(
+            child: _buildTextWithTooltip(
+              item.equipment.equipmentNumber,
+              item.equipment.equipmentNumber,
+            ),
+          ),
+          // 시리얼
+          ShadTableCell(
+            child: _buildTextWithTooltip(
+              item.equipment.serialNumber ?? '-',
+              item.equipment.serialNumber ?? '-',
+            ),
+          ),
+          // 제조사
+          ShadTableCell(
+            child: _buildTextWithTooltip(
+              item.vendorName ?? item.equipment.manufacturer,
+              item.vendorName ?? item.equipment.manufacturer,
+            ),
+          ),
+          // 모델
+          ShadTableCell(
+            child: _buildTextWithTooltip(
+              item.modelName ?? item.equipment.modelName,
+              item.modelName ?? item.equipment.modelName,
+            ),
+          ),
+          // 회사 (반응형)
+          if (availableWidth > 900)
+            ShadTableCell(
+              child: _buildTextWithTooltip(
+                item.companyName ?? item.currentCompany ?? '-',
+                item.companyName ?? item.currentCompany ?? '-',
+              ),
+            ),
+          // 창고 (반응형)
+          if (availableWidth > 1100)
+            ShadTableCell(
+              child: _buildTextWithTooltip(
+                item.warehouseLocation ?? '-',
+                item.warehouseLocation ?? '-',
+              ),
+            ),
+          // 일자 (반응형)
+          if (availableWidth > 800)
+            ShadTableCell(
+              child: _buildTextWithTooltip(
+                _formatDate(item.date),
+                _formatDate(item.date),
+              ),
+            ),
+          // 관리 액션
+          ShadTableCell(
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                Tooltip(
+                  message: '이력 보기',
+                  child: ShadButton.ghost(
+                    size: ShadButtonSize.sm,
+                    onPressed: () => _showEquipmentHistoryDialog(item.equipment.id ?? 0),
+                    child: const Icon(Icons.history, size: 16),
+                  ),
+                ),
+                const SizedBox(width: 4),
+                Tooltip(
+                  message: '수정',
+                  child: ShadButton.ghost(
+                    size: ShadButtonSize.sm,
+                    onPressed: () => _handleEdit(item),
+                    child: const Icon(Icons.edit, size: 16),
+                  ),
+                ),
+                const SizedBox(width: 4),
+                Tooltip(
+                  message: '삭제',
+                  child: ShadButton.ghost(
+                    size: ShadButtonSize.sm,
+                    onPressed: () => _handleDelete(item),
+                    child: const Icon(Icons.delete_outline, size: 16),
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ];
+      }).toList(),
+    );
+  }
+
   /// 라우트에 따른 초기 필터 설정
   void _setInitialFilter() {
     switch (widget.currentRoute) {
@@ -173,32 +326,7 @@ class _EquipmentListState extends State<EquipmentList> {
   }
 
 
-  /// 전체 선택/해제
-  void _onSelectAll(bool? value) {
-    setState(() {
-      final equipments = _getFilteredEquipments();
-      _selectedItems.clear(); // UI 체크박스 상태 초기화
   
-      if (value == true) {
-        for (final equipment in equipments) {
-          if (equipment.equipment.id != null) {
-            _selectedItems.add(equipment.equipment.id!);
-            _controller.selectEquipment(equipment);
-          }
-        }
-      } else {
-        _controller.clearSelection();
-      }
-    });
-  }
-
-  /// 전체 선택 상태 확인
-  bool _isAllSelected() {
-    final equipments = _getFilteredEquipments();
-    if (equipments.isEmpty) return false;
-    return equipments.every((e) => 
-      _controller.selectedEquipmentIds.contains('${e.equipment.id}:${e.status}'));
-  }
 
 
   /// 필터링된 장비 목록 반환
@@ -986,339 +1114,11 @@ class _EquipmentListState extends State<EquipmentList> {
     return totalWidth;
   }
 
-  /// 헤더 셀 빌더
-  Widget _buildHeaderCell(
-    String text, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final child = Container(
-      alignment: Alignment.centerLeft,
-      child: Text(
-        text,
-        style: TextStyle(fontSize: 13, fontWeight: FontWeight.w500),
-      ),
-    );
   
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
-    }
-  }
 
-  /// 데이터 셀 빌더
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      child: child,
-    );
   
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
 
-  /// 유연한 테이블 빌더 - Virtual Scrolling 적용
-  Widget _buildFlexibleTable(List<UnifiedEquipment> pagedEquipments, {required bool useExpanded, required double availableWidth}) {
-    final hasOutOrRent = pagedEquipments.any((e) => 
-      e.status == EquipmentStatus.out || e.status == EquipmentStatus.rent
-    );
   
-    // 헤더를 별도로 빌드 - 반응형 컬럼 적용
-    Widget header = Container(
-      padding: const EdgeInsets.symmetric(
-        horizontal: ShadcnTheme.spacing1, // spacing2 -> spacing1로 더 축소
-        vertical: 6, // 8 -> 6으로 더 축소
-      ),
-      decoration: BoxDecoration(
-        color: ShadcnTheme.muted.withValues(alpha: 0.3),
-        border: Border(
-          bottom: BorderSide(color: Colors.black),
-        ),
-      ),
-      child: Row(
-        children: [
-          // 필수 컬럼들 (항상 표시) - 축소된 너비 적용
-          // 체크박스
-          _buildDataCell(
-            ShadCheckbox(
-              value: _isAllSelected(),
-              onChanged: (bool? value) => _onSelectAll(value),
-            ),
-            flex: 1,
-            useExpanded: useExpanded,
-            minWidth: 30,
-          ),
-          // 번호
-          _buildHeaderCell('번호', flex: 1, useExpanded: useExpanded, minWidth: 35),
-          // 회사명 (소유회사)
-          _buildHeaderCell('소유회사', flex: 2, useExpanded: useExpanded, minWidth: 70),
-          // 제조사
-          _buildHeaderCell('제조사', flex: 2, useExpanded: useExpanded, minWidth: 60),
-          // 모델명
-          _buildHeaderCell('모델명', flex: 3, useExpanded: useExpanded, minWidth: 80),
-          // 장비번호
-          _buildHeaderCell('장비번호', flex: 3, useExpanded: useExpanded, minWidth: 70),
-          // 상태
-          _buildHeaderCell('상태', flex: 2, useExpanded: useExpanded, minWidth: 50),
-          // 관리
-          _buildHeaderCell('관리', flex: 2, useExpanded: useExpanded, minWidth: 100),
-          
-          // 중간 화면용 컬럼들 (800px 이상)
-          if (availableWidth > 800) ...[
-            // 수량
-            _buildHeaderCell('수량', flex: 1, useExpanded: useExpanded, minWidth: 35),
-            // 입출고일
-            _buildHeaderCell('입출고일', flex: 2, useExpanded: useExpanded, minWidth: 70),
-          ],
-          
-          // 상세 컬럼들 (1200px 이상에서만 표시)
-          if (_showDetailedColumns && availableWidth > 1200) ...[
-            _buildHeaderCell('바코드', flex: 2, useExpanded: useExpanded, minWidth: 70),
-            _buildHeaderCell('구매가격', flex: 2, useExpanded: useExpanded, minWidth: 70),
-            _buildHeaderCell('구매일', flex: 2, useExpanded: useExpanded, minWidth: 70),
-            _buildHeaderCell('보증기간', flex: 2, useExpanded: useExpanded, minWidth: 80),
-          ],
-        ],
-      ),
-    );
-
-    // 빈 상태 처리
-    if (pagedEquipments.isEmpty) {
-      return Column(
-        children: [
-          header,
-          Expanded(
-            child: Center(
-              child: Text(
-                '데이터가 없습니다',
-                style: ShadcnTheme.bodyMedium,
-              ),
-            ),
-          ),
-        ],
-      );
-    }
-
-    // Virtual Scrolling을 위한 CustomScrollView 사용
-    return Column(
-      mainAxisSize: MainAxisSize.min,
-      children: [
-        header, // 헤더는 고정
-        Expanded(
-          child: ListView.builder(
-            controller: ScrollController(),
-            itemCount: pagedEquipments.length,
-            itemBuilder: (context, index) {
-              final UnifiedEquipment equipment = pagedEquipments[index];
-              
-              return Container(
-                padding: const EdgeInsets.symmetric(
-                  horizontal: ShadcnTheme.spacing1, // spacing2 -> spacing1로 더 축소
-                  vertical: 2, // 3 -> 2로 더 축소
-                ),
-                decoration: BoxDecoration(
-                  border: Border(
-                    bottom: BorderSide(color: Colors.black),
-                  ),
-                ),
-                child: Row(
-                  children: [
-                    // 필수 컬럼들 (항상 표시) - 축소된 너비 적용
-                    // 체크박스
-                    _buildDataCell(
-                      ShadCheckbox(
-                        value: _selectedItems.contains(equipment.equipment.id ?? 0),
-                        onChanged: (bool? value) {
-                          if (equipment.equipment.id != null) {
-                            _onItemSelected(equipment.equipment.id!, value ?? false);
-                          }
-                        },
-                      ),
-                      flex: 1,
-                      useExpanded: useExpanded,
-                      minWidth: 30,
-                    ),
-                    // 번호
-                    _buildDataCell(
-                      Text(
-                        '${((_controller.currentPage - 1) * _controller.pageSize) + index + 1}',
-                        style: ShadcnTheme.bodySmall,
-                      ),
-                      flex: 1,
-                      useExpanded: useExpanded,
-                      minWidth: 35,
-                    ),
-                    // 소유회사
-                    _buildDataCell(
-                      _buildTextWithTooltip(
-                        equipment.companyName ?? 'N/A',
-                        equipment.companyName ?? 'N/A',
-                      ),
-                      flex: 2,
-                      useExpanded: useExpanded,
-                      minWidth: 70,
-                    ),
-                    // 제조사
-                    _buildDataCell(
-                      _buildTextWithTooltip(
-                        equipment.vendorName ?? 'N/A',
-                        equipment.vendorName ?? 'N/A',
-                      ),
-                      flex: 2,
-                      useExpanded: useExpanded,
-                      minWidth: 60,
-                    ),
-                    // 모델명
-                    _buildDataCell(
-                      _buildTextWithTooltip(
-                        equipment.modelName ?? '-',
-                        equipment.modelName ?? '-',
-                      ),
-                      flex: 3,
-                      useExpanded: useExpanded,
-                      minWidth: 80,
-                    ),
-                    // 장비번호
-                    _buildDataCell(
-                      _buildTextWithTooltip(
-                        equipment.equipment.serialNumber ?? '',
-                        equipment.equipment.serialNumber ?? '',
-                      ),
-                      flex: 3,
-                      useExpanded: useExpanded,
-                      minWidth: 70,
-                    ),
-                    // 상태
-                    _buildDataCell(
-                      _buildStatusBadge(equipment.status),
-                      flex: 2,
-                      useExpanded: useExpanded,
-                      minWidth: 50,
-                    ),
-                    // 관리 (아이콘 전용 버튼으로 최적화)
-                    _buildDataCell(
-                      Row(
-                        mainAxisSize: MainAxisSize.min,
-                        children: [
-                          Tooltip(
-                            message: '이력 보기',
-                            child: ShadButton.ghost(
-                              size: ShadButtonSize.sm,
-                              onPressed: () => _showEquipmentHistoryDialog(equipment.equipment.id ?? 0),
-                              child: const Icon(Icons.history, size: 16),
-                            ),
-                          ),
-                          const SizedBox(width: 1),
-                          Tooltip(
-                            message: '수정',
-                            child: ShadButton.ghost(
-                              size: ShadButtonSize.sm,
-                              onPressed: () => _handleEdit(equipment),
-                              child: const Icon(Icons.edit, size: 16),
-                            ),
-                          ),
-                          const SizedBox(width: 1),
-                          Tooltip(
-                            message: '삭제',
-                            child: ShadButton.ghost(
-                              size: ShadButtonSize.sm,
-                              onPressed: () => _handleDelete(equipment),
-                              child: const Icon(Icons.delete_outline, size: 16),
-                            ),
-                          ),
-                        ],
-                      ),
-                      flex: 2,
-                      useExpanded: useExpanded,
-                      minWidth: 100,
-                    ),
-                    
-                    // 중간 화면용 컬럼들 (800px 이상)
-                    if (availableWidth > 800) ...[
-                      // 수량 (백엔드에서 관리하지 않으므로 고정값)
-                      _buildDataCell(
-                        Text(
-                          '1',
-                          style: ShadcnTheme.bodySmall,
-                        ),
-                        flex: 1,
-                        useExpanded: useExpanded,
-                        minWidth: 35,
-                      ),
-                      // 입출고일
-                      _buildDataCell(
-                        _buildTextWithTooltip(
-                          _formatDate(equipment.date),
-                          _formatDate(equipment.date),
-                        ),
-                        flex: 2,
-                        useExpanded: useExpanded,
-                        minWidth: 70,
-                      ),
-                    ],
-                    
-                    // 상세 컬럼들 (1200px 이상에서만 표시)
-                    if (_showDetailedColumns && availableWidth > 1200) ...[
-                      // 바코드
-                      _buildDataCell(
-                        _buildTextWithTooltip(
-                          equipment.equipment.barcode ?? '-',
-                          equipment.equipment.barcode ?? '-',
-                        ),
-                        flex: 2,
-                        useExpanded: useExpanded,
-                        minWidth: 70,
-                      ),
-                      // 구매가격
-                      _buildDataCell(
-                        _buildTextWithTooltip(
-                          _formatPrice(equipment.equipment.purchasePrice),
-                          _formatPrice(equipment.equipment.purchasePrice),
-                        ),
-                        flex: 2,
-                        useExpanded: useExpanded,
-                        minWidth: 70,
-                      ),
-                      // 구매일
-                      _buildDataCell(
-                        _buildTextWithTooltip(
-                          _formatDate(equipment.equipment.purchaseDate),
-                          _formatDate(equipment.equipment.purchaseDate),
-                        ),
-                        flex: 2,
-                        useExpanded: useExpanded,
-                        minWidth: 70,
-                      ),
-                      // 보증기간
-                      _buildDataCell(
-                        _buildTextWithTooltip(
-                          _formatWarrantyPeriod(equipment.equipment.warrantyStartDate, equipment.equipment.warrantyEndDate),
-                          _formatWarrantyPeriod(equipment.equipment.warrantyStartDate, equipment.equipment.warrantyEndDate),
-                        ),
-                        flex: 2,
-                        useExpanded: useExpanded,
-                        minWidth: 80,
-                      ),
-                    ],
-                  ],
-                ),
-              );
-            },
-          ),
-        ),
-      ],
-    );
-  }
 
   /// 데이터 테이블
   Widget _buildDataTable(List<UnifiedEquipment> filteredEquipments) {
@@ -1367,19 +1167,18 @@ class _EquipmentListState extends State<EquipmentList> {
           final minimumWidth = _getMinimumTableWidth(pagedEquipments, availableWidth);
           final needsHorizontalScroll = minimumWidth > availableWidth;
 
+          // ShadTable 경로로 일괄 전환 (가로 스크롤은 ShadTable 외부에서 처리)
           if (needsHorizontalScroll) {
-            // 최소 너비보다 작을 때만 스크롤 활성화
             return SingleChildScrollView(
               scrollDirection: Axis.horizontal,
               controller: _horizontalScrollController,
               child: SizedBox(
                 width: minimumWidth,
-                child: _buildFlexibleTable(pagedEquipments, useExpanded: false, availableWidth: availableWidth),
+                child: _buildShadTable(pagedEquipments, availableWidth: availableWidth),
               ),
             );
           } else {
-            // 충분한 공간이 있을 때는 Expanded 사용
+            return _buildShadTable(pagedEquipments, availableWidth: availableWidth);
-            return _buildFlexibleTable(pagedEquipments, useExpanded: true, availableWidth: availableWidth);
           }
         },
       ),
@@ -1399,10 +1198,7 @@ class _EquipmentListState extends State<EquipmentList> {
   }
 
   /// 가격 포맷팅
-  String _formatPrice(double? price) {
+  
-    if (price == null) return '-';
-    return '${(price / 10000).toStringAsFixed(0)}만원';
-  }
 
   /// 날짜 포맷팅
   String _formatDate(DateTime? date) {
@@ -1411,75 +1207,8 @@ class _EquipmentListState extends State<EquipmentList> {
   }
 
   /// 보증기간 포맷팅
-  String _formatWarrantyPeriod(DateTime? startDate, DateTime? endDate) {
-    if (startDate == null || endDate == null) return '-';
   
-    final now = DateTime.now();
-    final isExpired = now.isAfter(endDate);
-    final remainingDays = isExpired ? 0 : endDate.difference(now).inDays;
 
-    if (isExpired) {
-      return '만료됨';
-    } else if (remainingDays <= 30) {
-      return '$remainingDays일 남음';
-    } else {
-      return _formatDate(endDate);
-    }
-  }
-
-  /// 재고 상태 위젯 빌더 (백엔드 기반 단순화)
-  Widget _buildInventoryStatus(UnifiedEquipment equipment) {
-    // 백엔드 Equipment_History 기반으로 단순 상태만 표시
-    Widget stockInfo;
-    if (equipment.status == 'I') {
-      // 입고 상태: 재고 있음
-      stockInfo = Row(
-        mainAxisSize: MainAxisSize.min,
-        children: [
-          Icon(Icons.check_circle, color: Colors.green, size: 16),
-          const SizedBox(width: 4),
-          Text(
-            '보유중',
-            style: ShadcnTheme.bodySmall.copyWith(color: Colors.green[700]),
-          ),
-        ],
-      );
-    } else if (equipment.status == 'O') {
-      // 출고 상태: 재고 없음
-      stockInfo = Row(
-        mainAxisSize: MainAxisSize.min,
-        children: [
-          Icon(Icons.warning, color: Colors.orange, size: 16),
-          const SizedBox(width: 4),
-          Text(
-            '출고됨',
-            style: ShadcnTheme.bodySmall.copyWith(color: Colors.orange[700]),
-          ),
-        ],
-      );
-    } else if (equipment.status == 'T') {
-      // 대여 상태
-      stockInfo = Row(
-        mainAxisSize: MainAxisSize.min,
-        children: [
-          Icon(Icons.schedule, color: Colors.blue, size: 16),
-          const SizedBox(width: 4),
-          Text(
-            '대여중',
-            style: ShadcnTheme.bodySmall.copyWith(color: Colors.blue[700]),
-          ),
-        ],
-      );
-    } else {
-      // 기타 상태
-      stockInfo = Text(
-        '-',
-        style: ShadcnTheme.bodySmall,
-      );
-    }
-    
-    return stockInfo;
-  }
 
   /// 상태 배지 빌더
   Widget _buildStatusBadge(String status) {
@@ -1528,51 +1257,8 @@ class _EquipmentListState extends State<EquipmentList> {
     );
   }
 
-  /// 입출고일 위젯 빌더
-  Widget _buildCreatedDateWidget(UnifiedEquipment equipment) {
-    String dateStr = equipment.date.toString().substring(0, 10);
-    return Text(
-      dateStr,
-      style: ShadcnTheme.bodySmall,
-    );
-  }
 
 
-  /// 액션 버튼 빌더
-  Widget _buildActionButtons(int equipmentId) {
-    return Row(
-      mainAxisSize: MainAxisSize.min,
-      children: [
-        // 이력 버튼 - 텍스트 + 아이콘으로 강화
-        ShadButton.outline(
-          size: ShadButtonSize.sm,
-          onPressed: () => _showEquipmentHistoryDialog(equipmentId),
-          child: Row(
-            mainAxisSize: MainAxisSize.min,
-            children: const [
-              Icon(Icons.history, size: 14),
-              SizedBox(width: 4),
-              Text('이력', style: TextStyle(fontSize: 12)),
-            ],
-          ),
-        ),
-        const SizedBox(width: 4),
-        // 편집 버튼
-        ShadButton.outline(
-          size: ShadButtonSize.sm,
-          onPressed: () => _handleEditById(equipmentId),
-          child: const Icon(Icons.edit_outlined, size: 14),
-        ),
-        const SizedBox(width: 4),
-        // 삭제 버튼
-        ShadButton.outline(
-          size: ShadButtonSize.sm,
-          onPressed: () => _handleDeleteById(equipmentId),
-          child: const Icon(Icons.delete_outline, size: 14),
-        ),
-      ],
-    );
-  }
 
   // 장비 이력 다이얼로그 표시
   void _showEquipmentHistoryDialog(int equipmentId) async {
@@ -1596,43 +1282,10 @@ class _EquipmentListState extends State<EquipmentList> {
 
 
   // 편집 핸들러 (액션 버튼에서 호출) - 장비 ID로 처리
-  void _handleEditById(int equipmentId) {
-    // 해당 장비 찾기
-    final equipment = _controller.equipments.firstWhere(
-      (e) => e.equipment.id == equipmentId,
-      orElse: () => throw Exception('Equipment not found'),
-    );
-    _handleEdit(equipment);
-  }
 
-  // 삭제 핸들러 (액션 버튼에서 호출) - 장비 ID로 처리
-  void _handleDeleteById(int equipmentId) {
-    // 해당 장비 찾기
-    final equipment = _controller.equipments.firstWhere(
-      (e) => e.equipment.id == equipmentId,
-      orElse: () => throw Exception('Equipment not found'),
-    );
-    _handleDelete(equipment);
-  }
 
   /// 체크박스 선택 관련 함수들
-  void _onItemSelected(int id, bool selected) {
-    // 해당 장비 찾기
-    final equipment = _controller.equipments.firstWhere(
-      (e) => e.equipment.id == id,
-      orElse: () => throw Exception('Equipment not found'),
-    );
   
-    setState(() {
-      if (selected) {
-        _selectedItems.add(id);
-        _controller.selectEquipment(equipment); // Controller에도 전달
-      } else {
-        _selectedItems.remove(id);
-        _controller.toggleSelection(equipment); // 선택 해제
-      }
-    });
-  }
 
 
   // 사용하지 않는 카테고리 관련 함수들 제거됨 (리스트 API에서 제공하지 않음)

lib/screens/inventory/inventory_history_screen.dart

@@ -75,180 +75,8 @@ class _InventoryHistoryScreenState extends State<InventoryHistoryScreen> {
     );
   }
 
-  /// 헤더 셀 빌더
+  // (Deprecated) 기존 커스텀 테이블 빌더 유틸들은 ShadTable 전환으로 제거되었습니다.
-  Widget _buildHeaderCell(
-    String text, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final child = Container(
-      alignment: Alignment.centerLeft,
-      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 12),
-      child: Text(
-        text,
-        style: const TextStyle(
-          fontSize: 14, 
-          fontWeight: FontWeight.w600,
-          color: Colors.black87,
-        ),
-      ),
-    );
 
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
-    }
-  }
-
-  /// 데이터 셀 빌더
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 10),
-      child: child,
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
-
-  /// 헤더 셀 리스트 (요구사항에 맞게 재정의)
-  List<Widget> _buildHeaderCells() {
-    return [
-      _buildHeaderCell('장비명', flex: 3, useExpanded: true, minWidth: 150),
-      _buildHeaderCell('시리얼번호', flex: 2, useExpanded: true, minWidth: 120),
-      _buildHeaderCell('위치', flex: 2, useExpanded: true, minWidth: 120),
-      _buildHeaderCell('변동일', flex: 1, useExpanded: false, minWidth: 100),
-      _buildHeaderCell('작업', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('비고', flex: 2, useExpanded: true, minWidth: 120),
-    ];
-  }
-
-  /// 테이블 행 빌더 (요구사항에 맞게 재정의)
-  Widget _buildTableRow(InventoryHistoryViewModel history, int index) {
-    return Container(
-      decoration: BoxDecoration(
-        color: index.isEven ? ShadcnTheme.muted.withValues(alpha: 0.1) : null,
-        border: const Border(
-          bottom: BorderSide(color: Colors.black12, width: 1),
-        ),
-      ),
-      child: Row(
-        children: [
-          // 장비명
-          _buildDataCell(
-            Tooltip(
-              message: history.equipmentName,
-              child: Text(
-                history.equipmentName,
-                style: ShadcnTheme.bodyMedium.copyWith(
-                  fontWeight: FontWeight.w500,
-                ),
-                overflow: TextOverflow.ellipsis,
-              ),
-            ),
-            flex: 3,
-            useExpanded: true,
-            minWidth: 150,
-          ),
-          // 시리얼번호
-          _buildDataCell(
-            Tooltip(
-              message: history.serialNumber,
-              child: Text(
-                history.serialNumber,
-                style: ShadcnTheme.bodySmall,
-                overflow: TextOverflow.ellipsis,
-              ),
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 120,
-          ),
-          // 위치 (출고/대여: 고객사, 입고/폐기: 창고)
-          _buildDataCell(
-            Tooltip(
-              message: history.location,
-              child: Row(
-                children: [
-                  Icon(
-                    history.isCustomerLocation ? Icons.business : Icons.warehouse,
-                    size: 14,
-                    color: history.isCustomerLocation ? Colors.blue : Colors.green,
-                  ),
-                  const SizedBox(width: 4),
-                  Expanded(
-                    child: Text(
-                      history.location,
-                      style: ShadcnTheme.bodySmall,
-                      overflow: TextOverflow.ellipsis,
-                    ),
-                  ),
-                ],
-              ),
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 120,
-          ),
-          // 변동일
-          _buildDataCell(
-            Text(
-              history.formattedDate,
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 1,
-            useExpanded: false,
-            minWidth: 100,
-          ),
-          // 작업 (상세보기만)
-          _buildDataCell(
-            ShadButton.outline(
-              size: ShadButtonSize.sm,
-              onPressed: () => _showEquipmentHistoryDetail(history),
-              child: const Row(
-                mainAxisSize: MainAxisSize.min,
-                children: [
-                  Icon(Icons.history, size: 14),
-                  SizedBox(width: 4),
-                  Text('상세보기', style: TextStyle(fontSize: 12)),
-                ],
-              ),
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          // 비고
-          _buildDataCell(
-            Tooltip(
-              message: history.remark ?? '비고 없음',
-              child: Text(
-                history.remark ?? '-',
-                style: ShadcnTheme.bodySmall.copyWith(
-                  color: ShadcnTheme.mutedForeground,
-                ),
-                overflow: TextOverflow.ellipsis,
-              ),
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 120,
-          ),
-        ],
-      ),
-    );
-  }
 
   /// 장비 이력 상세보기 다이얼로그 표시
   void _showEquipmentHistoryDetail(InventoryHistoryViewModel history) async {
@@ -304,17 +132,104 @@ class _InventoryHistoryScreenState extends State<InventoryHistoryScreen> {
           height: 40,
           width: 120,
           child: ShadSelect<String>(
-            selectedOptionBuilder: (context, value) => Text(
+            selectedOptionBuilder: (context, value) => Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                if (value != 'all') ...[
+                  Container(
+                    width: 8,
+                    height: 8,
+                    decoration: BoxDecoration(
+                      color: _getTransactionTypeColor(value),
+                      shape: BoxShape.circle,
+                    ),
+                  ),
+                  const SizedBox(width: 6),
+                ],
+                Text(
                   _getTransactionTypeDisplayText(value),
                   style: const TextStyle(fontSize: 14),
                 ),
+              ],
+            ),
             placeholder: const Text('거래 유형'),
             options: [
-              const ShadOption(value: 'all', child: Text('전체')),
+              const ShadOption(
-              const ShadOption(value: 'I', child: Text('입고')),
+                value: 'all', 
-              const ShadOption(value: 'O', child: Text('출고')),
+                child: Text('전체'),
-              const ShadOption(value: 'R', child: Text('대여')),
+              ),
-              const ShadOption(value: 'D', child: Text('폐기')),
+              ShadOption(
+                value: 'I', 
+                child: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Container(
+                      width: 8,
+                      height: 8,
+                      decoration: BoxDecoration(
+                        color: ShadcnTheme.equipmentIn,
+                        shape: BoxShape.circle,
+                      ),
+                    ),
+                    const SizedBox(width: 6),
+                    const Text('입고'),
+                  ],
+                ),
+              ),
+              ShadOption(
+                value: 'O',
+                child: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Container(
+                      width: 8,
+                      height: 8,
+                      decoration: BoxDecoration(
+                        color: ShadcnTheme.equipmentOut,
+                        shape: BoxShape.circle,
+                      ),
+                    ),
+                    const SizedBox(width: 6),
+                    const Text('출고'),
+                  ],
+                ),
+              ),
+              ShadOption(
+                value: 'R',
+                child: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Container(
+                      width: 8,
+                      height: 8,
+                      decoration: BoxDecoration(
+                        color: ShadcnTheme.equipmentRent,
+                        shape: BoxShape.circle,
+                      ),
+                    ),
+                    const SizedBox(width: 6),
+                    const Text('대여'),
+                  ],
+                ),
+              ),
+              ShadOption(
+                value: 'D',
+                child: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Container(
+                      width: 8,
+                      height: 8,
+                      decoration: BoxDecoration(
+                        color: ShadcnTheme.equipmentDisposal,
+                        shape: BoxShape.circle,
+                      ),
+                    ),
+                    const SizedBox(width: 6),
+                    const Text('폐기'),
+                  ],
+                ),
+              ),
             ],
             onChanged: (value) {
               if (value != null) {
@@ -407,7 +322,7 @@ class _InventoryHistoryScreenState extends State<InventoryHistoryScreen> {
           ],
           totalCount: stats['total'],
           statusMessage: controller.hasActiveFilters 
-              ? '${controller.filterStatusText}'
+              ? controller.filterStatusText
               : '장비 입출고 이력을 조회합니다',
         );
       },
@@ -432,7 +347,23 @@ class _InventoryHistoryScreenState extends State<InventoryHistoryScreen> {
     }
   }
 
-  /// 데이터 테이블 빌더
+  /// 거래 유형별 Phase 10 색상 반환
+  Color _getTransactionTypeColor(String type) {
+    switch (type) {
+      case 'I':
+        return ShadcnTheme.equipmentIn; // 입고 - 그린
+      case 'O':
+        return ShadcnTheme.equipmentOut; // 출고 - 블루
+      case 'R':
+        return ShadcnTheme.equipmentRent; // 대여 - 퍼플
+      case 'D':
+        return ShadcnTheme.equipmentDisposal; // 폐기 - 그레이
+      default:
+        return ShadcnTheme.foregroundMuted; // 기본/전체
+    }
+  }
+
+  /// 데이터 테이블 빌더 (ShadTable)
   Widget _buildDataTable(List<InventoryHistoryViewModel> historyList) {
     if (historyList.isEmpty) {
       return Center(
@@ -471,31 +402,66 @@ class _InventoryHistoryScreenState extends State<InventoryHistoryScreen> {
         border: Border.all(color: ShadcnTheme.border),
         borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
       ),
-      child: Column(
+      child: Padding(
-        mainAxisSize: MainAxisSize.min,
+        padding: const EdgeInsets.all(12.0),
-        children: [
+        child: ShadTable.list(
-          // 고정 헤더
+          header: const [
-          Container(
+            ShadTableCell.header(child: Text('장비명')),
-            decoration: BoxDecoration(
+            ShadTableCell.header(child: Text('시리얼번호')),
-              color: ShadcnTheme.muted.withValues(alpha: 0.3),
+            ShadTableCell.header(child: Text('위치')),
-              border: const Border(
+            ShadTableCell.header(child: Text('변동일')),
-                bottom: BorderSide(color: Colors.black12),
+            ShadTableCell.header(child: Text('작업')),
-              ),
+            ShadTableCell.header(child: Text('비고')),
-              borderRadius: const BorderRadius.only(
-                topLeft: Radius.circular(8),
-                topRight: Radius.circular(8),
-              ),
-            ),
-            child: Row(children: _buildHeaderCells()),
-          ),
-          // 스크롤 바디
-          Expanded(
-            child: ListView.builder(
-              itemCount: historyList.length,
-              itemBuilder: (context, index) => _buildTableRow(historyList[index], index),
-            ),
-          ),
           ],
+          children: historyList.map((history) {
+            return [
+              // 장비명
+              ShadTableCell(
+                child: Tooltip(
+                  message: history.equipmentName,
+                  child: Text(history.equipmentName, overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500)),
+                ),
+              ),
+              // 시리얼번호
+              ShadTableCell(
+                child: Tooltip(
+                  message: history.serialNumber,
+                  child: Text(history.serialNumber, overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodySmall),
+                ),
+              ),
+              // 위치
+              ShadTableCell(
+                child: Row(
+                  children: [
+                    Icon(history.isCustomerLocation ? Icons.business : Icons.warehouse, size: 14, color: history.isCustomerLocation ? ShadcnTheme.companyCustomer : ShadcnTheme.equipmentIn),
+                    const SizedBox(width: 6),
+                    Expanded(child: Text(history.location, overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodySmall)),
+                  ],
+                ),
+              ),
+              // 변동일
+              ShadTableCell(child: Text(history.formattedDate, style: ShadcnTheme.bodySmall)),
+              // 작업
+              ShadTableCell(
+                child: ShadButton.outline(
+                  size: ShadButtonSize.sm,
+                  onPressed: () => _showEquipmentHistoryDetail(history),
+                  child: const Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [Icon(Icons.history, size: 14), SizedBox(width: 4), Text('상세보기', style: TextStyle(fontSize: 12))],
+                  ),
+                ),
+              ),
+              // 비고
+              ShadTableCell(
+                child: Tooltip(
+                  message: history.remark ?? '비고 없음',
+                  child: Text(history.remark ?? '-', overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodySmall.copyWith(color: ShadcnTheme.mutedForeground)),
+                ),
+              ),
+            ];
+          }).toList(),
+        ),
       ),
     );
   }

lib/screens/maintenance/maintenance_alert_dashboard.dart

@@ -192,25 +192,26 @@ class _MaintenanceAlertDashboardState extends State<MaintenanceAlertDashboard> {
     Color color;
     IconData icon;
     
+    // Phase 10: 색체심리학 기반 알림 색상 체계 적용
     switch (type) {
       case 'expiring_7':
-        color = Colors.red.shade600;
+        color = ShadcnTheme.alertCritical7; // 7일 이내 - 위험 (레드)
         icon = Icons.priority_high_outlined;
         break;
       case 'expiring_30':
-        color = Colors.orange.shade600;
+        color = ShadcnTheme.alertWarning30; // 30일 이내 - 경고 (오렌지)
         icon = Icons.warning_amber_outlined;
         break;
       case 'expiring_60':
-        color = Colors.amber.shade600;
+        color = ShadcnTheme.alertWarning60; // 60일 이내 - 주의 (앰버)
         icon = Icons.schedule_outlined;
         break;
       case 'expired':
-        color = Colors.red.shade800;
+        color = ShadcnTheme.alertExpired; // 만료됨 - 심각 (진한 레드)
         icon = Icons.error_outline;
         break;
       default:
-        color = Colors.grey.shade600;
+        color = ShadcnTheme.alertNormal; // 정상 - 안전 (그린)
         icon = Icons.info_outline;
     }
 
@@ -449,13 +450,14 @@ class _MaintenanceAlertDashboardState extends State<MaintenanceAlertDashboard> {
           ),
         ),
         
-        // 고객사
+        // 고객사 - Phase 10: 회사 타입별 색상 적용
         Padding(
           padding: const EdgeInsets.symmetric(vertical: 12, horizontal: 8),
           child: Text(
             controller.getCompanyName(maintenance),
             style: ShadcnTheme.bodySmall.copyWith(
-              color: ShadcnTheme.foreground,
+              color: ShadcnTheme.companyCustomer, // 고객사 - 진한 그린
+              fontWeight: FontWeight.w500,
             ),
             maxLines: 1,
             overflow: TextOverflow.ellipsis,
@@ -468,12 +470,13 @@ class _MaintenanceAlertDashboardState extends State<MaintenanceAlertDashboard> {
           child: Text(
             '${maintenance.endedAt.year}-${maintenance.endedAt.month.toString().padLeft(2, '0')}-${maintenance.endedAt.day.toString().padLeft(2, '0')}',
             style: ShadcnTheme.bodySmall.copyWith(
+              // Phase 10: 만료 상태별 색상 체계 적용
               color: isExpired 
-                  ? Colors.red.shade600 
+                  ? ShadcnTheme.alertExpired // 만료됨 - 심각 (진한 레드)
                   : isExpiringSoon 
-                      ? Colors.orange.shade600 
+                      ? ShadcnTheme.alertWarning30 // 만료 임박 - 경고 (오렌지)
-                      : ShadcnTheme.foreground,
+                      : ShadcnTheme.alertNormal, // 정상 - 안전 (그린)
-              fontWeight: isExpired || isExpiringSoon ? FontWeight.w600 : FontWeight.normal,
+              fontWeight: isExpired || isExpiringSoon ? FontWeight.w600 : FontWeight.w500,
             ),
           ),
         ),
@@ -506,11 +509,12 @@ class _MaintenanceAlertDashboardState extends State<MaintenanceAlertDashboard> {
                 ? '${daysRemaining.abs()}일 지연'
                 : '$daysRemaining일 남음',
             style: ShadcnTheme.bodySmall.copyWith(
+              // Phase 10: 남은 일수 상태별 색상 체계 적용
               color: isExpired 
-                  ? Colors.red.shade600 
+                  ? ShadcnTheme.alertExpired // 지연 - 심각 (진한 레드)
                   : isExpiringSoon 
-                      ? Colors.orange.shade600 
+                      ? ShadcnTheme.alertWarning30 // 임박 - 경고 (오렌지)
-                      : Colors.green.shade600,
+                      : ShadcnTheme.alertNormal, // 충분 - 안전 (그린)
               fontWeight: FontWeight.w600,
             ),
           ),
@@ -543,14 +547,15 @@ class _MaintenanceAlertDashboardState extends State<MaintenanceAlertDashboard> {
   }
 
   /// 유지보수 타입별 색상
+  // Phase 10: 유지보수 타입별 색상 체계
   Color _getMaintenanceTypeColor(String maintenanceType) {
     switch (maintenanceType) {
-      case 'V': // 방문
+      case 'V': // 방문 - 본사/지점 계열 (블루)
-        return Colors.blue.shade600;
+        return ShadcnTheme.companyHeadquarters;
-      case 'R': // 원격
+      case 'R': // 원격 - 협력/성장 계열 (그린)
-        return Colors.green.shade600;
+        return ShadcnTheme.companyPartner;
       default:
-        return Colors.grey.shade600;
+        return ShadcnTheme.muted;
     }
   }
 

lib/screens/maintenance/maintenance_list.dart

@@ -70,13 +70,26 @@ class _MaintenanceListState extends State<MaintenanceList> {
       value: _controller,
       child: Scaffold(
         backgroundColor: ShadcnTheme.background,
-        body: Column(
+        body: Consumer<MaintenanceController>(
+          builder: (context, controller, child) {
+            return Column(
               children: [
                 _buildActionBar(),
                 _buildFilterBar(),
                 Expanded(child: _buildMainContent()),
-            _buildBottomBar(),
+                Container(
+                  padding: const EdgeInsets.all(ShadcnTheme.spacing4),
+                  decoration: BoxDecoration(
+                    color: ShadcnTheme.card,
+                    border: Border(
+                      top: BorderSide(color: ShadcnTheme.border),
+                    ),
+                  ),
+                  child: _buildPagination(controller),
+                ),
               ],
+            );
+          },
         ),
       ),
     );
@@ -260,47 +273,124 @@ class _MaintenanceListState extends State<MaintenanceList> {
 
   /// 데이터 테이블
   Widget _buildDataTable(MaintenanceController controller) {
-    return SingleChildScrollView(
+    final maintenances = controller.maintenances;
+
+    if (maintenances.isEmpty) {
+      return const StandardEmptyState(
+        icon: Icons.build_circle_outlined,
+        title: '유지보수가 없습니다',
+        message: '새로운 유지보수를 등록해보세요.',
+      );
+    }
+
+    return Container(
+      decoration: BoxDecoration(
+        border: Border.all(color: ShadcnTheme.border),
+        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
+      ),
+      child: Column(
+        children: [
+          // 고정 헤더
+          Container(
+            padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing4, vertical: ShadcnTheme.spacing3),
+            decoration: BoxDecoration(
+              color: ShadcnTheme.muted.withValues(alpha: 0.3),
+              border: Border(bottom: BorderSide(color: ShadcnTheme.border)),
+              borderRadius: BorderRadius.only(
+                topLeft: Radius.circular(ShadcnTheme.radiusMd),
+                topRight: Radius.circular(ShadcnTheme.radiusMd),
+              ),
+            ),
+            child: SingleChildScrollView(
               scrollDirection: Axis.horizontal,
               controller: _horizontalScrollController,
-      child: DataTable(
+              child: _buildFixedHeader(),
-        columns: _buildHeaders(),
+            ),
-        rows: _buildRows(controller.maintenances),
+          ),
+
+          // 스크롤 가능한 바디
+          Expanded(
+            child: SingleChildScrollView(
+              scrollDirection: Axis.horizontal,
+              controller: _horizontalScrollController,
+              child: SizedBox(
+                width: _calculateTableWidth(),
+                child: ListView.builder(
+                  itemCount: maintenances.length,
+                  itemBuilder: (context, index) => _buildTableRow(maintenances[index], index),
+                ),
+              ),
+            ),
+          ),
+        ],
       ),
     );
   }
 
-  /// 테이블 헤더
+  /// 고정 헤더 빌드
-  List<DataColumn> _buildHeaders() {
+  Widget _buildFixedHeader() {
-    return [
+    return SizedBox(
-      const DataColumn(label: Text('선택')),
+      width: _calculateTableWidth(),
-      const DataColumn(label: Text('ID')),
+      child: Row(
-      const DataColumn(label: Text('장비 정보')),
+        children: [
-      const DataColumn(label: Text('유지보수 타입')),
+          _buildHeaderCell('선택', 60),
-      const DataColumn(label: Text('시작일')),
+          _buildHeaderCell('ID', 80),
-      const DataColumn(label: Text('종료일')),
+          _buildHeaderCell('장비 정보', 200),
+          _buildHeaderCell('유지보수 타입', 120),
+          _buildHeaderCell('시작일', 100),
+          _buildHeaderCell('종료일', 100),
           if (_showDetailedColumns) ...[
-        const DataColumn(label: Text('주기')),
+            _buildHeaderCell('주기', 80),
-        const DataColumn(label: Text('상태')),
+            _buildHeaderCell('상태', 100),
-        const DataColumn(label: Text('남은 일수')),
+            _buildHeaderCell('남은 일수', 100),
           ],
-      const DataColumn(label: Text('작업')),
+          _buildHeaderCell('작업', 120),
-    ];
+        ],
+      ),
+    );
   }
 
-  /// 테이블 로우
+  /// 테이블 총 너비 계산
-  List<DataRow> _buildRows(List<MaintenanceDto> maintenances) {
+  double _calculateTableWidth() {
-    return maintenances.map((maintenance) {
+    double width = 60 + 80 + 200 + 120 + 100 + 100 + 120; // 기본 컬럼들
-      final isSelected = _selectedItems.contains(maintenance.id);
+    if (_showDetailedColumns) {
+      width += 80 + 100 + 100; // 상세 컬럼들
+    }
+    return width;
+  }
 
-      return DataRow(
+  /// 헤더 셀 빌드
-        selected: isSelected,
+  Widget _buildHeaderCell(String text, double width) {
-        onSelectChanged: (_) => _showMaintenanceDetail(maintenance),
+    return Container(
-        cells: [
+      width: width,
+      padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing2),
+      child: Text(
+        text,
+        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
+      ),
+    );
+  }
+
+  /// 테이블 행 빌드
+  Widget _buildTableRow(MaintenanceDto maintenance, int index) {
+    return Container(
+      decoration: BoxDecoration(
+        color: index.isEven ? ShadcnTheme.muted.withValues(alpha: 0.1) : null,
+        border: Border(bottom: BorderSide(color: ShadcnTheme.border.withValues(alpha: 0.3))),
+      ),
+      child: Material(
+        color: Colors.transparent,
+        child: InkWell(
+          onTap: () => _showMaintenanceDetail(maintenance),
+          child: Container(
+            padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing4, vertical: ShadcnTheme.spacing3),
+            child: Row(
+              children: [
                 // 선택 체크박스
-          DataCell(
+                SizedBox(
-            Checkbox(
+                  width: 60,
-              value: isSelected,
+                  child: ShadCheckbox(
+                    value: _selectedItems.contains(maintenance.id),
                     onChanged: (value) {
                       setState(() {
                         if (value == true) {
@@ -314,37 +404,47 @@ class _MaintenanceListState extends State<MaintenanceList> {
                 ),
 
                 // ID
-          DataCell(Text(maintenance.id?.toString() ?? '-')),
+                SizedBox(
+                  width: 80,
+                  child: Text(
+                    maintenance.id?.toString() ?? '-',
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
 
                 // 장비 정보
-          DataCell(
+                SizedBox(
-            Column(
+                  width: 200,
+                  child: Column(
                     crossAxisAlignment: CrossAxisAlignment.start,
                     mainAxisSize: MainAxisSize.min,
                     children: [
                       Text(
                         maintenance.equipmentSerial ?? '시리얼 번호 없음',
                         style: const TextStyle(fontWeight: FontWeight.w500),
+                        overflow: TextOverflow.ellipsis,
                       ),
                       if (maintenance.equipmentModel != null)
                         Text(
                           maintenance.equipmentModel!,
                           style: TextStyle(
                             fontSize: 12,
-                      color: Colors.grey[600],
+                            color: ShadcnTheme.mutedForeground,
                           ),
+                          overflow: TextOverflow.ellipsis,
                         ),
                     ],
                   ),
                 ),
 
                 // 유지보수 타입
-          DataCell(
+                SizedBox(
-            Container(
+                  width: 120,
-              padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+                  child: Container(
+                    padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing2, vertical: ShadcnTheme.spacing1),
                     decoration: BoxDecoration(
                       color: _getMaintenanceTypeColor(maintenance.maintenanceType),
-                borderRadius: BorderRadius.circular(4),
+                      borderRadius: BorderRadius.circular(ShadcnTheme.radiusSm),
                     ),
                     child: Text(
                       MaintenanceType.getDisplayName(maintenance.maintenanceType),
@@ -353,28 +453,48 @@ class _MaintenanceListState extends State<MaintenanceList> {
                         color: Colors.white,
                         fontWeight: FontWeight.w500,
                       ),
+                      overflow: TextOverflow.ellipsis,
                     ),
                   ),
                 ),
 
                 // 시작일
-          DataCell(Text(DateFormat('yyyy-MM-dd').format(maintenance.startedAt))),
+                SizedBox(
+                  width: 100,
+                  child: Text(
+                    DateFormat('yyyy-MM-dd').format(maintenance.startedAt),
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
 
                 // 종료일
-          DataCell(Text(DateFormat('yyyy-MM-dd').format(maintenance.endedAt))),
+                SizedBox(
+                  width: 100,
+                  child: Text(
+                    DateFormat('yyyy-MM-dd').format(maintenance.endedAt),
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
 
                 // 상세 컬럼들
                 if (_showDetailedColumns) ...[
                   // 주기
-            DataCell(Text('${maintenance.periodMonth}개월')),
+                  SizedBox(
+                    width: 80,
+                    child: Text(
+                      '${maintenance.periodMonth}개월',
+                      style: ShadcnTheme.bodySmall,
+                    ),
+                  ),
 
                   // 상태
-            DataCell(
+                  SizedBox(
-              Container(
+                    width: 100,
-                padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+                    child: Container(
+                      padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing2, vertical: ShadcnTheme.spacing1),
                       decoration: BoxDecoration(
                         color: _controller.getMaintenanceStatusColor(maintenance),
-                  borderRadius: BorderRadius.circular(4),
+                        borderRadius: BorderRadius.circular(ShadcnTheme.radiusSm),
                       ),
                       child: Text(
                         _controller.getMaintenanceStatusText(maintenance),
@@ -383,41 +503,44 @@ class _MaintenanceListState extends State<MaintenanceList> {
                           color: Colors.white,
                           fontWeight: FontWeight.w500,
                         ),
+                        overflow: TextOverflow.ellipsis,
                       ),
                     ),
                   ),
 
                   // 남은 일수
-            DataCell(
+                  SizedBox(
-              Text(
+                    width: 100,
+                    child: Text(
                       maintenance.daysRemaining != null
                           ? '${maintenance.daysRemaining}일'
                           : '-',
                       style: TextStyle(
                         color: maintenance.daysRemaining != null &&
                                maintenance.daysRemaining! <= 30
-                      ? Colors.red
+                            ? ShadcnTheme.destructive
-                      : null,
+                            : ShadcnTheme.foreground,
                       ),
                     ),
                   ),
                 ],
 
                 // 작업 버튼들
-          DataCell(
+                SizedBox(
-            Row(
+                  width: 120,
+                  child: Row(
                     mainAxisSize: MainAxisSize.min,
                     children: [
                       ShadButton.ghost(
                         child: const Icon(Icons.edit, size: 16),
                         onPressed: () => _showMaintenanceForm(maintenance: maintenance),
                       ),
-                const SizedBox(width: 4),
+                      const SizedBox(width: ShadcnTheme.spacing1),
                       ShadButton.ghost(
                         child: Icon(
                           Icons.delete,
                           size: 16,
-                    color: Colors.red[400],
+                          color: ShadcnTheme.destructive,
                         ),
                         onPressed: () => _deleteMaintenance(maintenance),
                       ),
@@ -425,44 +548,24 @@ class _MaintenanceListState extends State<MaintenanceList> {
                   ),
                 ),
               ],
+            ),
+          ),
+        ),
+      ),
     );
-    }).toList();
   }
 
-  /// 하단바 (페이지네이션)
+  /// 하단 페이지네이션
-  Widget _buildBottomBar() {
+  Widget _buildPagination(MaintenanceController controller) {
-    return Consumer<MaintenanceController>(
+    return Pagination(
-      builder: (context, controller, child) {
-        return Container(
-          padding: const EdgeInsets.all(16),
-          decoration: BoxDecoration(
-            color: ShadcnTheme.card,
-            border: Border(
-              top: BorderSide(color: ShadcnTheme.border),
-            ),
-          ),
-          child: Row(
-            children: [
-              // 선택된 항목 정보
-              if (_selectedItems.isNotEmpty)
-                Text('${_selectedItems.length}개 선택됨'),
-              
-              const Spacer(),
-              
-              // 페이지네이션
-              Pagination(
       totalCount: controller.totalCount,
       currentPage: controller.currentPage,
       pageSize: 20, // MaintenanceController._perPage 상수값
       onPageChanged: (page) => controller.goToPage(page),
-              ),
-            ],
-          ),
-        );
-      },
     );
   }
 
+
   // 유틸리티 메서드들
   Color _getMaintenanceTypeColor(String type) {
     switch (type) {

lib/screens/model/model_list_screen.dart

@@ -6,6 +6,7 @@ import 'package:superport/screens/model/controllers/model_controller.dart';
 import 'package:superport/screens/model/model_form_dialog.dart';
 import 'package:superport/screens/common/layouts/base_list_screen.dart';
 import 'package:superport/screens/common/widgets/standard_action_bar.dart';
+import 'package:superport/screens/common/widgets/pagination.dart';
 import 'package:superport/screens/common/theme_shadcn.dart';
 import 'package:superport/injection_container.dart' as di;
 
@@ -19,6 +20,10 @@ class ModelListScreen extends StatefulWidget {
 class _ModelListScreenState extends State<ModelListScreen> {
   late final ModelController _controller;
   
+  // 클라이언트 사이드 페이지네이션
+  int _currentPage = 1;
+  static const int _pageSize = 10;
+
   @override
   void initState() {
     super.initState();
@@ -28,6 +33,33 @@ class _ModelListScreenState extends State<ModelListScreen> {
     });
   }
 
+  // 현재 페이지의 모델 목록 반환
+  List<ModelDto> _getCurrentPageModels() {
+    final allModels = _controller.models;
+    final startIndex = (_currentPage - 1) * _pageSize;
+    final endIndex = startIndex + _pageSize;
+    
+    if (startIndex >= allModels.length) return [];
+    if (endIndex >= allModels.length) return allModels.sublist(startIndex);
+    
+    return allModels.sublist(startIndex, endIndex);
+  }
+
+  // 총 페이지 수 계산
+  int _getTotalPages() {
+    return (_controller.models.length / _pageSize).ceil();
+  }
+
+  // 페이지 이동
+  void _goToPage(int page) {
+    final totalPages = _getTotalPages();
+    if (page < 1 || page > totalPages) return;
+    
+    setState(() {
+      _currentPage = page;
+    });
+  }
+
   @override
   Widget build(BuildContext context) {
     return ChangeNotifierProvider.value(
@@ -78,21 +110,21 @@ class _ModelListScreenState extends State<ModelListScreen> {
           '전체 모델',
           controller.models.length.toString(),
           Icons.category,
-          ShadcnTheme.primary,
+          ShadcnTheme.companyCustomer,
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
         _buildStatCard(
           '제조사',
           controller.vendors.length.toString(),
           Icons.business,
-          ShadcnTheme.success,
+          ShadcnTheme.companyPartner,
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
         _buildStatCard(
           '활성 모델',
           controller.models.where((m) => !m.isDeleted).length.toString(),
           Icons.check_circle,
-          ShadcnTheme.info,
+          ShadcnTheme.equipmentIn,
         ),
       ],
     );
@@ -105,7 +137,12 @@ class _ModelListScreenState extends State<ModelListScreen> {
           flex: 2,
           child: ShadInput(
             placeholder: const Text('모델명 검색...'),
-            onChanged: controller.setSearchQuery,
+            onChanged: (value) {
+              setState(() {
+                _currentPage = 1; // 검색 시 첫 페이지로 리셋
+              });
+              controller.setSearchQuery(value);
+            },
           ),
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
@@ -135,7 +172,12 @@ class _ModelListScreenState extends State<ModelListScreen> {
                 return const Text('전체');
               }
             },
-            onChanged: controller.setVendorFilter,
+            onChanged: (value) {
+              setState(() {
+                _currentPage = 1; // 필터 변경 시 첫 페이지로 리셋
+              });
+              controller.setVendorFilter(value);
+            },
           ),
         ),
       ],
@@ -169,123 +211,59 @@ class _ModelListScreenState extends State<ModelListScreen> {
     );
   }
 
-  /// 헤더 셀 빌더
+
-  Widget _buildHeaderCell(
+  Widget _buildDataTable(ModelController controller) {
-    String text, {
+    final allModels = controller.models;
-    required int flex,
+    final currentPageModels = _getCurrentPageModels();
-    required bool useExpanded,
+    
-    required double minWidth,
+    if (allModels.isEmpty) {
-  }) {
+      return Center(
-    final child = Container(
+        child: Column(
-      alignment: Alignment.centerLeft,
+          mainAxisAlignment: MainAxisAlignment.center,
-      child: Text(
+          children: [
-        text,
+            Icon(
-        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
+              Icons.category_outlined,
+              size: 64,
+              color: ShadcnTheme.mutedForeground,
+            ),
+            const SizedBox(height: ShadcnTheme.spacing4),
+            Text(
+              '등록된 모델이 없습니다',
+              style: ShadcnTheme.bodyMedium.copyWith(
+                color: ShadcnTheme.mutedForeground,
+              ),
+            ),
+          ],
         ),
       );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
     }
-  }
-
-  /// 데이터 셀 빌더
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      child: child,
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
-
-  /// 헤더 셀 리스트
-  List<Widget> _buildHeaderCells() {
-    return [
-      _buildHeaderCell('ID', flex: 0, useExpanded: false, minWidth: 60),
-      _buildHeaderCell('제조사', flex: 2, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('모델명', flex: 3, useExpanded: true, minWidth: 120),
-      _buildHeaderCell('등록일', flex: 2, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('상태', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('작업', flex: 0, useExpanded: false, minWidth: 100),
-    ];
-  }
-
-  /// 테이블 행 빌더
-  Widget _buildTableRow(ModelDto model, int index) {
-    final vendor = _controller.getVendorById(model.vendorsId);
 
     return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
       decoration: BoxDecoration(
-        color: index.isEven 
+        border: Border.all(color: ShadcnTheme.border),
-            ? ShadcnTheme.muted.withValues(alpha: 0.1)
+        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-            : null,
-        border: const Border(
-          bottom: BorderSide(color: Colors.black),
-        ),
       ),
+      child: Padding(
+        padding: const EdgeInsets.all(12.0),
+        child: ShadTable.list(
+          header: const [
+            ShadTableCell.header(child: Text('ID')),
+            ShadTableCell.header(child: Text('제조사')),
+            ShadTableCell.header(child: Text('모델명')),
+            ShadTableCell.header(child: Text('등록일')),
+            ShadTableCell.header(child: Text('상태')),
+            ShadTableCell.header(child: Text('작업')),
+          ],
+          children: currentPageModels.map((model) {
+            final vendor = _controller.getVendorById(model.vendorsId);
+            return [
+              ShadTableCell(child: Text(model.id.toString(), style: ShadcnTheme.bodySmall)),
+              ShadTableCell(child: Text(vendor?.name ?? '알 수 없음', overflow: TextOverflow.ellipsis)),
+              ShadTableCell(child: Text(model.name, overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500))),
+              ShadTableCell(child: Text(model.registeredAt != null ? DateFormat('yyyy-MM-dd').format(model.registeredAt) : '-', style: ShadcnTheme.bodySmall)),
+              ShadTableCell(child: _buildStatusChip(model.isDeleted)),
+              ShadTableCell(
                 child: Row(
-        children: [
-          _buildDataCell(
-            Text(
-              model.id.toString(),
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 60,
-          ),
-          _buildDataCell(
-            Text(
-              vendor?.name ?? '알 수 없음',
-              style: ShadcnTheme.bodyMedium,
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            Text(
-              model.name,
-              style: ShadcnTheme.bodyMedium.copyWith(
-                fontWeight: FontWeight.w500,
-              ),
-            ),
-            flex: 3,
-            useExpanded: true,
-            minWidth: 120,
-          ),
-          _buildDataCell(
-            Text(
-              model.registeredAt != null
-                  ? DateFormat('yyyy-MM-dd').format(model.registeredAt)
-                  : '-',
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            _buildStatusChip(model.isDeleted),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            Row(
                   mainAxisSize: MainAxisSize.min,
                   children: [
                     ShadButton.ghost(
@@ -295,74 +273,59 @@ class _ModelListScreenState extends State<ModelListScreen> {
                     const SizedBox(width: ShadcnTheme.spacing1),
                     ShadButton.ghost(
                       onPressed: () => _showDeleteConfirmDialog(model),
-                  child: const Icon(Icons.delete, size: 16),
+                      child: Icon(Icons.delete, size: 16, color: ShadcnTheme.destructive),
                     ),
                   ],
                 ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 100,
               ),
-        ],
+            ];
+          }).toList(),
+        ),
       ),
     );
   }
 
-  Widget _buildDataTable(ModelController controller) {
-    final models = controller.models;
-    
-    return Container(
-      width: double.infinity,
-      decoration: BoxDecoration(
-        border: Border.all(color: Colors.black),
-        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-      ),
-      child: Column(
-        children: [
-          // 고정 헤더
-          Container(
-            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
-            decoration: BoxDecoration(
-              color: ShadcnTheme.muted.withValues(alpha: 0.3),
-              border: Border(bottom: BorderSide(color: Colors.black)),
-            ),
-            child: Row(children: _buildHeaderCells()),
-          ),
-          // 스크롤 바디
-          Expanded(
-            child: models.isEmpty
-                ? Center(
-                    child: Column(
-                      mainAxisAlignment: MainAxisAlignment.center,
-                      children: [
-                        Icon(
-                          Icons.category_outlined,
-                          size: 64,
-                          color: ShadcnTheme.mutedForeground,
-                        ),
-                        const SizedBox(height: 16),
-                        Text(
-                          '등록된 모델이 없습니다',
-                          style: ShadcnTheme.bodyMedium.copyWith(
-                            color: ShadcnTheme.mutedForeground,
-                          ),
-                        ),
-                      ],
-                    ),
-                  )
-                : ListView.builder(
-                    itemCount: models.length,
-                    itemBuilder: (context, index) => _buildTableRow(models[index], index),
-                  ),
-          ),
-        ],
-      ),
-    );
-  }
 
   Widget _buildPagination(ModelController controller) {
-    // 모델 목록은 현재 페이지네이션이 없는 것 같으니 빈 위젯 반환
+    final totalCount = controller.models.length;
-    return const SizedBox();
+    final totalPages = _getTotalPages();
+    
+    if (totalCount <= _pageSize) {
+      return Container(
+        padding: const EdgeInsets.all(ShadcnTheme.spacing3),
+        decoration: BoxDecoration(
+          color: ShadcnTheme.card,
+          border: Border(
+            top: BorderSide(color: ShadcnTheme.border),
+          ),
+        ),
+        child: Row(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Text(
+              '총 $totalCount개 모델',
+              style: ShadcnTheme.bodySmall,
+            ),
+          ],
+        ),
+      );
+    }
+
+    return Container(
+      padding: const EdgeInsets.all(ShadcnTheme.spacing3),
+      decoration: BoxDecoration(
+        color: ShadcnTheme.card,
+        border: Border(
+          top: BorderSide(color: ShadcnTheme.border),
+        ),
+      ),
+      child: Pagination(
+        totalCount: totalCount,
+        currentPage: _currentPage,
+        pageSize: _pageSize,
+        onPageChanged: _goToPage,
+      ),
+    );
   }
 
   Widget _buildStatCard(
@@ -416,11 +379,15 @@ class _ModelListScreenState extends State<ModelListScreen> {
 
   Widget _buildStatusChip(bool isDeleted) {
     if (isDeleted) {
-      return ShadBadge.destructive(
+      return ShadBadge(
+        backgroundColor: ShadcnTheme.equipmentDisposal.withValues(alpha: 0.1),
+        foregroundColor: ShadcnTheme.equipmentDisposal,
         child: const Text('비활성'),
       );
     } else {
-      return ShadBadge.secondary(
+      return ShadBadge(
+        backgroundColor: ShadcnTheme.equipmentIn.withValues(alpha: 0.1),
+        foregroundColor: ShadcnTheme.equipmentIn,
         child: const Text('활성'),
       );
     }

lib/screens/rent/rent_list_screen.dart

@@ -153,163 +153,6 @@ class _RentListScreenState extends State<RentListScreen> {
     _controller.loadRents();
   }
 
-  /// 헤더 셀 빌더
-  Widget _buildHeaderCell(
-    String text, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final child = Container(
-      alignment: Alignment.centerLeft,
-      child: Text(
-        text,
-        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
-      ),
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
-    }
-  }
-
-  /// 데이터 셀 빌더
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      child: child,
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
-
-  /// 헤더 셀 리스트
-  List<Widget> _buildHeaderCells() {
-    return [
-      _buildHeaderCell('ID', flex: 0, useExpanded: false, minWidth: 60),
-      _buildHeaderCell('장비 이력 ID', flex: 1, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('시작일', flex: 1, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('종료일', flex: 1, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('기간 (일)', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('상태', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('작업', flex: 0, useExpanded: false, minWidth: 120),
-    ];
-  }
-
-  /// 테이블 행 빌더
-  Widget _buildTableRow(RentDto rent, int index) {
-    final days = _controller.calculateRentDays(rent.startedAt, rent.endedAt);
-    final status = _controller.getRentStatus(rent);
-    
-    return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-      decoration: BoxDecoration(
-        color: index.isEven 
-            ? ShadcnTheme.muted.withValues(alpha: 0.1)
-            : null,
-        border: const Border(
-          bottom: BorderSide(color: Colors.black),
-        ),
-      ),
-      child: Row(
-        children: [
-          _buildDataCell(
-            Text(
-              rent.id?.toString() ?? '-',
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 60,
-          ),
-          _buildDataCell(
-            Text(
-              rent.equipmentHistoryId.toString(),
-              style: ShadcnTheme.bodyMedium,
-            ),
-            flex: 1,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            Text(
-              DateFormat('yyyy-MM-dd').format(rent.startedAt),
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 1,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            Text(
-              DateFormat('yyyy-MM-dd').format(rent.endedAt),
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 1,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            Text(
-              '$days일',
-              style: ShadcnTheme.bodySmall,
-              textAlign: TextAlign.center,
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            _buildStatusChip(status),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            Row(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                ShadButton.ghost(
-                  size: ShadButtonSize.sm,
-                  onPressed: () => _showEditDialog(rent),
-                  child: const Icon(Icons.edit, size: 16),
-                ),
-                const SizedBox(width: 4),
-                if (status == '진행중')
-                  ShadButton.ghost(
-                    size: ShadButtonSize.sm,
-                    onPressed: () => _returnRent(rent),
-                    child: const Icon(Icons.assignment_return, size: 16),
-                  ),
-                if (status == '진행중')
-                  const SizedBox(width: 4),
-                ShadButton.ghost(
-                  size: ShadButtonSize.sm,
-                  onPressed: () => _deleteRent(rent),
-                  child: const Icon(Icons.delete, size: 16),
-                ),
-              ],
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 120,
-          ),
-        ],
-      ),
-    );
-  }
-
   /// 상태 배지 빌더
   Widget _buildStatusChip(String? status) {
     switch (status) {
@@ -332,31 +175,13 @@ class _RentListScreenState extends State<RentListScreen> {
     }
   }
 
+
   /// 데이터 테이블 빌더
   Widget _buildDataTable(RentController controller) {
     final rents = controller.rents;
 
-    return Container(
+    if (rents.isEmpty) {
-      width: double.infinity,
+      return Center(
-      decoration: BoxDecoration(
-        border: Border.all(color: Colors.black),
-        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-      ),
-      child: Column(
-        children: [
-          // 고정 헤더
-          Container(
-            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
-            decoration: BoxDecoration(
-              color: ShadcnTheme.muted.withValues(alpha: 0.3),
-              border: Border(bottom: BorderSide(color: Colors.black)),
-            ),
-            child: Row(children: _buildHeaderCells()),
-          ),
-          // 스크롤 바디
-          Expanded(
-            child: rents.isEmpty
-                ? Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
@@ -365,7 +190,7 @@ class _RentListScreenState extends State<RentListScreen> {
               size: 64,
               color: ShadcnTheme.mutedForeground,
             ),
-                        const SizedBox(height: 16),
+            const SizedBox(height: ShadcnTheme.spacing4),
             Text(
               '등록된 임대 계약이 없습니다',
               style: ShadcnTheme.bodyMedium.copyWith(
@@ -374,8 +199,43 @@ class _RentListScreenState extends State<RentListScreen> {
             ),
           ],
         ),
-                  )
+      );
-                : ListView.builder(
+    }
+
+    return Container(
+      decoration: BoxDecoration(
+        border: Border.all(color: ShadcnTheme.border),
+        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
+      ),
+      child: Column(
+        children: [
+          // 고정 헤더
+          Container(
+            padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing4, vertical: ShadcnTheme.spacing3),
+            decoration: BoxDecoration(
+              color: ShadcnTheme.muted.withValues(alpha: 0.3),
+              border: Border(bottom: BorderSide(color: ShadcnTheme.border)),
+              borderRadius: BorderRadius.only(
+                topLeft: Radius.circular(ShadcnTheme.radiusMd),
+                topRight: Radius.circular(ShadcnTheme.radiusMd),
+              ),
+            ),
+            child: Row(
+              children: [
+                _buildHeaderCell('ID', 60),
+                _buildHeaderCell('장비 이력 ID', 120),
+                _buildHeaderCell('시작일', 100),
+                _buildHeaderCell('종료일', 100),
+                _buildHeaderCell('기간 (일)', 80),
+                _buildHeaderCell('상태', 80),
+                _buildHeaderCell('작업', 140),
+              ],
+            ),
+          ),
+
+          // 스크롤 가능한 바디
+          Expanded(
+            child: ListView.builder(
               itemCount: rents.length,
               itemBuilder: (context, index) => _buildTableRow(rents[index], index),
             ),
@@ -385,6 +245,126 @@ class _RentListScreenState extends State<RentListScreen> {
     );
   }
 
+  /// 헤더 셀 빌드
+  Widget _buildHeaderCell(String text, double width) {
+    return SizedBox(
+      width: width,
+      child: Text(
+        text,
+        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
+      ),
+    );
+  }
+
+  /// 테이블 행 빌드
+  Widget _buildTableRow(RentDto rent, int index) {
+    final days = _controller.calculateRentDays(rent.startedAt, rent.endedAt);
+    final status = _controller.getRentStatus(rent);
+
+    return Container(
+      decoration: BoxDecoration(
+        color: index.isEven ? ShadcnTheme.muted.withValues(alpha: 0.1) : null,
+        border: Border(bottom: BorderSide(color: ShadcnTheme.border.withValues(alpha: 0.3))),
+      ),
+      child: Material(
+        color: Colors.transparent,
+        child: InkWell(
+          onTap: () => _showEditDialog(rent),
+          child: Container(
+            padding: const EdgeInsets.symmetric(horizontal: ShadcnTheme.spacing4, vertical: ShadcnTheme.spacing3),
+            child: Row(
+              children: [
+                // ID
+                SizedBox(
+                  width: 60,
+                  child: Text(
+                    rent.id?.toString() ?? '-',
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
+
+                // 장비 이력 ID
+                SizedBox(
+                  width: 120,
+                  child: Text(
+                    rent.equipmentHistoryId.toString(),
+                    style: ShadcnTheme.bodyMedium,
+                  ),
+                ),
+
+                // 시작일
+                SizedBox(
+                  width: 100,
+                  child: Text(
+                    DateFormat('yyyy-MM-dd').format(rent.startedAt),
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
+
+                // 종료일
+                SizedBox(
+                  width: 100,
+                  child: Text(
+                    DateFormat('yyyy-MM-dd').format(rent.endedAt),
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
+
+                // 기간 (일)
+                SizedBox(
+                  width: 80,
+                  child: Text(
+                    '$days일',
+                    style: ShadcnTheme.bodySmall,
+                  ),
+                ),
+
+                // 상태
+                SizedBox(
+                  width: 80,
+                  child: _buildStatusChip(status),
+                ),
+
+                // 작업 버튼들
+                SizedBox(
+                  width: 140,
+                  child: Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      ShadButton.ghost(
+                        size: ShadButtonSize.sm,
+                        onPressed: () => _showEditDialog(rent),
+                        child: const Icon(Icons.edit, size: 16),
+                      ),
+                      const SizedBox(width: ShadcnTheme.spacing1),
+                      if (status == '진행중')
+                        ShadButton.ghost(
+                          size: ShadButtonSize.sm,
+                          onPressed: () => _returnRent(rent),
+                          child: const Icon(Icons.assignment_return, size: 16),
+                        ),
+                      if (status == '진행중')
+                        const SizedBox(width: ShadcnTheme.spacing1),
+                      ShadButton.ghost(
+                        size: ShadButtonSize.sm,
+                        onPressed: () => _deleteRent(rent),
+                        child: Icon(
+                          Icons.delete,
+                          size: 16,
+                          color: ShadcnTheme.destructive,
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
   /// 검색바 빌더
   Widget _buildSearchBar() {
     return Row(
@@ -465,13 +445,21 @@ class _RentListScreenState extends State<RentListScreen> {
   Widget? _buildPagination() {
     return Consumer<RentController>(
       builder: (context, controller, child) {
-        if (controller.totalPages <= 1) return const SizedBox.shrink();
+        // 항상 페이지네이션 정보 표시 (총 개수라도)
-        
+        return Container(
-        return Pagination(
+          padding: const EdgeInsets.symmetric(vertical: ShadcnTheme.spacing2),
+          child: controller.totalPages > 1 
+            ? Pagination(
                 totalCount: controller.totalRents,
                 currentPage: controller.currentPage,
                 pageSize: AppConstants.rentPageSize,
                 onPageChanged: (page) => controller.loadRents(page: page),
+              )
+            : Text(
+                '총 ${controller.totalRents}개 임대 계약',
+                style: ShadcnTheme.bodySmall,
+                textAlign: TextAlign.center,
+              ),
         );
       },
     );

lib/screens/user/user_form.dart

@@ -6,6 +6,7 @@ import 'package:flutter/services.dart';
 import 'package:superport/screens/user/controllers/user_form_controller.dart';
 import 'package:superport/utils/formatters/korean_phone_formatter.dart';
 import 'package:superport/screens/common/widgets/standard_dropdown.dart';
+import 'package:superport/screens/common/templates/form_layout_template.dart';
 
 // 사용자 등록/수정 화면 (UI만 담당, 상태/로직 분리)
 class UserFormScreen extends StatefulWidget {
@@ -39,15 +40,35 @@ class _UserFormScreenState extends State<UserFormScreen> {
       },
       child: Consumer<UserFormController>(
         builder: (context, controller, child) {
-          return Scaffold(
+          // Phase 10: FormLayoutTemplate 적용
-            appBar: AppBar(
+          return FormLayoutTemplate(
-              title: Text(controller.isEditMode ? '사용자 수정' : '사용자 등록'),
+            title: controller.isEditMode ? '사용자 수정' : '사용자 등록',
-            ),
+            isLoading: controller.isLoading,
-            body: controller.isLoading
+            onSave: () async {
+              // 폼 검증
+              if (!controller.formKey.currentState!.validate()) {
+                return;
+              }
+              controller.formKey.currentState!.save();
+              
+              // 사용자 저장
+              bool success = false;
+              await controller.saveUser((error) {
+                if (error == null) {
+                  success = true;
+                } else {
+                  // 에러 처리는 controller에서 관리
+                }
+              });
+              
+              if (success && mounted) {
+                Navigator.of(context).pop(true);
+              }
+            },
+            onCancel: () => Navigator.of(context).pop(),
+            child: controller.isLoading
                 ? const Center(child: ShadProgress())
-                : Padding(
+                : Form(
-                    padding: const EdgeInsets.all(16.0),
-                    child: Form(
                     key: controller.formKey,
                     child: SingleChildScrollView(
                         child: Column(
@@ -85,30 +106,33 @@ class _UserFormScreenState extends State<UserFormScreen> {
                             // 회사 선택 (*필수)
                             _buildCompanyDropdown(controller),
                             
-                            const SizedBox(height: 24),
+                            // 중복 검사 상태 메시지 영역
-                            
+                            if (controller.isCheckingEmailDuplicate)
-                            // 중복 검사 상태 메시지 영역 (고정 높이)
+                              const Padding(
-                            SizedBox(
+                                padding: EdgeInsets.symmetric(vertical: 16),
-                              height: 40,
                                 child: Center(
-                                child: controller.isCheckingEmailDuplicate
+                                  child: Row(
-                                    ? const Row(
                                     mainAxisAlignment: MainAxisAlignment.center,
                                     children: [
                                       ShadProgress(),
                                       SizedBox(width: 8),
                                       Text('중복 검사 중...'),
                                     ],
-                                      )
+                                  ),
-                                    : controller.emailDuplicateMessage != null
+                                ),
-                                        ? Text(
+                              ),
+                              
+                            if (controller.emailDuplicateMessage != null)
+                              Padding(
+                                padding: const EdgeInsets.symmetric(vertical: 16),
+                                child: Center(
+                                  child: Text(
                                     controller.emailDuplicateMessage!,
                                     style: const TextStyle(
                                       color: Colors.red,
                                       fontWeight: FontWeight.bold,
                                     ),
-                                          )
+                                  ),
-                                        : Container(),
                                 ),
                               ),
                             
@@ -121,22 +145,10 @@ class _UserFormScreenState extends State<UserFormScreen> {
                                   description: Text(controller.error!),
                                 ),
                               ),
-                            // 저장 버튼
-                            SizedBox(
-                              width: double.infinity,
-                              child: ShadButton(
-                                onPressed: controller.isLoading || controller.isCheckingEmailDuplicate
-                                    ? null
-                                    : () => _onSaveUser(controller),
-                                size: ShadButtonSize.lg,
-                                child: Text(controller.isEditMode ? '수정하기' : '등록하기'),
-                              ),
-                            ),
                           ],
                         ),
                       ),
                     ),
-                  ),
           );
         },
       ),
@@ -153,7 +165,6 @@ class _UserFormScreenState extends State<UserFormScreen> {
     String? Function(String?)? validator,
     void Function(String?)? onSaved,
     void Function(String)? onChanged,
-    Widget? suffixIcon,
   }) {
     final controller = TextEditingController(text: initialValue.isNotEmpty ? initialValue : '');
     return Padding(
@@ -247,45 +258,4 @@ class _UserFormScreenState extends State<UserFormScreen> {
     );
   }
 
-
-  // 저장 버튼 클릭 시 사용자 저장
-  void _onSaveUser(UserFormController controller) async {
-    // 먼저 폼 유효성 검사
-    if (controller.formKey.currentState?.validate() != true) {
-      return;
-    }
-    
-    // 폼 데이터 저장
-    controller.formKey.currentState?.save();
-    
-    // 이메일 중복 검사 (저장 시점)
-    final emailIsUnique = await controller.checkDuplicateEmail(controller.email);
-    
-    if (!emailIsUnique) {
-      // 중복이 발견되면 저장하지 않음
-      return;
-    }
-    
-    // 이메일 중복이 없으면 저장 진행
-    await controller.saveUser((error) {
-      if (error != null) {
-        ShadToaster.of(context).show(
-          ShadToast.destructive(
-            title: const Text('오류'),
-            description: Text(error),
-          ),
-        );
-      } else {
-        ShadToaster.of(context).show(
-          ShadToast(
-            title: const Text('성공'),
-            description: Text(
-              controller.isEditMode ? '사용자 정보가 수정되었습니다' : '사용자가 등록되었습니다',
-            ),
-          ),
-        );
-        Navigator.pop(context, true);
-      }
-    });
-  }
 }

lib/screens/user/user_list.dart

@@ -3,7 +3,6 @@ import 'package:flutter/material.dart';
 import 'package:shadcn_ui/shadcn_ui.dart';
 import 'package:superport/models/user_model.dart';
 import 'package:superport/screens/common/theme_shadcn.dart';
-import 'package:superport/screens/common/components/shadcn_components.dart';
 import 'package:superport/screens/common/layouts/base_list_screen.dart';
 import 'package:superport/screens/common/widgets/standard_action_bar.dart';
 import 'package:superport/screens/common/widgets/pagination.dart';
@@ -55,24 +54,28 @@ class _UserListState extends State<UserList> {
   /// 사용자 권한 표시 배지
   Widget _buildUserRoleBadge(UserRole role) {
     final roleName = role.displayName;
-    ShadcnBadgeVariant variant;
+    Color backgroundColor;
+    Color foregroundColor;
     
     switch (role) {
       case UserRole.admin:
-        variant = ShadcnBadgeVariant.destructive;
+        backgroundColor = ShadcnTheme.alertCritical7.withValues(alpha: 0.1);
+        foregroundColor = ShadcnTheme.alertCritical7;
         break;
       case UserRole.manager:
-        variant = ShadcnBadgeVariant.primary;
+        backgroundColor = ShadcnTheme.companyHeadquarters.withValues(alpha: 0.1);
+        foregroundColor = ShadcnTheme.companyHeadquarters;
         break;
       case UserRole.staff:
-        variant = ShadcnBadgeVariant.secondary;
+        backgroundColor = ShadcnTheme.equipmentDisposal.withValues(alpha: 0.1);
+        foregroundColor = ShadcnTheme.equipmentDisposal;
         break;
     }
     
-    return ShadcnBadge(
+    return ShadBadge(
-      text: roleName,
+      backgroundColor: backgroundColor,
-      variant: variant,
+      foregroundColor: foregroundColor,
-      size: ShadcnBadgeSize.small,
+      child: Text(roleName),
     );
   }
 
@@ -202,21 +205,21 @@ class _UserListState extends State<UserList> {
           '전체 사용자',
           _controller.total.toString(),
           Icons.people,
-          ShadcnTheme.primary,
+          ShadcnTheme.companyHeadquarters,
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
         _buildStatCard(
           '활성 사용자',
           _controller.users.where((u) => u.isActive).length.toString(),
           Icons.check_circle,
-          ShadcnTheme.success,
+          ShadcnTheme.equipmentIn,
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
         _buildStatCard(
           '비활성 사용자',
           _controller.users.where((u) => !u.isActive).length.toString(),
           Icons.person_off,
-          ShadcnTheme.mutedForeground,
+          ShadcnTheme.equipmentDisposal,
         ),
       ],
     );
@@ -265,27 +268,8 @@ class _UserListState extends State<UserList> {
   Widget _buildDataTable() {
     final users = _controller.users;
     
-    return Container(
+    if (users.isEmpty) {
-      width: double.infinity,
+      return Center(
-      decoration: BoxDecoration(
-        border: Border.all(color: Colors.black),
-        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-      ),
-      child: Column(
-        children: [
-          // 고정 헤더
-          Container(
-            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
-            decoration: BoxDecoration(
-              color: ShadcnTheme.muted.withValues(alpha: 0.3),
-              border: Border(bottom: BorderSide(color: Colors.black)),
-            ),
-            child: Row(children: _buildHeaderCells()),
-          ),
-          // 스크롤 바디
-          Expanded(
-            child: users.isEmpty
-                ? Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
@@ -303,165 +287,73 @@ class _UserListState extends State<UserList> {
             ),
           ],
         ),
-                  )
-                : ListView.builder(
-                    itemCount: users.length,
-                    itemBuilder: (context, index) => _buildTableRow(users[index], index),
-                  ),
-          ),
-        ],
-      ),
       );
     }
 
-  List<Widget> _buildHeaderCells() {
-    return [
-      _buildHeaderCell('번호', flex: 0, useExpanded: false, minWidth: 50),
-      _buildHeaderCell('이름', flex: 2, useExpanded: true, minWidth: 80),
-      _buildHeaderCell('이메일', flex: 3, useExpanded: true, minWidth: 120),
-      _buildHeaderCell('회사', flex: 2, useExpanded: true, minWidth: 80),
-      _buildHeaderCell('권한', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('상태', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('작업', flex: 0, useExpanded: false, minWidth: 120),
-    ];
-  }
-
-  Widget _buildHeaderCell(
-    String text, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final child = Container(
-      alignment: Alignment.centerLeft,
-      child: Text(
-        text,
-        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
-      ),
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
-    }
-  }
-
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      child: child,
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
-
-  Widget _buildTableRow(User user, int index) {
-    final rowNumber = (_controller.currentPage - 1) * _controller.pageSize + index + 1;
-    
     return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+      width: double.infinity,
       decoration: BoxDecoration(
-        color: index.isEven 
+        border: Border.all(color: ShadcnTheme.border),
-            ? ShadcnTheme.muted.withValues(alpha: 0.1)
+        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-            : null,
-        border: const Border(
-          bottom: BorderSide(color: Colors.black),
       ),
-      ),
+      child: Padding(
-      child: Row(
+        padding: const EdgeInsets.all(12.0),
+        child: ShadTable.list(
+          header: const [
+            ShadTableCell.header(child: Text('번호')),
+            ShadTableCell.header(child: Text('이름')),
+            ShadTableCell.header(child: Text('이메일')),
+            ShadTableCell.header(child: Text('회사')),
+            ShadTableCell.header(child: Text('권한')),
+            ShadTableCell.header(child: Text('상태')),
+            ShadTableCell.header(child: Text('작업')),
+          ],
           children: [
-          _buildDataCell(
+            for (int index = 0; index < users.length; index++)
-            Text(
+              [
-              rowNumber.toString(),
+                // 번호
-              style: ShadcnTheme.bodySmall,
+                ShadTableCell(child: Text(((_controller.currentPage - 1) * _controller.pageSize + index + 1).toString(), style: ShadcnTheme.bodySmall)),
-            ),
+                // 이름
-            flex: 0,
+                ShadTableCell(child: Text(users[index].name, overflow: TextOverflow.ellipsis)),
-            useExpanded: false,
+                // 이메일
-            minWidth: 50,
+                ShadTableCell(child: Text(users[index].email ?? '-', overflow: TextOverflow.ellipsis, style: ShadcnTheme.bodySmall)),
-          ),
+                // 회사
-          _buildDataCell(
+                ShadTableCell(child: Text(users[index].companyName ?? '-', overflow: TextOverflow.ellipsis)),
-            Text(
+                // 권한
-              user.name,
+                ShadTableCell(child: _buildUserRoleBadge(users[index].role)),
-              style: ShadcnTheme.bodyMedium.copyWith(
+                // 상태
-                fontWeight: FontWeight.w500,
+                ShadTableCell(child: _buildStatusChip(users[index].isActive)),
-              ),
+                // 작업
-            ),
+                ShadTableCell(
-            flex: 2,
+                  child: Row(
-            useExpanded: true,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            Text(
-              user.email ?? '',
-              style: ShadcnTheme.bodyMedium,
-            ),
-            flex: 3,
-            useExpanded: true,
-            minWidth: 120,
-          ),
-          _buildDataCell(
-            Text(
-              '-', // Company name not available in current model
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            _buildUserRoleBadge(user.role),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            _buildStatusChip(user.isActive),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            Row(
                     mainAxisSize: MainAxisSize.min,
                     children: [
                       ShadButton.ghost(
-                  onPressed: user.id != null ? () => _navigateToEdit(user.id!) : null,
+                        onPressed: users[index].id != null ? () => _navigateToEdit(users[index].id!) : null,
                         child: const Icon(Icons.edit, size: 16),
                       ),
                       const SizedBox(width: ShadcnTheme.spacing1),
                       ShadButton.ghost(
-                  onPressed: () => _showStatusChangeDialog(user),
+                        onPressed: () => _showStatusChangeDialog(users[index]),
-                  child: Icon(
+                        child: Icon(users[index].isActive ? Icons.person_off : Icons.person, size: 16),
-                    user.isActive ? Icons.person_off : Icons.person,
-                    size: 16,
-                  ),
                       ),
                       const SizedBox(width: ShadcnTheme.spacing1),
                       ShadButton.ghost(
-                  onPressed: user.id != null ? () => _showDeleteDialog(user.id!, user.name) : null,
+                        onPressed: users[index].id != null ? () => _showDeleteDialog(users[index].id!, users[index].name) : null,
                         child: const Icon(Icons.delete, size: 16),
                       ),
                     ],
                   ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 120,
                 ),
               ],
+          ],
+        ),
       ),
     );
   }
 
+  // (Deprecated) 기존 커스텀 테이블 빌더 유틸들은 ShadTable 전환으로 제거되었습니다.
+
   Widget _buildPagination() {
     if (_controller.totalPages <= 1) return const SizedBox();
     
@@ -524,11 +416,15 @@ class _UserListState extends State<UserList> {
 
   Widget _buildStatusChip(bool isActive) {
     if (isActive) {
-      return ShadBadge.secondary(
+      return ShadBadge(
+        backgroundColor: ShadcnTheme.equipmentIn.withValues(alpha: 0.1),
+        foregroundColor: ShadcnTheme.equipmentIn,
         child: const Text('활성'),
       );
     } else {
-      return ShadBadge.destructive(
+      return ShadBadge(
+        backgroundColor: ShadcnTheme.equipmentDisposal.withValues(alpha: 0.1),
+        foregroundColor: ShadcnTheme.equipmentDisposal,
         child: const Text('비활성'),
       );
     }
@@ -536,4 +432,3 @@ class _UserListState extends State<UserList> {
 
   // StandardDataRow 임시 정의
 }
-

lib/screens/vendor/vendor_list_screen.dart

@@ -164,21 +164,21 @@ class _VendorListScreenState extends State<VendorListScreen> {
           '전체 벤더',
           controller.totalCount.toString(),
           Icons.business,
-          ShadcnTheme.primary,
+          ShadcnTheme.companyPartner,
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
         _buildStatCard(
           '활성 벤더',
           controller.vendors.where((v) => !v.isDeleted).length.toString(),
           Icons.check_circle,
-          ShadcnTheme.success,
+          ShadcnTheme.equipmentIn,
         ),
         const SizedBox(width: ShadcnTheme.spacing4),
         _buildStatCard(
           '비활성 벤더',
           controller.vendors.where((v) => v.isDeleted).length.toString(),
           Icons.cancel,
-          ShadcnTheme.mutedForeground,
+          ShadcnTheme.equipmentDisposal,
         ),
       ],
     );
@@ -222,159 +222,12 @@ class _VendorListScreenState extends State<VendorListScreen> {
     );
   }
 
-  /// 헤더 셀 빌더
-  Widget _buildHeaderCell(
-    String text, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final child = Container(
-      alignment: Alignment.centerLeft,
-      child: Text(
-        text,
-        style: ShadcnTheme.bodyMedium.copyWith(fontWeight: FontWeight.w500),
-      ),
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: child);
-    } else {
-      return SizedBox(width: minWidth, child: child);
-    }
-  }
-
-  /// 데이터 셀 빌더
-  Widget _buildDataCell(
-    Widget child, {
-    required int flex,
-    required bool useExpanded,
-    required double minWidth,
-  }) {
-    final container = Container(
-      alignment: Alignment.centerLeft,
-      child: child,
-    );
-
-    if (useExpanded) {
-      return Expanded(flex: flex, child: container);
-    } else {
-      return SizedBox(width: minWidth, child: container);
-    }
-  }
-
-  /// 헤더 셀 리스트
-  List<Widget> _buildHeaderCells() {
-    return [
-      _buildHeaderCell('번호', flex: 0, useExpanded: false, minWidth: 50),
-      _buildHeaderCell('벤더명', flex: 3, useExpanded: true, minWidth: 120),
-      _buildHeaderCell('등록일', flex: 2, useExpanded: true, minWidth: 100),
-      _buildHeaderCell('상태', flex: 0, useExpanded: false, minWidth: 80),
-      _buildHeaderCell('작업', flex: 0, useExpanded: false, minWidth: 100),
-    ];
-  }
-
-  /// 테이블 행 빌더
-  Widget _buildTableRow(dynamic vendor, int index) {
-    final rowNumber = (_controller.currentPage - 1) * _controller.pageSize + index + 1;
-    
-    return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-      decoration: BoxDecoration(
-        color: index.isEven 
-            ? ShadcnTheme.muted.withValues(alpha: 0.1)
-            : null,
-        border: const Border(
-          bottom: BorderSide(color: Colors.black),
-        ),
-      ),
-      child: Row(
-        children: [
-          _buildDataCell(
-            Text(
-              rowNumber.toString(),
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 50,
-          ),
-          _buildDataCell(
-            Text(
-              vendor.name,
-              style: ShadcnTheme.bodyMedium.copyWith(
-                fontWeight: FontWeight.w500,
-              ),
-            ),
-            flex: 3,
-            useExpanded: true,
-            minWidth: 120,
-          ),
-          _buildDataCell(
-            Text(
-              vendor.createdAt != null
-                  ? DateFormat('yyyy-MM-dd').format(vendor.createdAt!)
-                  : '-',
-              style: ShadcnTheme.bodySmall,
-            ),
-            flex: 2,
-            useExpanded: true,
-            minWidth: 100,
-          ),
-          _buildDataCell(
-            _buildStatusChip(vendor.isDeleted),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 80,
-          ),
-          _buildDataCell(
-            Row(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                ShadButton.ghost(
-                  onPressed: () => _showEditDialog(vendor.id!),
-                  child: const Icon(Icons.edit, size: 16),
-                ),
-                const SizedBox(width: ShadcnTheme.spacing1),
-                ShadButton.ghost(
-                  onPressed: () => _showDeleteConfirmDialog(vendor.id!, vendor.name),
-                  child: const Icon(Icons.delete, size: 16),
-                ),
-              ],
-            ),
-            flex: 0,
-            useExpanded: false,
-            minWidth: 100,
-          ),
-        ],
-      ),
-    );
-  }
 
   Widget _buildDataTable(VendorController controller) {
     final vendors = controller.vendors;
     
-    return Container(
+    if (vendors.isEmpty) {
-      width: double.infinity,
+      return Center(
-      decoration: BoxDecoration(
-        border: Border.all(color: Colors.black),
-        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
-      ),
-      child: Column(
-        children: [
-          // 고정 헤더
-          Container(
-            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
-            decoration: BoxDecoration(
-              color: ShadcnTheme.muted.withValues(alpha: 0.3),
-              border: Border(bottom: BorderSide(color: Colors.black)),
-            ),
-            child: Row(children: _buildHeaderCells()),
-          ),
-          // 스크롤 바디
-          Expanded(
-            child: vendors.isEmpty
-                ? Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
@@ -383,7 +236,7 @@ class _VendorListScreenState extends State<VendorListScreen> {
               size: 64,
               color: ShadcnTheme.mutedForeground,
             ),
-                        const SizedBox(height: 16),
+            const SizedBox(height: ShadcnTheme.spacing4),
             Text(
               '등록된 벤더가 없습니다',
               style: ShadcnTheme.bodyMedium.copyWith(
@@ -392,17 +245,65 @@ class _VendorListScreenState extends State<VendorListScreen> {
             ),
           ],
         ),
-                  )
+      );
-                : ListView.builder(
+    }
-                    itemCount: vendors.length,
+
-                    itemBuilder: (context, index) => _buildTableRow(vendors[index], index),
+    return Container(
+      decoration: BoxDecoration(
+        border: Border.all(color: ShadcnTheme.border),
+        borderRadius: BorderRadius.circular(ShadcnTheme.radiusMd),
       ),
+      child: Padding(
+        padding: const EdgeInsets.all(12.0),
+        child: ShadTable.list(
+          header: const [
+            ShadTableCell.header(child: Text('번호')),
+            ShadTableCell.header(child: Text('벤더명')),
+            ShadTableCell.header(child: Text('등록일')),
+            ShadTableCell.header(child: Text('상태')),
+            ShadTableCell.header(child: Text('작업')),
+          ],
+          children: [
+            for (int index = 0; index < vendors.length; index++)
+              [
+                // 번호
+                ShadTableCell(child: Text(((_controller.currentPage - 1) * _controller.pageSize + index + 1).toString(), style: ShadcnTheme.bodySmall)),
+                // 벤더명
+                ShadTableCell(child: Text(vendors[index].name, overflow: TextOverflow.ellipsis)),
+                // 등록일
+                ShadTableCell(child: Text(
+                  vendors[index].createdAt != null
+                      ? DateFormat('yyyy-MM-dd').format(vendors[index].createdAt!)
+                      : '-',
+                  style: ShadcnTheme.bodySmall,
+                )),
+                // 상태
+                ShadTableCell(child: _buildStatusChip(vendors[index].isDeleted)),
+                // 작업
+                ShadTableCell(
+                  child: Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      ShadButton.ghost(
+                        onPressed: () => _showEditDialog(vendors[index].id!),
+                        child: const Icon(Icons.edit, size: 16),
+                      ),
+                      const SizedBox(width: ShadcnTheme.spacing1),
+                      ShadButton.ghost(
+                        onPressed: () => _showDeleteConfirmDialog(vendors[index].id!, vendors[index].name),
+                        child: Icon(Icons.delete, size: 16, color: ShadcnTheme.destructive),
                       ),
                     ],
                   ),
+                ),
+              ],
+          ],
+        ),
+      ),
     );
   }
 
+
   Widget _buildPagination(VendorController controller) {
     if (controller.totalPages <= 1) return const SizedBox();
     
@@ -465,16 +366,18 @@ class _VendorListScreenState extends State<VendorListScreen> {
 
   Widget _buildStatusChip(bool isDeleted) {
     if (isDeleted) {
-      return ShadBadge.destructive(
+      return ShadBadge(
+        backgroundColor: ShadcnTheme.equipmentDisposal.withValues(alpha: 0.1),
+        foregroundColor: ShadcnTheme.equipmentDisposal,
         child: const Text('비활성'),
       );
     } else {
-      return ShadBadge.secondary(
+      return ShadBadge(
+        backgroundColor: ShadcnTheme.equipmentIn.withValues(alpha: 0.1),
+        foregroundColor: ShadcnTheme.equipmentIn,
         child: const Text('활성'),
       );
     }
   }
 
-  // StandardDataRow 클래스 정의 (임시)
 }
-

lib/screens/zipcode/components/zipcode_table.dart

@@ -290,142 +290,5 @@ class ZipcodeTable extends StatelessWidget {
     );
   }
 
-  void _showAddressDetails(BuildContext context, ZipcodeDto zipcode) {
-    showDialog(
-      context: context,
-      builder: (context) => ShadDialog(
-        title: const Text('우편번호 상세정보'),
-        description: const Text('선택한 우편번호의 상세 정보입니다'),
-        child: Container(
-          width: 400,
-          padding: const EdgeInsets.all(16),
-          child: Column(
-            mainAxisSize: MainAxisSize.min,
-            crossAxisAlignment: CrossAxisAlignment.start,
-            children: [
-              // 우편번호
-              _buildInfoRow(
-                context,
-                '우편번호', 
-                zipcode.zipcode.toString().padLeft(5, '0'),
-                Icons.local_post_office,
-              ),
-              const SizedBox(height: 12),
   
-              // 시도
-              _buildInfoRow(
-                context,
-                '시도', 
-                zipcode.sido,
-                Icons.location_city,
-              ),
-              const SizedBox(height: 12),
-              
-              // 구/군
-              _buildInfoRow(
-                context,
-                '구/군', 
-                zipcode.gu,
-                Icons.location_on,
-              ),
-              const SizedBox(height: 12),
-              
-              // 상세주소
-              _buildInfoRow(
-                context,
-                '상세주소', 
-                zipcode.etc,
-                Icons.home,
-              ),
-              const SizedBox(height: 12),
-              
-              // 전체주소
-              _buildInfoRow(
-                context,
-                '전체주소', 
-                zipcode.fullAddress,
-                Icons.place,
-              ),
-              const SizedBox(height: 20),
-              
-              // 액션 버튼
-              Row(
-                children: [
-                  Expanded(
-                    child: ShadButton.outline(
-                      onPressed: () => _copyToClipboard(
-                        context, 
-                        zipcode.fullAddress, 
-                        '전체주소'
-                      ),
-                      child: const Row(
-                        mainAxisAlignment: MainAxisAlignment.center,
-                        children: [
-                          Icon(Icons.copy, size: 16),
-                          SizedBox(width: 6),
-                          Text('주소 복사'),
-                        ],
-                      ),
-                    ),
-                  ),
-                  const SizedBox(width: 8),
-                  Expanded(
-                    child: ShadButton(
-                      onPressed: () {
-                        Navigator.of(context).pop();
-                        onSelect(zipcode);
-                      },
-                      child: const Row(
-                        mainAxisAlignment: MainAxisAlignment.center,
-                        children: [
-                          Icon(Icons.check, size: 16),
-                          SizedBox(width: 6),
-                          Text('선택'),
-                        ],
-                      ),
-                    ),
-                  ),
-                ],
-              ),
-            ],
-          ),
-        ),
-      ),
-    );
-  }
-
-  Widget _buildInfoRow(BuildContext context, String label, String value, IconData icon) {
-    final theme = ShadTheme.of(context);
-    
-    return Row(
-      crossAxisAlignment: CrossAxisAlignment.start,
-      children: [
-        Icon(
-          icon,
-          size: 16,
-          color: theme.colorScheme.mutedForeground,
-        ),
-        const SizedBox(width: 8),
-        SizedBox(
-          width: 60,
-          child: Text(
-            label,
-            style: theme.textTheme.small.copyWith(
-              fontWeight: FontWeight.w600,
-              color: theme.colorScheme.mutedForeground,
-            ),
-          ),
-        ),
-        const SizedBox(width: 8),
-        Expanded(
-          child: Text(
-            value,
-            style: theme.textTheme.small.copyWith(
-              fontWeight: FontWeight.w500,
-            ),
-          ),
-        ),
-      ],
-    );
-  }
 }

lib/services/equipment_warehouse_cache_service.dart

@@ -33,7 +33,6 @@ class EquipmentWarehouseCacheService {
   
   // 설정 상수
   static const int _cacheValidMinutes = 10; // 10분간 캐시 유효
-  static const int _maxRetryCount = 3;      // 최대 재시도 횟수
 
   /// 캐시 로딩 상태
   bool get isLoaded => _isLoaded;

lib/services/health_check_service_web.dart

@@ -1,16 +1,18 @@
-import 'dart:js' as js;
-
 import 'package:flutter/foundation.dart';
+import 'package:js/js.dart';
 
-/// 웹 플랫폼을 위한 알림 구현
+// JS interop 선언: window.showHealthCheckNotification(title, message, status)
+@JS('showHealthCheckNotification')
+external void _showHealthCheckNotification(
+  String title,
+  String message,
+  String status,
+);
+
+/// 웹 플랫폼을 위한 알림 구현 (js_interop 기반)
 void showNotification(String title, String message, String status) {
   try {
-    // JavaScript 함수 호출
+    _showHealthCheckNotification(title, message, status);
-    js.context.callMethod('showHealthCheckNotification', [
-      title,
-      message,
-      status,
-    ]);
   } catch (e) {
     debugPrint('웹 알림 표시 실패: $e');
   }

lib/services/inventory_history_service.dart

@@ -180,8 +180,8 @@ class InventoryHistoryService {
 
   /// 시리얼번호 결정 로직
   String _determineSerialNumber(EquipmentDto? equipment, EquipmentHistoryDto history) {
-    if (equipment != null && equipment.serialNumber != null) {
+    if (equipment != null) {
-      return equipment.serialNumber!;
+      return equipment.serialNumber;
     }
     
     if (history.equipmentSerial != null) {

lib/services/user_service.dart

@@ -178,6 +178,7 @@ class UserService {
       email: dto.email ?? '',
       name: dto.name,
       phone: dto.phone,
+      companyName: dto.company?.name,
       role: UserRole.staff, // UserDto에는 role이 없으므로 기본값
       isActive: true, // UserDto에는 isActive가 없으므로 기본값
       createdAt: DateTime.now(), // UserDto에는 createdAt이 없으므로 현재 시간

pubspec.lock

@@ -674,7 +674,7 @@ packages:
     source: hosted
     version: "1.0.5"
   js:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: js
       sha256: f2c445dce49627136094980615a031419f7f3eb393237e4ecd97ac15dea343f3

pubspec.yaml

@@ -46,6 +46,8 @@ dependencies:
   
   # UI 컴포넌트
   shadcn_ui: ^0.28.7
+  # Web JS interop (pinned to 0.6.x for compat with flutter_secure_storage_web)
+  js: ^0.6.7
   
   # 한국 비즈니스 UX 지원
   webview_flutter: ^4.4.2

test/integration/auth_flow_integration_test.dart

@@ -0,0 +1,41 @@
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  final baseUrl = Platform.environment['INTEGRATION_API_BASE_URL'];
+  final username = Platform.environment['INTEGRATION_LOGIN_USERNAME'];
+  final password = Platform.environment['INTEGRATION_LOGIN_PASSWORD'];
+
+  group('Auth Integration (real API)', () {
+    test('health endpoint responds', () async {
+      if (baseUrl == null || baseUrl.isEmpty) {
+        return; // silently succeed when not configured
+      }
+      final dio = Dio(BaseOptions(baseUrl: baseUrl));
+      final res = await dio.get('/health');
+      expect(res.statusCode, inInclusiveRange(200, 204));
+    }, tags: ['integration']);
+
+    test('login and get users (requires credentials)', () async {
+      if (baseUrl == null || username == null || password == null) {
+        return; // silently succeed when not configured
+      }
+      final dio = Dio(BaseOptions(baseUrl: baseUrl));
+      final loginRes = await dio.post('/auth/login', data: {
+        'username': username,
+        'password': password,
+      });
+      expect(loginRes.statusCode, inInclusiveRange(200, 204));
+
+      final accessToken = loginRes.data['access_token'] as String?;
+      expect(accessToken, isNotNull);
+
+      dio.options.headers['Authorization'] = 'Bearer $accessToken';
+      final usersRes = await dio.get('/users');
+      expect(usersRes.statusCode, inInclusiveRange(200, 204));
+    }, tags: ['integration']);
+  });
+}
+

test/unit/auth_interceptor_test.dart

@@ -0,0 +1,216 @@
+import 'package:dartz/dartz.dart';
+import 'package:dio/dio.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get_it/get_it.dart';
+
+import 'package:superport/core/constants/api_endpoints.dart';
+import 'package:superport/core/errors/failures.dart';
+import 'package:superport/data/datasources/remote/interceptors/auth_interceptor.dart';
+import 'package:superport/data/models/auth/refresh_token_request.dart';
+import 'package:superport/data/models/auth/login_request.dart';
+import 'package:superport/data/models/auth/login_response.dart';
+import 'package:superport/data/models/auth/auth_user.dart';
+import 'package:superport/data/models/auth/token_response.dart';
+import 'package:superport/domain/repositories/auth_repository.dart';
+
+class _InMemoryAuthRepository implements AuthRepository {
+  String? _accessToken;
+  String? _refreshToken;
+  bool cleared = false;
+
+  _InMemoryAuthRepository({String? accessToken, String? refreshToken})
+      : _accessToken = accessToken,
+        _refreshToken = refreshToken;
+
+  @override
+  Future<Either<Failure, String?>> getStoredAccessToken() async => Right(_accessToken);
+
+  @override
+  Future<Either<Failure, String?>> getStoredRefreshToken() async => Right(_refreshToken);
+
+  @override
+  Future<Either<Failure, TokenResponse>> refreshToken(RefreshTokenRequest refreshRequest) async {
+    if (refreshRequest.refreshToken != _refreshToken || _refreshToken == null) {
+      return Left(ServerFailure(message: 'Invalid refresh token'));
+    }
+    // Issue new tokens
+    _accessToken = 'NEW_TOKEN';
+    _refreshToken = 'NEW_REFRESH';
+    return Right(TokenResponse(
+      accessToken: _accessToken!,
+      refreshToken: _refreshToken!,
+      tokenType: 'Bearer',
+      expiresIn: 3600,
+    ));
+  }
+
+  @override
+  Future<Either<Failure, void>> clearLocalSession() async {
+    cleared = true;
+    _accessToken = null;
+    _refreshToken = null;
+    return const Right(null);
+  }
+
+  // Unused in these tests
+  @override
+  Future<Either<Failure, void>> changePassword(String currentPassword, String newPassword) async =>
+      const Right(null);
+  @override
+  Future<Either<Failure, void>> requestPasswordReset(String email) async => const Right(null);
+  @override
+  Future<Either<Failure, bool>> isAuthenticated() async => const Right(true);
+  @override
+  Future<Either<Failure, void>> logout() async => const Right(null);
+  @override
+  Future<Either<Failure, bool>> validateSession() async => const Right(true);
+  @override
+  Future<Either<Failure, LoginResponse>> login(LoginRequest loginRequest) async =>
+      Left(ServerFailure(message: 'not used in test'));
+  @override
+  Future<Either<Failure, AuthUser>> getCurrentUser() async =>
+      Left(ServerFailure(message: 'not used in test'));
+}
+
+/// Interceptor that terminates requests without hitting network.
+class _TerminatorInterceptor extends Interceptor {
+  RequestOptions? lastOptions;
+
+  @override
+  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
+    lastOptions = options;
+    // Default success response (200)
+    handler.resolve(Response(requestOptions: options, statusCode: 200, data: {'ok': true}));
+  }
+}
+
+/// Interceptor that rejects with 401 unless it sees the expected token.
+class _UnauthorizedThenOkInterceptor extends Interceptor {
+  final String requiredBearer;
+  _UnauthorizedThenOkInterceptor(this.requiredBearer);
+
+  @override
+  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
+    final auth = options.headers['Authorization'];
+    // Debug: record current auth header on the test interceptor
+    // ignore: avoid_print
+    print('Test UnauthorizedThenOkInterceptor saw Authorization: ' + (auth?.toString() ?? 'NULL'));
+    if (auth == 'Bearer $requiredBearer') {
+      handler.resolve(Response(requestOptions: options, statusCode: 200, data: {'ok': true}));
+    } else {
+      handler.reject(DioException(
+        requestOptions: options,
+        response: Response(requestOptions: options, statusCode: 401),
+        type: DioExceptionType.badResponse,
+        message: 'Unauthorized',
+      ));
+    }
+  }
+}
+
+/// Simple HTTP adapter that returns 200 when Authorization matches,
+/// otherwise returns 401. This is used to exercise `dio.fetch(...)` retry path.
+class _AuthTestAdapter implements HttpClientAdapter {
+  @override
+  void close({bool force = false}) {}
+
+  @override
+  Future<ResponseBody> fetch(
+    RequestOptions options,
+    Stream<List<int>>? requestStream,
+    Future? cancelFuture,
+  ) async {
+    final auth = options.headers['Authorization'];
+    // Login endpoint always returns 200
+    if (options.path == ApiEndpoints.login) {
+      return ResponseBody.fromString('{"ok":true}', 200, headers: {});
+    }
+    if (auth == 'Bearer NEW_TOKEN') {
+      return ResponseBody.fromString('{"ok":true}', 200, headers: {});
+    }
+    return ResponseBody.fromString('', 401, headers: {});
+  }
+}
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+  group('AuthInterceptor', () {
+    late GetIt sl;
+
+    setUp(() {
+      sl = GetIt.instance;
+      sl.reset(dispose: true);
+    });
+
+    tearDown(() {
+      sl.reset(dispose: true);
+    });
+
+    test('attaches Authorization header for protected endpoints', () async {
+      final repo = _InMemoryAuthRepository(accessToken: 'OLD_TOKEN', refreshToken: 'REFRESH');
+      sl.registerLazySingleton<AuthRepository>(() => repo);
+
+      final dio = Dio(BaseOptions(baseUrl: 'https://example.com'));
+      final terminator = _TerminatorInterceptor();
+      dio.interceptors.add(AuthInterceptor(dio, overrideAuthRepository: repo));
+      dio.interceptors.add(terminator);
+
+      final res = await dio.get(ApiEndpoints.users);
+      expect(res.statusCode, 200);
+      expect(terminator.lastOptions, isNotNull);
+      expect(terminator.lastOptions!.headers['Authorization'], 'Bearer OLD_TOKEN');
+    });
+
+    test('skips Authorization header for auth endpoints', () async {
+      final repo = _InMemoryAuthRepository(accessToken: 'OLD_TOKEN', refreshToken: 'REFRESH');
+      sl.registerLazySingleton<AuthRepository>(() => repo);
+
+      final dio = Dio(BaseOptions(baseUrl: 'https://example.com'));
+      final terminator = _TerminatorInterceptor();
+      dio.interceptors.add(AuthInterceptor(dio, overrideAuthRepository: repo));
+      dio.interceptors.add(terminator);
+
+      final res = await dio.get(ApiEndpoints.login);
+      expect(res.statusCode, 200);
+      expect(terminator.lastOptions, isNotNull);
+      expect(terminator.lastOptions!.headers.containsKey('Authorization'), isFalse);
+    });
+
+    test('on 401, refresh token and retry succeeds', () async {
+      final repo = _InMemoryAuthRepository(accessToken: 'OLD_TOKEN', refreshToken: 'REFRESH');
+      sl.registerLazySingleton<AuthRepository>(() => repo);
+
+      final dio = Dio(BaseOptions(baseUrl: 'https://example.com'));
+      dio.httpClientAdapter = _AuthTestAdapter();
+      dio.interceptors.add(AuthInterceptor(dio, overrideAuthRepository: repo));
+
+      final res = await dio.get(ApiEndpoints.users);
+      expect(res.statusCode, 200);
+      // ensure repo now holds new token
+      final tokenEither = await repo.getStoredAccessToken();
+      expect(tokenEither.getOrElse(() => null), 'NEW_TOKEN');
+    });
+
+    test('on 401 and refresh fails, session cleared and error bubbles', () async {
+      // Repo with no refresh token (will fail refresh)
+      final repo = _InMemoryAuthRepository(accessToken: 'OLD_TOKEN', refreshToken: null);
+      sl.registerLazySingleton<AuthRepository>(() => repo);
+      // Verify registration exists
+      expect(GetIt.instance.isRegistered<AuthRepository>(), true);
+
+      final dio = Dio(BaseOptions(baseUrl: 'https://example.com'));
+      dio.httpClientAdapter = _AuthTestAdapter();
+      dio.interceptors.add(AuthInterceptor(dio, overrideAuthRepository: repo));
+
+      DioException? caught;
+      try {
+        await dio.get(ApiEndpoints.users);
+      } on DioException catch (e) {
+        caught = e;
+      }
+      expect(caught, isNotNull);
+      expect(caught!.response?.statusCode, 401);
+      expect(repo.cleared, isTrue);
+    });
+  });
+}