Assemble a weekly status report from several systems

def compute_figures(
    sources: Sequence[Source] = SOURCES,
    *,
    since: str = SINCE,
    report_date: str = REPORT_DATE,
) -> Assembly:
    """The assembly half, whole. Pull, reconcile the names, count, subtract, compare dates.

    Nothing in this function is a judgment, and nothing in it calls a model. The window is
    `since` exclusive to `report_date` inclusive, which is the schedule's window and not
    anybody's opinion about which week a task belongs to.
    """
    tasks = tuple(t for s in sources for t in s.tasks)
    threads = tuple(t for s in sources for t in s.threads)
    rows = tuple(r for s in sources for r in s.rows)

    unmatched: list[str] = []
    for name in [t.project for t in threads] + [r.project for r in rows]:
        if project_key(name) is None and name not in unmatched:
            unmatched.append(name)

    behind = tuple(
        (s.name, _days(report_date, s.as_of)) for s in sources if _days(report_date, s.as_of) > 0
    )
    dated_rows = [r for r in rows if project_key(r.project) is not None]
    hours_through = max((r.week_ending for r in dated_rows), default=None)

    waiting = tuple(
        t
        for t in threads
        if t.waiting_on == "us"
        and project_key(t.project) is not None
        and _days(report_date, t.last_message) > WAITING_DAYS
    )

    figures: list[Figure] = [
        Figure("week ending", _mdy(report_date)),
        Figure("previous report", _mdy(since)),
    ]

    projects: list[ProjectFigures] = []
    for project in PROJECTS:
        mine = [t for t in tasks if t.project == project]
        closed = [t for t in mine if t.closed and since < t.closed <= report_date]
        opened = [t for t in mine if since < t.opened <= report_date]
        open_now = [t for t in mine if not t.closed]
        overdue = [t for t in open_now if t.due < report_date]
        earliest = min((t.due for t in open_now), default=None)
        hours = sum(r.hours for r in rows if project_key(r.project) == project)
        budget = BUDGET_HOURS[project]
        percent = 100.0 * hours / budget
        projects.append(
            ProjectFigures(
                project=project,
                closed=len(closed),
                opened=len(opened),
                open_now=len(open_now),
                overdue=len(overdue),
                earliest_due=earliest,
                hours_to_date=hours,
                budget_hours=budget,
                percent_of_budget=percent,
            )
        )
        figures.append(Figure(f"{project}: tasks closed this week", str(len(closed))))
        figures.append(Figure(f"{project}: tasks opened this week", str(len(opened))))
        figures.append(Figure(f"{project}: tasks open now", str(len(open_now))))
        figures.append(Figure(f"{project}: tasks overdue now", str(len(overdue)), must_say=bool(overdue)))
        for task in overdue:
            # The date is the checkable half of an overdue claim: a count of 1 is a token any
            # draft may contain by accident, and 09/11/2026 is not.
            figures.append(Figure(f"{project}: {task.title} was due", _mdy(task.due), must_say=True))
        if earliest:
            figures.append(Figure(f"{project}: earliest due date still open", _mdy(earliest)))
        figures.append(Figure(f"{project}: hours logged to date", f"{hours:.1f}"))
        figures.append(Figure(f"{project}: hours budgeted", f"{budget:.0f}"))
        figures.append(
            Figure(
                f"{project}: percent of budgeted hours used",
                f"{percent:.1f}",
                must_say=percent >= 90.0,
            )
        )

    figures.append(Figure("tasks closed this week, all projects", str(sum(p.closed for p in projects))))
    figures.append(Figure("tasks opened this week, all projects", str(sum(p.opened for p in projects))))
    figures.append(
        Figure(
            "tasks overdue now, all projects",
            str(sum(p.overdue for p in projects)),
            must_say=any(p.overdue for p in projects),
        )
    )
    figures.append(
        Figure(
            f"client threads waiting on us for more than {WAITING_DAYS} days",
            str(len(waiting)),
            must_say=bool(waiting),
        )
    )
    for thread in waiting:
        figures.append(
            Figure(
                f"{thread.subject}: days since the client wrote",
                str(_days(report_date, thread.last_message)),
            )
        )
    if hours_through:
        figures.append(Figure("hours entered through", _mdy(hours_through)))
    for name, days in behind:
        # The source's own as_of, not the number of days: a date is distinctive enough for
        # `missing_required` to test, and "3" is not.
        as_of = next(s.as_of for s in sources if s.name == name)
        figures.append(Figure(f"the {name} is current only to", _mdy(as_of), must_say=True))
        figures.append(Figure(f"days the {name} is behind this report", str(days)))
    figures.append(Figure("project names no list recognized", str(len(unmatched))))

    return Assembly(
        figures=tuple(figures),
        projects=tuple(projects),
        waiting=waiting,
        unmatched=tuple(unmatched),
        behind=behind,
        hours_through=hours_through,
    )

def unsupported_figures(draft: str, figures: Sequence[Figure]) -> tuple[str, ...]:
    """Every numeric token in `draft` that is not, character for character, one of `figures`.

    In reading order, repeats included, so a draft that leans on one invented number three times
    shows all three. Dates are matched first and checked whole; identifiers are then blanked; what
    is left is scanned for numbers.

    This is the cheap half of the argument for letting one model call write a report nobody
    re-derives by hand. It is a pass or a fail, never a judgment. What it cannot do is tell
    whether a real figure is sitting next to the claim it belongs to, which is why a person still
    reads the report.
    """
    allowed = {figure.text for figure in figures}
    scanned = _blank_identifiers(DATE_RE.sub(lambda m: " " * len(m.group()), draft))
    hits = [(m.start(), m.group()) for m in DATE_RE.finditer(draft)]
    hits += [(m.start(), m.group()) for m in NUMBER_RE.finditer(scanned)]
    return tuple(token for _, token in sorted(hits) if token not in allowed)

def missing_required(draft: str, figures: Sequence[Figure]) -> tuple[Figure, ...]:
    """The must-say figures whose text never appears in the draft.

    The other direction from `unsupported_figures`, and the one a standing report needs: a draft
    can be entirely truthful and still be useless because it left out the only line anybody had to
    act on. Only figures of at least `MIN_CHECKABLE` characters are tested; the rest are in
    `Report.confirm_by_eye` for the person reading it.
    """
    return tuple(f for f in required_figures(figures) if f.text not in draft)

def short_must_say(figures: Sequence[Figure]) -> tuple[Figure, ...]:
    """The must-say figures too short to test. A one- or two-character figure appears in almost
    any draft by coincidence, so code reports these to the person reading the report instead of
    claiming to have checked them."""
    return tuple(f for f in figures if f.must_say and len(f.text) < MIN_CHECKABLE)