@ngocsangairvds/vsaf 4.1.9 → 4.1.10

package/skills/vds-skill/runtime/excel_orchestrator/clean_remarks_column.py

@@ -0,0 +1,127 @@
+"""Clean remarks column - only service rows should have remarks, task rows should be empty."""
+
+from openpyxl import load_workbook
+
+if __name__ == "__main__":
+    wb = load_workbook(
+        "../../docs-nttc/projects/INSURANCE/analysis/reference/vietin/estimation/Estimation_HTBH.xlsx", read_only=False
+    )
+    detail = wb["VDS_Est_Detail_Target_State"]
+    original = wb["Est Detail"]
+
+    print("=== Cleaning Remarks Column ===")
+
+    # Check original pattern
+    print("\\nChecking original pattern...")
+    original_task_has_remark = False
+    for row in range(10, 50):
+        col2 = original.cell(row, 2).value
+        col3 = original.cell(row, 3).value
+        col6 = original.cell(row, 6).value
+
+        if col3 and not isinstance(col2, (int, float)):  # Task row
+            if col6:
+                original_task_has_remark = True
+                print(f"  Row {row} (task): Has remark: {str(col6)[:50]}")
+                break
+
+    if not original_task_has_remark:
+        print("  Original: Task rows do NOT have remarks")
+
+    # Clean VDS sheet
+    print("\\nCleaning VDS sheet...")
+    cleaned_count = 0
+
+    for row in range(10, 482):
+        col2 = detail.cell(row, 2).value
+        col3 = detail.cell(row, 3).value
+        col6 = detail.cell(row, 6).value
+
+        if not col3:
+            # Empty row - clear remark if any
+            if col6:
+                detail.cell(row, 6).value = None
+                cleaned_count += 1
+            continue
+
+        # Check if this is a task row (not a service row)
+        is_task_row = not isinstance(col2, (int, float))
+
+        if is_task_row:
+            # Task rows should NOT have remarks
+            if col6:
+                old_remark = str(col6)
+                detail.cell(row, 6).value = None
+                cleaned_count += 1
+                print(f"  Row {row}: Removed remark from task: {str(col3)[:40]}")
+                print(f"    Removed: {old_remark[:60]}")
+
+    # Ensure service rows have remarks
+    print("\\nVerifying service rows have remarks...")
+    missing_remarks = []
+    for row in range(10, 482):
+        col2 = detail.cell(row, 2).value
+        col3 = detail.cell(row, 3).value
+        col6 = detail.cell(row, 6).value
+
+        if col3 and isinstance(col2, (int, float)):  # Service row
+            if not col6:
+                missing_remarks.append({"row": row, "service": str(col3)[:50]})
+
+    if missing_remarks:
+        print(f"  Found {len(missing_remarks)} service rows without remarks")
+        for m in missing_remarks[:5]:
+            print(f"    Row {m['row']}: {m['service']}")
+    else:
+        print("  All service rows have remarks")
+
+    # Check for irrelevant data in service remarks
+    print("\\nChecking for irrelevant data in service remarks...")
+    irrelevant_count = 0
+    for row in range(10, 482):
+        col2 = detail.cell(row, 2).value
+        col3 = detail.cell(row, 3).value
+        col6 = detail.cell(row, 6).value
+
+        if col3 and isinstance(col2, (int, float)) and col6:  # Service row with remark
+            remark = str(col6)
+            service_name = str(col3).lower()
+
+            # Check for common irrelevant patterns
+            issues = []
+
+            # Check if remark is too generic or doesn't match service
+            if len(remark) < 30:
+                issues.append("Too short")
+
+            # Check if remark contains service name key words
+            if "proposal" in service_name and "proposal" not in remark.lower() and "đề xuất" not in remark.lower():
+                issues.append("Does not mention proposal")
+            elif "policy" in service_name and "policy" not in remark.lower() and "chính sách" not in remark.lower():
+                issues.append("Does not mention policy")
+            elif (
+                "customer" in service_name
+                and "targeted" not in service_name
+                and "customer" not in remark.lower()
+                and "khách hàng" not in remark.lower()
+            ):
+                issues.append("Does not mention customer")
+
+            # Check for placeholder text
+            if "placeholder" in remark.lower() or "todo" in remark.lower() or "tbd" in remark.lower():
+                issues.append("Contains placeholder text")
+
+            if issues:
+                irrelevant_count += 1
+                print(f"  Row {row}: {str(col3)[:50]}")
+                print(f"    Issues: {', '.join(issues)}")
+                print(f"    Remark: {remark[:80]}")
+
+    if irrelevant_count == 0:
+        print("  No irrelevant data found")
+
+    wb.save("../../docs-nttc/projects/INSURANCE/analysis/reference/vietin/estimation/Estimation_HTBH.xlsx")
+
+    print(f"\\n✅ Cleaned {cleaned_count} task rows (removed remarks)")
+    print(f"✅ Checked {len(missing_remarks)} service rows for missing remarks")
+    print("✅ Checked service remarks for irrelevant data")

package/skills/vds-skill/runtime/excel_orchestrator/comprehensive_brd_check.py

@@ -0,0 +1,322 @@
+"""
+Comprehensive BRD Coverage Check and Duplicate/Overlap Detection
+
+This script:
+1. Checks for duplicate tasks (same task in same service)
+2. Checks for overlapping tasks (same task in different services where it shouldn't be)
+3. Analyzes BRD coverage
+4. Identifies missing BRD sections
+5. Adds tasks for uncovered sections
+6. Improves BRD references
+"""
+
+import re
+from collections import defaultdict
+from pathlib import Path
+
+from openpyxl import load_workbook
+
+EXCEL_PATH = Path(
+    "../../insurance-document/projects/INSURANCE/analysis/reference/vietin/estimation/Estimation_HTBH.xlsx"
+)
+BRD_PATH = Path("../../insurance-document/projects/INSURANCE/analysis/reference/BRD/BRD_NTBH_2.0.md")
+
+
+def check_duplicates(excel_path: Path) -> list[dict]:
+    """Check for duplicate tasks (same task name in same service)."""
+    wb = load_workbook(excel_path, data_only=False)
+    ws = wb["VDS_Task_Breakdown_Detailed"]
+
+    duplicates = []
+    task_map = {}  # {(service_id, task_name_normalized): [rows]}
+
+    for row in range(9, ws.max_row + 1):  # Start from row 9 (after summary)
+        service_id = ws.cell(row, 1).value
+        task_name = ws.cell(row, 6).value
+
+        if service_id and isinstance(service_id, (int, float)) and task_name:
+            service_id_int = int(service_id)
+            # Normalize task name
+            task_normalized = str(task_name).lower().strip()
+            task_normalized = re.sub(r"[^\w\s]", "", task_normalized)
+            task_normalized = " ".join(task_normalized.split())
+
+            key = (service_id_int, task_normalized)
+            if key not in task_map:
+                task_map[key] = []
+            task_map[key].append(row)
+
+    # Find duplicates
+    for key, rows in task_map.items():
+        if len(rows) > 1:
+            service_id, task_name = key
+            duplicates.append(
+                {
+                    "service_id": service_id,
+                    "task_name": task_name,
+                    "rows": rows,
+                    "count": len(rows),
+                }
+            )
+
+    return duplicates
+
+
+def check_overlaps(excel_path: Path) -> list[dict]:
+    """Check for overlapping tasks (BRD-specific tasks in wrong services)."""
+    wb = load_workbook(excel_path, data_only=False)
+    ws = wb["VDS_Task_Breakdown_Detailed"]
+
+    # BRD-specific tasks that should only be in specific services
+    brd_specific_rules = {
+        # Renewal tasks
+        "thiết kế workflow gia hạn": ["Renewal Process", "Policy Business"],
+        "triển khai workflow gia hạn": ["Renewal Process", "Policy Business"],
+        "logic tự động gia hạn": ["Renewal Process", "Policy Business"],
+        "thông báo gia hạn": ["Renewal Process", "Policy Business", "Notification Spi"],
+        # Claims tasks
+        "thiết kế state machine bồi thường": ["Claim Business"],
+        "triển khai state machine bồi thường": ["Claim Business"],
+        "workflow gửi yêu cầu bồi thường": ["Claim Business"],
+        "hành động khách hàng": ["Claim Business"],
+        "tích hợp api bồi thường nhà bảo hiểm": ["Claim Business", "Insurer Service"],
+        "tích hợp thanh toán cho bồi thường": ["Claim Business", "Payment Service"],
+        # Purchase/Proposal tasks
+        "luồng mua hàng": ["Proposal Business", "Customer Business"],
+        "so sánh sản phẩm": ["Proposal Business", "Product Catalog"],
+        "tích hợp ocr": ["Proposal Business", "Ocr Service"],
+        "engine voucher": ["Proposal Business", "Promotion Business"],
+        # AI/Intelligent tasks
+        "nghiên cứu ml model": [
+            "Intelligent Recommendation Service",
+            "Intelligent Filtering Service",
+            "Targeted Customer Service",
+        ],
+        "engine gợi ý": ["Intelligent Recommendation Service"],
+        "tích hợp hệ thống bi": [
+            "Intelligent Recommendation Service",
+            "Analytics Service",
+        ],
+        "engine phân tích khách hàng": ["Targeted Customer Service", "Crm Service"],
+        "engine tính giá động": ["Rating Engine", "Proposal Business"],
+        "thuật toán đánh giá rủi ro": [
+            "Underwriting Engine",
+            "Auto Underwriting Process",
+        ],
+        "cấu hình công thức giá": [
+            "Rating Engine",
+            "Product Catalog",
+            "Business Rules Engine",
+        ],
+        # Chatbot tasks
+        "tích hợp nlp": ["Chatbot Service"],
+        "luồng hội thoại": ["Chatbot Service"],
+        "cơ sở tri thức": ["Chatbot Service", "Document Management Service"],
+        "xử lý fallback": ["Chatbot Service"],
+        # Payment tasks
+        "tích hợp payment gateway": ["Payment Service", "Payment Integration Hub"],
+        "engine tự động thanh toán": ["Payment Service", "Billing Service"],
+        "xử lý thanh toán một phần": ["Payment Service", "Billing Service"],
+        "workflow xử lý hoàn tiền": ["Payment Service", "Billing Service"],
+        "đối soát thanh toán": ["Payment Service", "Reconcile Process"],
+    }
+
+    overlaps = []
+
+    # Get service names
+    ws_services = wb["VDS_Est_Detail_Services_Total"]
+    service_names = {}
+    for row in range(2, 60):
+        service_id = ws_services.cell(row, 1).value
+        service_name = ws_services.cell(row, 2).value
+        if service_id and isinstance(service_id, (int, float)) and service_name:
+            name_clean = str(service_name).split(":")[0].strip()
+            service_names[int(service_id)] = name_clean
+
+    # Check each task
+    for row in range(9, ws.max_row + 1):
+        service_id = ws.cell(row, 1).value
+        task_name = ws.cell(row, 6).value
+
+        if service_id and isinstance(service_id, (int, float)) and task_name:
+            service_id_int = int(service_id)
+            service_name = service_names.get(service_id_int, "")
+            task_lower = str(task_name).lower()
+
+            # Check if it's a BRD-specific task
+            for task_keyword, allowed_services in brd_specific_rules.items():
+                if task_keyword in task_lower:
+                    # Check if service is in allowed list
+                    service_allowed = False
+                    for allowed_service in allowed_services:
+                        if allowed_service.lower() in service_name.lower():
+                            service_allowed = True
+                            break
+
+                    if not service_allowed:
+                        overlaps.append(
+                            {
+                                "row": row,
+                                "service_id": service_id_int,
+                                "service_name": service_name,
+                                "task_name": task_name,
+                                "task_keyword": task_keyword,
+                                "allowed_services": allowed_services,
+                            }
+                        )
+                    break  # Only check first match
+
+    return overlaps
+
+
+def analyze_brd_coverage(excel_path: Path, brd_path: Path) -> dict:
+    """Analyze BRD coverage and identify gaps."""
+    wb = load_workbook(excel_path, data_only=False)
+    ws = wb["VDS_Task_Breakdown_Detailed"]
+
+    # Read BRD
+    with open(brd_path, encoding="utf-8") as f:
+        brd_content = f.read()
+
+    # Extract BRD sections
+    section3_sections = re.findall(
+        r"^## \*\*(.*?)\*\*",
+        brd_content[
+            brd_content.find("# **MÔ TẢ CHI TIẾT TÍNH NĂNG DÀNH CHO KHÁCH HÀNG**") : brd_content.find(
+                "# **MÔ TẢ CHI TIẾT TÍNH NĂNG DÀNH CHO QUẢN TRỊ VIÊN**"
+            )
+        ],
+        re.MULTILINE,
+    )
+
+    section4_sections = re.findall(
+        r"^## \*\*(.*?)\*\*",
+        brd_content[brd_content.find("# **MÔ TẢ CHI TIẾT TÍNH NĂNG DÀNH CHO QUẢN TRỊ VIÊN**") :],
+        re.MULTILINE,
+    )
+
+    # Clean section titles
+    section3_sections = [re.sub(r"\*\*", "", s).strip() for s in section3_sections]
+    section4_sections = [re.sub(r"\*\*", "", s).strip() for s in section4_sections]
+
+    # Check BRD references in sheet
+    brd_refs_found = set()
+    tasks_by_brd = defaultdict(list)
+
+    for row in range(9, ws.max_row + 1):
+        brd_ref = ws.cell(row, 7).value
+        task_name = ws.cell(row, 6).value
+        service_id = ws.cell(row, 1).value
+
+        if brd_ref and str(brd_ref) != "N/A":
+            brd_refs_found.add(str(brd_ref))
+            tasks_by_brd[str(brd_ref)].append({"row": row, "service_id": service_id, "task_name": task_name})
+
+    # Map BRD sections to found references
+    coverage = {"section3": {}, "section4": {}, "missing_sections": []}
+
+    # Check Section 3
+    for section in section3_sections:
+        section_lower = section.lower()
+        found = False
+        matching_refs = []
+
+        for brd_ref in brd_refs_found:
+            if any(keyword in brd_ref.lower() for keyword in section_lower.split() if len(keyword) > 3):
+                found = True
+                matching_refs.append(brd_ref)
+
+        coverage["section3"][section] = {
+            "found": found,
+            "refs": matching_refs,
+            "task_count": sum(len(tasks_by_brd[ref]) for ref in matching_refs),
+        }
+
+        if not found:
+            coverage["missing_sections"].append({"section": "3", "title": section, "type": "customer"})
+
+    # Check Section 4
+    for section in section4_sections:
+        section_lower = section.lower()
+        found = False
+        matching_refs = []
+
+        for brd_ref in brd_refs_found:
+            if any(keyword in brd_ref.lower() for keyword in section_lower.split() if len(keyword) > 3):
+                found = True
+                matching_refs.append(brd_ref)
+
+        coverage["section4"][section] = {
+            "found": found,
+            "refs": matching_refs,
+            "task_count": sum(len(tasks_by_brd[ref]) for ref in matching_refs),
+        }
+
+        if not found:
+            coverage["missing_sections"].append({"section": "4", "title": section, "type": "admin"})
+
+    return coverage
+
+
+def main():
+    """Main execution."""
+    print("=" * 80)
+    print("Comprehensive BRD Coverage Check and Duplicate/Overlap Detection")
+    print("=" * 80)
+
+    # Step 1: Check duplicates
+    print("\nStep 1: Checking for duplicate tasks...")
+    duplicates = check_duplicates(EXCEL_PATH)
+    if duplicates:
+        print(f"⚠️ Found {len(duplicates)} duplicate task groups:")
+        for dup in duplicates[:10]:
+            print(
+                f"  Service {dup['service_id']}: '{dup['task_name'][:50]}...' appears {dup['count']} times at rows {dup['rows'][:5]}"
+            )
+    else:
+        print("✅ No duplicate tasks found")
+
+    # Step 2: Check overlaps
+    print("\nStep 2: Checking for overlapping tasks...")
+    overlaps = check_overlaps(EXCEL_PATH)
+    if overlaps:
+        print(f"⚠️ Found {len(overlaps)} overlapping tasks:")
+        for overlap in overlaps[:10]:
+            print(f"  Row {overlap['row']}: Service {overlap['service_id']} ({overlap['service_name']})")
+            print(f"    Task: {overlap['task_name'][:50]}...")
+            print(f"    Should be in: {', '.join(overlap['allowed_services'])}")
+    else:
+        print("✅ No overlapping tasks found")
+
+    # Step 3: Analyze BRD coverage
+    print("\nStep 3: Analyzing BRD coverage...")
+    coverage = analyze_brd_coverage(EXCEL_PATH, BRD_PATH)
+
+    section3_covered = sum(1 for s in coverage["section3"].values() if s["found"])
+    section4_covered = sum(1 for s in coverage["section4"].values() if s["found"])
+    total_sections = len(coverage["section3"]) + len(coverage["section4"])
+    total_covered = section3_covered + section4_covered
+
+    print(f"  Section 3 (Customer): {section3_covered}/{len(coverage['section3'])} covered")
+    print(f"  Section 4 (Admin): {section4_covered}/{len(coverage['section4'])} covered")
+    print(f"  Total: {total_covered}/{total_sections} ({total_covered / total_sections * 100:.1f}%)")
+
+    if coverage["missing_sections"]:
+        print(f"\n⚠️ Missing BRD sections: {len(coverage['missing_sections'])}")
+        for missing in coverage["missing_sections"]:
+            print(f"  {missing['section']}. {missing['title']} ({missing['type']})")
+
+    # Summary
+    print("\n" + "=" * 80)
+    print("Summary")
+    print("=" * 80)
+    print(f"  Duplicates: {len(duplicates)}")
+    print(f"  Overlaps: {len(overlaps)}")
+    print(f"  BRD Coverage: {total_covered}/{total_sections} ({total_covered / total_sections * 100:.1f}%)")
+    print(f"  Missing Sections: {len(coverage['missing_sections'])}")
+
+    return {"duplicates": duplicates, "overlaps": overlaps, "coverage": coverage}
+
+
+if __name__ == "__main__":
+    results = main()

package/skills/vds-skill/runtime/excel_orchestrator/create_buffered_summary.py

@@ -0,0 +1,119 @@
+"""
+Create a buffered summary sheet with phased buffers.
+- Source: VDS_Est_Detail_Target_State (reads actual values, data_only)
+- Output sheet: VDS_Buffered_Summary (overwrites if exists)
+- Scenarios:
+    * Base
+    * Phase 1 (+35%) – critical gaps
+    * Phase 1+2 (+50%) – critical + important
+    * Phase 1+2+3 (+54%) – critical + important + optional
+    * Tech/Integration buffer (+5%) – optional hidden complexity
+    * All-in including tech (+59%)
+"""
+
+from openpyxl import load_workbook
+
+SRC_SHEET = "VDS_Est_Detail_Target_State"
+NEW_SHEET = "VDS_Buffered_Summary"
+FILE_PATH = "../../docs-nttc/projects/INSURANCE/analysis/reference/vietin/estimation/Estimation_HTBH.xlsx"
+
+
+def compute_base_totals(wb):
+    """Sum days/hours from detail sheet (data_only)."""
+    detail = wb[SRC_SHEET]
+    total_days = 0.0
+    total_hours = 0.0
+    for row in range(10, 482):
+        col2 = detail.cell(row, 2).value
+        col3 = detail.cell(row, 3).value
+        col4 = detail.cell(row, 4).value
+        col5 = detail.cell(row, 5).value
+        if col3 and not isinstance(col2, (int, float)) and col5:
+            days = float(col5) if isinstance(col5, (int, float)) else 0.0
+            hours = float(col4) if isinstance(col4, (int, float)) else (days * 8)
+            total_days += days
+            total_hours += hours
+    return round(total_days, 1), round(total_hours, 1)
+
+
+def add_row(ws, row_idx, label, multiplier, base_days, base_hours, note=""):
+    days = round(base_days * multiplier, 1)
+    hours = round(base_hours * multiplier, 1)
+    ws.cell(row_idx, 1, label)
+    ws.cell(row_idx, 2, days)
+    ws.cell(row_idx, 3, hours)
+    ws.cell(row_idx, 4, note)
+
+
+def main() -> None:
+    wb = load_workbook(FILE_PATH, read_only=False, data_only=True)
+    if SRC_SHEET not in wb.sheetnames:
+        raise SystemExit(f"Missing sheet {SRC_SHEET}")
+
+    base_days, base_hours = compute_base_totals(wb)
+
+    # Remove old sheet if exists
+    if NEW_SHEET in wb.sheetnames:
+        ws_old = wb[NEW_SHEET]
+        wb.remove(ws_old)
+    ws = wb.create_sheet(NEW_SHEET)
+
+    # Headers
+    ws.cell(1, 1, "Scenario")
+    ws.cell(1, 2, "Days")
+    ws.cell(1, 3, "Hours")
+    ws.cell(1, 4, "Notes")
+
+    row = 2
+    add_row(ws, row, "Base", 1.0, base_days, base_hours, "Current estimation")
+    row += 1
+    add_row(
+        ws,
+        row,
+        "Phase 1 (+35%)",
+        1.35,
+        base_days,
+        base_hours,
+        "Critical gaps: Non-functional, Risk/Contingency, Deployment/DevOps",
+    )
+    row += 1
+    add_row(
+        ws,
+        row,
+        "Phase 1+2 (+50%)",
+        1.50,
+        base_days,
+        base_hours,
+        "Add Documentation + Monitoring/Alerting",
+    )
+    row += 1
+    add_row(ws, row, "Phase 1+2+3 (+54%)", 1.54, base_days, base_hours, "Add Training/KT")
+    row += 1
+    add_row(
+        ws,
+        row,
+        "Tech/Integration buffer (+5%)",
+        1.05,
+        base_days,
+        base_hours,
+        "Hidden complexity: library upgrades, external integrations",
+    )
+    row += 1
+    add_row(
+        ws,
+        row,
+        "All-in incl. Tech (+59%)",
+        1.59,
+        base_days,
+        base_hours,
+        "Phase1+2+3 plus tech/integration buffer",
+    )
+
+    wb.save(FILE_PATH)
+    print(
+        f"✅ Created {NEW_SHEET}: base={base_days} days / {base_hours} hours; all-in={round(base_days * 1.59, 1)} days"
+    )
+
+
+if __name__ == "__main__":
+    main()

package/skills/vds-skill/runtime/excel_orchestrator/create_service_totals_sheet.py

@@ -0,0 +1,118 @@
+"""
+Create a summary sheet with main services and total effort per service.
+- Source: VDS_Est_Detail_Target_State
+- Output sheet: VDS_Est_Detail_Services_Total (overwrites if exists)
+- Columns: #, Service Name, Total Hours, Total Days, Remark
+- Keeps header styling from original Est Detail header.
+"""
+
+from copy import copy
+
+from openpyxl import load_workbook
+from openpyxl.styles import Alignment, Font, PatternFill
+
+SRC_SHEET = "VDS_Est_Detail_Target_State"
+NEW_SHEET = "VDS_Est_Detail_Services_Total"
+FILE_PATH = "../../insurance-document/projects/INSURANCE/analysis/reference/vietin/estimation/Estimation_HTBH.xlsx"
+
+
+def main() -> None:
+    wb = load_workbook(FILE_PATH, read_only=False)
+    detail = wb[SRC_SHEET]
+
+    # Remove old sheet if exists
+    if NEW_SHEET in wb.sheetnames:
+        idx = wb.sheetnames.index(NEW_SHEET)
+        wb.remove(wb[NEW_SHEET])
+    new_ws = wb.create_sheet(NEW_SHEET)
+
+    # Copy header style from Est Detail header row 8 (same as source sheet)
+    header_row_src = 8
+    headers = ["#", "Task Name", "Coding Effort (hours)", "in days", "Remarks"]
+    # Target columns: B,C,D,E,F (matching original positions for readability)
+    target_cols = [2, 3, 4, 5, 6]
+
+    for header, col in zip(headers, target_cols, strict=False):
+        cell_src = detail.cell(header_row_src, col)
+        cell_new = new_ws.cell(1, col)
+        cell_new.value = header
+        cell_new.font = copy(cell_src.font)
+        cell_new.fill = copy(cell_src.fill)
+        cell_new.alignment = Alignment(horizontal="center", vertical="center")
+
+    # Borders and widths are not strictly needed for summary; column widths can be set
+    new_ws.column_dimensions["B"].width = detail.column_dimensions["B"].width or 8
+    new_ws.column_dimensions["C"].width = detail.column_dimensions["C"].width or 50
+    new_ws.column_dimensions["D"].width = detail.column_dimensions["D"].width or 18
+    new_ws.column_dimensions["E"].width = detail.column_dimensions["E"].width or 12
+    new_ws.column_dimensions["F"].width = detail.column_dimensions["F"].width or 60
+
+    # Iterate services and accumulate totals
+    services = []
+    current_service = None
+
+    for row in range(10, 482):
+        col2 = detail.cell(row, 2).value
+        col3 = detail.cell(row, 3).value
+        col4 = detail.cell(row, 4).value
+        col5 = detail.cell(row, 5).value
+        col6 = detail.cell(row, 6).value
+
+        if col3 and isinstance(col2, (int, float)):
+            # New service row
+            if current_service:
+                services.append(current_service)
+            current_service = {
+                "section": int(col2),
+                "name": str(col3),
+                "remark": str(col6) if col6 else "",
+                "hours": 0.0,
+                "days": 0.0,
+            }
+        elif col3 and current_service:
+            # Task row
+            # Hours are in col4 (may be formula); days in col5
+            days = float(col5) if isinstance(col5, (int, float)) else 0.0
+            hours = float(col4) if isinstance(col4, (int, float)) else (days * 8)
+            current_service["hours"] += hours
+            current_service["days"] += days
+
+    # Append last service
+    if current_service:
+        services.append(current_service)
+
+    # Write services to new sheet starting row 2
+    total_hours = 0.0
+    total_days = 0.0
+    for idx, svc in enumerate(services, start=2):
+        new_ws.cell(idx, 2).value = svc["section"]
+        new_ws.cell(idx, 3).value = svc["name"]
+        new_ws.cell(idx, 4).value = round(svc["hours"], 1)
+        new_ws.cell(idx, 5).value = round(svc["days"], 1)
+        new_ws.cell(idx, 6).value = svc["remark"]
+
+        total_hours += svc["hours"]
+        total_days += svc["days"]
+
+    # Total row
+    total_row = len(services) + 2
+    total_fill = PatternFill(start_color="FFF2F2F2", end_color="FFF2F2F2", fill_type="solid")
+    bold_font = Font(bold=True)
+
+    new_ws.cell(total_row, 3).value = "Tổng cộng"
+    new_ws.cell(total_row, 3).font = bold_font
+    new_ws.cell(total_row, 4).value = round(total_hours, 1)
+    new_ws.cell(total_row, 4).font = bold_font
+    new_ws.cell(total_row, 5).value = round(total_days, 1)
+    new_ws.cell(total_row, 5).font = bold_font
+    for col in [3, 4, 5, 6]:
+        new_ws.cell(total_row, col).fill = total_fill
+
+    wb.save(FILE_PATH)
+    print(
+        f"✅ Created sheet {NEW_SHEET} with {len(services)} services. Totals: {total_hours:.1f} hours / {total_days:.1f} days"
+    )
+
+
+if __name__ == "__main__":
+    main()