Skip to content

malekokour/clinpharm-pmx-skills / skills/assess-development-plan-gaps

assess-development-plan-gaps

Verified

Assesses a clinical pharmacology development plan against guidance-anchored evidence expectations, classifying every expected element as present, triggered, waivable-with-rationale, or a residual gap, each traced to the criterion that creates the obligation. Use this skill when someone asks what clinical pharmacology evidence a programme is still missing, whether a plan covers what a reviewer will expect, or which studies the drug's own properties have made obligatory — for example "what CP work are we still missing before the pre-NDA meeting" or "does this plan cover the renal and hepatic expectations". Do not use for reviewing one interaction package, for assembling agency-facing briefing content, or for any request to decide whether a gap is acceptable, to commit to a study, or to approve a plan.

FileKindSize
PASTE.mdmarkdown22.4 KB
README.mdmarkdown7.8 KB
SKILL.mdskill md22.7 KB
assets/guidance-index.mdmarkdown5.2 KB
references/development-extension-modes.mdmarkdown5.4 KB
references/evidence-hierarchy.mdmarkdown2.7 KB
references/human-review.mdmarkdown2.4 KB
references/output-states.mdmarkdown2.5 KB
references/source-preflight.mdmarkdown2.8 KB
scripts/assess_coverage.pyexecutablescript3.0 KB
scripts/findings.pyscript4.7 KB
scripts/public_development_intelligence.pyexecutablescript15.9 KB
scripts/renal_staging.pyexecutablescript1.7 KB

scripts/assess_coverage.py

View on GitHub
#!/usr/bin/env python3
"""Check a clinical pharmacology development plan for the study types a programme is normally expected to address.

Emits mechanical findings only. Both sides of every conflict are preserved with
their locators; this script never decides which is correct.

Author: Malek Okour
Dependencies: Python standard library only
"""

from __future__ import annotations

import argparse
import re
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from findings import Finding, Report

REQUIRED = [
    ("single ascending dose", r"single[- ]ascending|\bsad\b"),
    ("multiple ascending dose", r"multiple[- ]ascending|\bmad\b"),
    ("food effect", r"food[- ]effect|fed[/ ]fasted"),
    # Accept the three deliberate prose separators only. The synthetic plan uses
    # an en dash; allowing arbitrary punctuation would weaken this into a fuzzy
    # match and could hide a genuinely absent interaction section.
    ("drug-drug interaction", r"drug(?:-|–| )drug interaction|\bddi\b"),
    ("renal impairment", r"renal impairment"),
    ("hepatic impairment", r"hepatic impairment"),
    ("QT assessment", r"\bqt\b|thorough qt|cardiac repolarisation"),
    ("mass balance / ADME", r"mass balance|\badme\b|human radiolabel"),
    ("population PK", r"population pk|\bpoppk\b|nonlinear mixed"),
    ("exposure-response", r"exposure[- ]response|\be-r\b"),
]


def run(ns) -> Report:
    text = read(ns.plan).lower()
    report = Report(tool="assess_coverage")
    report.count("required study types", len(REQUIRED))

    present = 0
    for name, pattern in REQUIRED:
        if re.search(pattern, text):
            present += 1
        else:
            report.add(Finding(
                rule="required-element-absent",
                severity="Major",
                item=name,
                observed="not found",
                expected="an explicit statement addressing this item",
                locator="whole document",
                detail="Absence is reported as absence. A missing element is not assumed "
                       "to be covered elsewhere or intentionally omitted.",
            ))
    report.count("study types present", present)

    if present == 0:
        report.cannot_assess(
            "coverage assessment",
            "none of the expected elements were found, which usually means the wrong "
            "document was supplied",
            "the document this checker targets",
        )
    return report


def read(path: str) -> str:
    return Path(path).read_text(encoding="utf-8", errors="replace")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
    parser.add_argument("--plan", required=True, help="document text")
    parser.add_argument("--json", action="store_true", help="machine-readable output")
    ns = parser.parse_args()
    report = run(ns)
    print(report.render(as_json=ns.json))
    return 1 if any(f.severity == "Critical" for f in report.findings) else 0


if __name__ == "__main__":
    raise SystemExit(main())
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall