Five S Auditor

2. Scoring and Analysis

def calculate_scores(audit: FiveSAudit):
    """
    Calculate 5S scores by category and overall
    """
    scores = {}

    for category, questions in audit.questions.items():
        rated = [q for q in questions if q.rating is not None]
        if rated:
            avg_score = sum(q.rating.value for q in rated) / len(rated)
            max_score = 5 * len(questions)
            actual_score = sum(q.rating.value for q in rated)

            scores[category] = {
                "average": round(avg_score, 2),
                "percentage": round(actual_score / max_score * 100, 1),
                "questions_rated": len(rated),
                "total_questions": len(questions),
                "action_items": sum(1 for q in questions if q.action_required)
            }

    # Overall score
    all_ratings = [q.rating.value for cat in audit.questions.values()
                   for q in cat if q.rating]
    if all_ratings:
        scores["overall"] = {
            "average": round(sum(all_ratings) / len(all_ratings), 2),
            "percentage": round(sum(all_ratings) / (5 * len(all_ratings)) * 100, 1),
            "grade": get_grade(sum(all_ratings) / len(all_ratings))
        }

    return scores

def get_grade(avg_score):
    if avg_score >= 4.5:
        return "World Class"
    elif avg_score >= 4.0:
        return "Excellent"
    elif avg_score >= 3.0:
        return "Good"
    elif avg_score >= 2.0:
        return "Fair"
    else:
        return "Needs Improvement"

3. Red Tag Analysis (Sort)

@dataclass
class RedTag:
    item_description: str
    location: str
    category: str  # tools, materials, equipment, documents, other
    condition: str  # good, damaged, obsolete
    last_used: Optional[datetime.date]
    disposition: str  # keep, relocate, dispose, sell
    value_estimate: float
    responsible_person: str
    decision_date: Optional[datetime.date] = None
    action_taken: str = ""

class RedTagTracking:
    """
    Track red-tagged items during Sort phase
    """
    def __init__(self, area_name: str):
        self.area_name = area_name
        self.tags: List[RedTag] = []
        self.start_date = datetime.date.today()

    def add_tag(self, tag: RedTag):
        self.tags.append(tag)

    def summary(self):
        dispositions = {}
        for tag in self.tags:
            dispositions[tag.disposition] = dispositions.get(tag.disposition, 0) + 1

        return {
            "total_items": len(self.tags),
            "disposition_breakdown": dispositions,
            "total_value": sum(t.value_estimate for t in self.tags),
            "pending_decisions": sum(1 for t in self.tags if not t.decision_date),
            "by_category": self._by_category()
        }

    def _by_category(self):
        categories = {}
        for tag in self.tags:
            if tag.category not in categories:
                categories[tag.category] = []
            categories[tag.category].append(tag.item_description)
        return categories

4. Visual Management Assessment

def assess_visual_management(area_observations):
    """
    Evaluate visual management maturity
    """
    criteria = {
        "floor_markings": {
            "present": False,
            "compliant": False,
            "comments": ""
        },
        "tool_boards": {
            "present": False,
            "shadows_complete": False,
            "all_tools_present": False,
            "comments": ""
        },
        "labeling": {
            "locations_labeled": False,
            "consistent_format": False,
            "legible": False,
            "comments": ""
        },
        "status_boards": {
            "production_status": False,
            "quality_metrics": False,
            "safety_info": False,
            "updated_regularly": False,
            "comments": ""
        },
        "abnormality_signals": {
            "andon_present": False,
            "clear_escalation": False,
            "comments": ""
        }
    }

    # Score each criterion
    score = 0
    max_score = 0

    for category, items in criteria.items():
        for key, value in items.items():
            if key != "comments":
                max_score += 1
                if area_observations.get(category, {}).get(key):
                    score += 1

    return {
        "criteria": criteria,
        "score": score,
        "max_score": max_score,
        "percentage": round(score / max_score * 100, 1) if max_score > 0 else 0,
        "maturity_level": get_visual_maturity_level(score / max_score if max_score > 0 else 0)
    }

def get_visual_maturity_level(ratio):
    if ratio >= 0.9:
        return "Level 5: World Class"
    elif ratio >= 0.7:
        return "Level 4: Proactive"
    elif ratio >= 0.5:
        return "Level 3: Systematic"
    elif ratio >= 0.3:
        return "Level 2: Basic"
    else:
        return "Level 1: Initial"

5. Trend Analysis

def analyze_audit_trends(audit_history: List[dict]):
    """
    Analyze 5S scores over time
    """
    if len(audit_history) < 2:
        return {"message": "Need at least 2 audits for trend analysis"}

    # Sort by date
    sorted_audits = sorted(audit_history, key=lambda x: x['date'])

    trends = {
        "overall": [],
        "S1_Sort": [],
        "S2_SetInOrder": [],
        "S3_Shine": [],
        "S4_Standardize": [],
        "S5_Sustain": []
    }

    for audit in sorted_audits:
        trends["overall"].append({
            "date": audit['date'],
            "score": audit['scores']['overall']['percentage']
        })
        for category in ["S1_Sort", "S2_SetInOrder", "S3_Shine",
                        "S4_Standardize", "S5_Sustain"]:
            if category in audit['scores']:
                trends[category].append({
                    "date": audit['date'],
                    "score": audit['scores'][category]['percentage']
                })

    # Calculate trend direction
    analysis = {}
    for category, data in trends.items():
        if len(data) >= 2:
            recent = data[-3:] if len(data) >= 3 else data
            first_score = recent[0]['score']
            last_score = recent[-1]['score']
            change = last_score - first_score

            analysis[category] = {
                "current_score": last_score,
                "change": round(change, 1),
                "trend": "improving" if change > 2 else "declining" if change < -2 else "stable",
                "data_points": len(data)
            }

    return analysis

6. Action Item Tracking

@dataclass
class ActionItem:
    description: str
    category: str  # S1-S5
    priority: str  # high, medium, low
    responsible: str
    due_date: datetime.date
    status: str = "open"  # open, in_progress, completed, overdue
    completion_date: Optional[datetime.date] = None
    notes: str = ""

class ActionItemTracker:
    """
    Track 5S improvement actions
    """
    def __init__(self):
        self.items: List[ActionItem] = []

    def add_from_audit(self, audit: FiveSAudit):
        """Generate action items from audit findings"""
        for category, questions in audit.questions.items():
            for q in questions:
                if q.action_required:
                    self.items.append(ActionItem(
                        description=f"Address: {q.question} - {q.notes}",
                        category=category,
                        priority="high" if q.rating.value == 1 else "medium",
                        responsible="TBD",
                        due_date=datetime.date.today() + datetime.timedelta(days=14)
                    ))

    def status_summary(self):
        statuses = {"open": 0, "in_progress": 0, "completed": 0, "overdue": 0}

        for item in self.items:
            if item.status == "open" and item.due_date < datetime.date.today():
                item.status = "overdue"
            statuses[item.status] += 1

        return {
            "total": len(self.items),
            "by_status": statuses,
            "completion_rate": statuses["completed"] / len(self.items) * 100 if self.items else 0,
            "overdue_count": statuses["overdue"]
        }

Process Integration

This skill integrates with the following processes:

• 5s-workplace-organization-implementation.js
• kaizen-event-facilitation.js
• standard-work-development.js

Output Format

{
  "audit_info": {
    "area": "Assembly Line 3",
    "auditor": "John Smith",
    "date": "2024-01-15"
  },
  "scores": {
    "S1_Sort": {"percentage": 80, "grade": "Good"},
    "S2_SetInOrder": {"percentage": 85, "grade": "Good"},
    "S3_Shine": {"percentage": 70, "grade": "Fair"},
    "S4_Standardize": {"percentage": 75, "grade": "Good"},
    "S5_Sustain": {"percentage": 65, "grade": "Fair"},
    "overall": {"percentage": 75, "grade": "Good"}
  },
  "trend": "improving",
  "action_items": {
    "total": 5,
    "high_priority": 2,
    "overdue": 0
  },
  "next_audit_date": "2024-02-15"
}

Best Practices

1. Regular audits - Weekly or bi-weekly consistency
2. Rotate auditors - Fresh eyes find more
3. Take photos - Visual evidence of progress
4. Follow up on actions - Close the loop
5. Celebrate wins - Recognize improvements
6. Post results - Transparency drives improvement

Constraints

• Audits should be constructive, not punitive
• Include area workers in the process
• Document all findings objectively
• Track trends over time