Skip to content

K-Dense-AI/scientific-agent-skills / skills/iso-standards-readiness

iso-standards-readiness

Verified

Prepares and structurally reviews readiness evidence for ISO management-system and laboratory-competence standards - ISO 13485 medical device QMS, ISO 14971 device risk management, ISO/IEC 17025 testing and calibration laboratories, and ISO 15189 medical laboratories. Use when organizing declared scope, controlled documents, risk-management files, scope of accreditation, traceability, CAPA, external-provider controls, or bounded local evidence manifests, and when separating ISO certification from laboratory accreditation, FDA QMSR inspection, CLIA certification, MDSAP, and EU MDR/IVDR evidence boundaries. Not for legal applicability, compliance, certification, or accreditation decisions; contains no clause text.

FileKindSize
SKILL.mdskill md17.9 KB
assets/templates/capa-record-template.jsonconfig2.9 KB
assets/templates/document-register-template.jsonconfig2.1 KB
assets/templates/evidence-manifest-template.jsonconfig2.0 KB
assets/templates/laboratory-scope-intake-template.jsonconfig3.3 KB
assets/templates/medical-laboratory-scope-intake-template.jsonconfig3.5 KB
assets/templates/procedures/CAPA-procedure-template.mdmarkdown6.4 KB
assets/templates/procedures/document-control-procedure-template.mdmarkdown6.8 KB
assets/templates/qmsr-transition-template.jsonconfig9.4 KB
assets/templates/quality-manual-template.mdmarkdown9.2 KB
assets/templates/scope-intake-template.jsonconfig2.9 KB
assets/templates/supplier-controls-template.jsonconfig4.2 KB
assets/templates/traceability-matrix-template.jsonconfig4.3 KB
references/assurance-lanes.mdmarkdown7.1 KB
references/evidence-architecture.mdmarkdown13.3 KB
references/gap-analysis-checklist.mdmarkdown19.0 KB
references/iso-13485.mdmarkdown12.0 KB
references/iso-14971.mdmarkdown9.3 KB
references/iso-15189.mdmarkdown12.2 KB
references/iso-17025.mdmarkdown12.0 KB
references/quality-manual-guide.mdmarkdown11.3 KB
references/source-ledger.mdmarkdown20.7 KB
scripts/_catalog.pyscript7.6 KB
scripts/_common.pyscript16.4 KB
scripts/audit_document_records.pyscript5.4 KB
scripts/check_capa.pyscript8.7 KB
scripts/check_qmsr_transition.pyscript5.5 KB
scripts/check_supplier_controls.pyscript5.6 KB
scripts/check_traceability.pyscript5.5 KB
scripts/gap_analyzer.pyscript5.5 KB
scripts/validate_evidence_manifest.pyscript8.2 KB
scripts/validate_scope_intake.pyscript7.1 KB

scripts/check_supplier_controls.py

View on GitHub
#!/usr/bin/env python3
"""Check supplier and outsourced-process control evidence."""

from __future__ import annotations

from typing import Any

from _common import (
    Review,
    finish,
    guarded_main,
    load_json,
    require_root_object,
    standard_parser,
)

SUPPLIER_STATUSES = {"candidate", "approved", "conditional", "suspended", "disqualified"}
CRITICALITIES = {"low", "medium", "high", "critical"}
CONTROL_STATUSES = {"planned", "implemented", "verified", "not-applicable"}


def _control(
    review: Review,
    supplier: dict[str, Any],
    key: str,
    path: str,
    *,
    required: bool,
) -> None:
    control_path = f"{path}.{key}"
    control = review.object(supplier.get(key), control_path)
    if control is None:
        return
    status = review.choice(control, "status", CONTROL_STATUSES, control_path)
    review.text(control, "owner", control_path, max_chars=200)
    review.text(control, "method", control_path, max_chars=2_000)
    review.evidence(
        control,
        control_path,
        min_items=1 if status in {"implemented", "verified", "not-applicable"} else 0,
    )
    review.approval(
        control,
        control_path,
        require_approved=status in {"verified", "not-applicable"},
    )
    review.source_refs(control, control_path)
    if status == "not-applicable":
        review.text(control, "rationale", control_path, max_chars=2_000)
    if required and status not in {"implemented", "verified"}:
        review.add(
            "CONTROL_NOT_READY",
            f"{control_path}.status",
            "risk-based supplier control must be implemented or verified",
            "blocker",
        )


def validate(data: dict[str, Any]) -> tuple[Review, dict[str, int]]:
    review = Review()
    metadata = review.object(data.get("metadata"), "metadata")
    if metadata is not None:
        review.controlled_item(metadata, "metadata", require_approved=True)
        review.text(metadata, "register_id", "metadata", max_chars=120)
        review.date(metadata, "review_date", "metadata")

    methodology = review.object(data.get("control_methodology"), "control_methodology")
    if methodology is not None:
        review.text(methodology, "risk_method", "control_methodology", max_chars=2_000)
        review.text(
            methodology,
            "approval_authority",
            "control_methodology",
            max_chars=200,
        )
        review.text(
            methodology,
            "monitoring_and_escalation",
            "control_methodology",
            max_chars=2_000,
        )
        review.text(methodology, "owner", "control_methodology", max_chars=200)
        review.evidence(methodology, "control_methodology")
        review.approval(
            methodology,
            "control_methodology",
            require_approved=True,
        )
        review.source_refs(methodology, "control_methodology")

    suppliers = review.list(data.get("suppliers"), "suppliers", min_items=1) or []
    approved = 0
    for index, value in enumerate(suppliers):
        path = f"suppliers[{index}]"
        supplier = review.object(value, path)
        if supplier is None:
            continue
        review.text(supplier, "id", path, max_chars=120)
        review.text(supplier, "name", path, max_chars=300)
        review.text(supplier, "owner", path, max_chars=200)
        status = review.choice(supplier, "status", SUPPLIER_STATUSES, path)
        criticality = review.choice(supplier, "criticality", CRITICALITIES, path)
        review.text(
            supplier,
            "product_service_or_process",
            path,
            max_chars=1_000,
        )
        review.text(supplier, "risk_rationale", path, max_chars=2_000)
        review.date(supplier, "next_review_date", path)
        review.evidence(supplier, path)
        review.approval(supplier, path, require_approved=status == "approved")
        review.source_refs(supplier, path)
        if status == "approved":
            approved += 1

        strict = criticality in {"high", "critical"} and status in {
            "approved",
            "conditional",
        }
        for key in (
            "selection_and_initial_evaluation",
            "purchasing_requirements",
            "change_notification",
            "incoming_or_acceptance_verification",
            "performance_monitoring",
            "reevaluation",
            "nonconformity_and_capa",
        ):
            _control(review, supplier, key, path, required=strict)
        for key in (
            "quality_agreement",
            "subtier_controls",
            "business_continuity",
        ):
            _control(
                review,
                supplier,
                key,
                path,
                required=criticality == "critical" and status in {"approved", "conditional"},
            )

        if status == "conditional":
            review.text(supplier, "conditions", path, max_chars=2_000)
            review.date(supplier, "condition_due_date", path)
        if status in {"suspended", "disqualified"}:
            review.text(supplier, "disposition", path, max_chars=2_000)

    review.unique_ids(suppliers, "suppliers")
    return review, {"approved_suppliers": approved, "suppliers": len(suppliers)}


def main() -> int:
    parser = standard_parser(
        "Check risk-based supplier and outsourced-process control evidence.",
        "Path to the local supplier-controls JSON file",
    )
    args = parser.parse_args()
    data = require_root_object(load_json(args.input))
    review, metrics = validate(data)
    return finish("check_supplier_controls", review, args, metrics=metrics)


if __name__ == "__main__":
    guarded_main(main)
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall