Verification Loop for Construction Automation

A systematic verification framework ensuring quality of construction automation outputs before delivery or deployment.

When to Use

Invoke this skill:

• After generating cost estimates
• After creating or updating schedules
• After processing BIM/CAD data
• After generating reports (daily, weekly, monthly)
• After running data pipelines
• Before submitting documents to clients
• Before deploying automation workflows

Verification Phases

Phase 1: Data Integrity Check

def verify_data_integrity(output: dict) -> VerificationResult:
    """Check data completeness and consistency"""

    checks = []

    # Completeness check
    required_fields = get_required_fields(output['type'])
    missing = [f for f in required_fields if f not in output]
    checks.append({
        'name': 'Completeness',
        'status': 'PASS' if not missing else 'FAIL',
        'details': f'Missing fields: {missing}' if missing else 'All required fields present'
    })

    # Consistency check
    inconsistencies = find_inconsistencies(output)
    checks.append({
        'name': 'Consistency',
        'status': 'PASS' if not inconsistencies else 'WARN',
        'details': inconsistencies or 'No inconsistencies found'
    })

    # Referential integrity
    broken_refs = check_references(output)
    checks.append({
        'name': 'Referential Integrity',
        'status': 'PASS' if not broken_refs else 'FAIL',
        'details': f'Broken references: {broken_refs}' if broken_refs else 'All references valid'
    })

    return VerificationResult(checks)

Data Integrity Checklist

• All required fields populated
• No duplicate records
• Foreign keys resolve correctly
• Date formats consistent
• Currency values formatted correctly
• Units of measure standardized

Phase 2: Business Logic Verification

def verify_business_logic(output: dict) -> VerificationResult:
    """Verify construction-specific business rules"""

    checks = []

    # Cost estimate checks
    if output['type'] == 'cost_estimate':
        # Verify totals match line items
        calculated_total = sum(item['amount'] for item in output['line_items'])
        declared_total = output['total']
        variance = abs(calculated_total - declared_total)

        checks.append({
            'name': 'Total Accuracy',
            'status': 'PASS' if variance < 0.01 else 'FAIL',
            'details': f'Calculated: {calculated_total}, Declared: {declared_total}'
        })

        # Verify markup applied correctly
        for item in output['line_items']:
            expected_markup = item['base_cost'] * (1 + item['markup_rate'])
            if abs(item['amount'] - expected_markup) > 0.01:
                checks.append({
                    'name': f'Markup Check - {item["id"]}',
                    'status': 'FAIL',
                    'details': f'Expected: {expected_markup}, Got: {item["amount"]}'
                })

    # Schedule checks
    if output['type'] == 'schedule':
        # Verify dependencies
        for task in output['tasks']:
            for pred_id in task.get('predecessors', []):
                pred = find_task(output['tasks'], pred_id)
                if pred and pred['end_date'] > task['start_date']:
                    checks.append({
                        'name': f'Dependency Violation - {task["id"]}',
                        'status': 'FAIL',
                        'details': f'Task starts before predecessor {pred_id} ends'
                    })

        # Verify resource allocation
        resource_conflicts = find_resource_conflicts(output['tasks'])
        checks.append({
            'name': 'Resource Conflicts',
            'status': 'PASS' if not resource_conflicts else 'WARN',
            'details': resource_conflicts or 'No resource conflicts'
        })

    return VerificationResult(checks)

Business Logic Checklist

For Cost Estimates:

• Line item totals = declared subtotals
• Subtotals + markups = grand total
• Tax calculations correct
• Contingency applied consistently
• Unit prices within expected ranges
• Quantities match QTO

For Schedules:

• Dependencies respected (no backwards links)
• Critical path calculated correctly
• No resource over-allocation
• Milestones properly dated
• Working days/calendar correct
• Float values logical

For BIM Data:

• Element counts match expected
• Property values within ranges
• Spatial relationships valid
• Level associations correct
• Classification codes valid

Phase 3: Format & Standards Compliance

def verify_standards_compliance(output: dict) -> VerificationResult:
    """Verify compliance with construction standards"""

    checks = []

    # CSI classification check
    if 'csi_codes' in output:
        invalid_codes = []
        for code in output['csi_codes']:
            if not validate_csi_code(code):
                invalid_codes.append(code)

        checks.append({
            'name': 'CSI Code Validation',
            'status': 'PASS' if not invalid_codes else 'WARN',
            'details': f'Invalid codes: {invalid_codes}' if invalid_codes else 'All codes valid'
        })

    # CWICR mapping check
    if output.get('cwicr_mapped'):
        unmapped = [item for item in output['items'] if not item.get('cwicr_id')]
        checks.append({
            'name': 'CWICR Mapping',
            'status': 'PASS' if not unmapped else 'WARN',
            'details': f'{len(unmapped)} items unmapped' if unmapped else 'All items mapped'
        })

    # Document format check
    if output['type'] == 'report':
        format_issues = validate_report_format(output)
        checks.append({
            'name': 'Report Format',
            'status': 'PASS' if not format_issues else 'WARN',
            'details': format_issues or 'Format compliant'
        })

    return VerificationResult(checks)

Standards Compliance Checklist

• CSI MasterFormat codes valid (6-digit)
• UniFormat codes valid (if used)
• CWICR mappings present
• ISO dates (YYYY-MM-DD)
• Currency format consistent
• Measurement units consistent (metric/imperial)

Phase 4: Output Quality Check

def verify_output_quality(output: dict) -> VerificationResult:
    """Check output quality and presentation"""

    checks = []

    # Formatting check
    if output['format'] == 'excel':
        checks.extend([
            {
                'name': 'Column Headers',
                'status': check_headers_present(output),
                'details': 'Headers in first row'
            },
            {
                'name': 'Number Formatting',
                'status': check_number_format(output),
                'details': 'Currencies and percentages formatted'
            },
            {
                'name': 'Print Area',
                'status': check_print_area(output),
                'details': 'Print area set for clean output'
            }
        ])

    if output['format'] == 'pdf':
        checks.extend([
            {
                'name': 'Page Layout',
                'status': check_page_layout(output),
                'details': 'Margins and orientation correct'
            },
            {
                'name': 'Images Rendered',
                'status': check_images(output),
                'details': 'All images/charts visible'
            },
            {
                'name': 'Fonts Embedded',
                'status': check_fonts(output),
                'details': 'Fonts embedded for portability'
            }
        ])

    # Data visualization check
    if 'charts' in output:
        for chart in output['charts']:
            checks.append({
                'name': f'Chart - {chart["title"]}',
                'status': validate_chart(chart),
                'details': 'Labels, legends, and da