请找出全部未完成事项，前十条搜索结果够吗？

"""Offline exhaustive read workflow. Fixed fixtures; no network or real auth."""
from copy import deepcopy
from dataclasses import dataclass, replace


@dataclass(frozen=True)
class Query:
    scope: str = "team-A"
    snapshot: str = "snapshot-1"
    state: str = "open"


@dataclass(frozen=True)
class Task:
    id: str
    title: str
    scope: str = "team-A"
    done: bool = False


@dataclass(frozen=True)
class Page:
    rows: tuple
    next_token: str
    scope: str = "team-A"
    snapshot: str = "snapshot-1"
    state: str = "open"
    search_complete: bool = True
    total: int | None = None
    total_kind: str = "unknown"  # unknown, estimate, exact


@dataclass(frozen=True)
class Report:
    status: str
    reason: str
    query: Query
    tasks: tuple
    requests: int
    accepted_pages: int


class ToolFailure(Exception):
    pass


class FakeAPI:
    """This teaching contract lists all matching rows in a fixed snapshot.

    The server fixture copies its pages and checks one authorized scope.
    This is not an implementation of authentication or snapshot isolation.
    """
    def __init__(self, pages):
        self.pages = deepcopy(pages)
        self.calls = []

    def list_tasks(self, query, token):
        self.calls.append((query, token))
        if query.scope != "team-A":
            raise ToolFailure("forbidden scope")
        page = self.pages.get(token)
        if isinstance(page, Exception):
            raise page
        if page is None:
            raise ToolFailure("unknown continuation token")
        return deepcopy(page)


def collect(api, query, page_budget=10):
    if type(page_budget) is not int or page_budget < 1:
        raise ValueError("page_budget must be a positive integer")
    if query.state != "open" or not query.scope or not query.snapshot:
        raise ValueError("this demo needs an open-task query with an explicit scope and snapshot")
    token, requested, found = "", set(), {}
    requests = accepted_pages = 0
    exact_total = None

    def report(status, reason):
        return Report(status, reason, query, tuple(found.values()), requests, accepted_pages)

    while True:
        if requests >= page_budget:
            return report("partial", "page_budget")
        if token in requested:
            return report("partial", "token_loop")
        requested.add(token)
        requests += 1
        try:
            page = api.list_tasks(query, token)
        except ToolFailure:
            return report("partial", "tool_error")
        if page.scope != query.scope or page.state != query.state:
            return report("partial", "scope_or_filter_changed")
        if page.snapshot != query.snapshot:
            return report("partial", "snapshot_changed")
        if type(page.next_token) is not str or type(page.search_complete) is not bool:
            return report("partial", "invalid_page")
        if page.total_kind not in ("unknown", "estimate", "exact"):
            return report("partial", "invalid_total")
        if page.total is not None and (type(page.total) is not int or page.total < 0):
            return report("partial", "invalid_total")
        if page.total_kind != "unknown" and page.total is None:
            return report("partial", "invalid_total")
        if page.total_kind == "exact":
            if exact_total is not None and exact_total != page.total:
                return report("partial", "exact_total_changed")
            exact_total = page.total

        # Validate a whole page before admitting its rows to the report.
        candidate = dict(found)
        for task in page.rows:
            if (not isinstance(task, Task) or not task.id or task.scope != query.scope
                    or query.state != "open" or task.done is not False):
                return report("partial", "invalid_row")
            if task.id in candidate and candidate[task.id] != task:
                return report("partial", "conflicting_duplicate")
            candidate[task.id] = task
        found = candidate
        accepted_pages += 1
        if not page.search_complete:
            return report("partial", "source_incomplete")
        if page.next_token == "":
            if exact_total is not None and len(found) != exact_total:
                return report("partial", "exact_total_mismatch")
            return report("complete", "end_of_collection")
        # Empty rows and count == total are deliberately not termination tests.
        token = page.next_token


def show(label, result):
    ids = ",".join(task.id for task in result.tasks) or "(none observed)"
    print(f"{label}: {result.status}; {result.reason}; tasks={ids}; requests={result.requests}")


def main():
    task_a = Task("A", "prepare agenda")
    task_b = Task("B", "check venue")
    pages = {
        "": Page((task_a,), "opaque-2", total=2, total_kind="exact"),
        "opaque-2": Page((), "opaque-3", total=2, total_kind="exact"),
        "opaque-3": Page((task_b,), "", total=2, total_kind="exact"),
    }
    query = Query()
    api = FakeAPI(pages)
    complete = collect(api, query)
    assert complete.status == "complete" and complete.tasks == (task_a, task_b)
    assert complete.accepted_pages == 3 and complete.requests == 3
    assert all(sent == query for sent, _ in api.calls)
    show("empty middle page", complete)

    limited = collect(FakeAPI(pages), query, page_budget=2)
    assert limited.status == "partial" and limited.reason == "page_budget"
    assert limited.tasks == (task_a,) and limited.requests == 2
    show("budget reached", limited)

    loop = dict(pages)
    loop["opaque-2"] = replace(loop["opaque-2"], next_token="opaque-2")
    looping = collect(FakeAPI(loop), query)
    assert looping.reason == "token_loop" and looping.requests == 2
    show("repeated token", looping)

    changed = dict(pages)
    changed["opaque-2"] = Page((task_b,), "", snapshot="snapshot-2")
    mixed = collect(FakeAPI(changed), query)
    assert mixed.reason == "snapshot_changed" and mixed.tasks == (task_a,)
    show("changed snapshot", mixed)

    failed = dict(pages)
    failed["opaque-2"] = ToolFailure("fixture timeout")
    failure = collect(FakeAPI(failed), query)
    assert failure.reason == "tool_error" and failure.tasks == (task_a,)
    show("tool failed", failure)

    duplicate = dict(pages)
    duplicate["opaque-3"] = replace(duplicate["opaque-3"], rows=(task_a, task_b))
    deduplicated = collect(FakeAPI(duplicate), query)
    assert deduplicated.status == "complete" and deduplicated.tasks == (task_a, task_b)
    duplicate["opaque-3"] = replace(duplicate["opaque-3"], rows=(replace(task_a, title="changed"), task_b))
    conflict = collect(FakeAPI(duplicate), query)
    assert conflict.reason == "conflicting_duplicate" and conflict.tasks == (task_a,)
    show("conflicting duplicate", conflict)

    partial_search = {"": Page((task_a,), "", search_complete=False)}
    incomplete = collect(FakeAPI(partial_search), query)
    assert incomplete.reason == "source_incomplete" and incomplete.status == "partial"
    show("source warning", incomplete)

    estimated = {"": Page((task_a, task_b), "", total=100, total_kind="estimate")}
    estimate_result = collect(FakeAPI(estimated), query)
    assert estimate_result.status == "complete" and len(estimate_result.tasks) == 2
    show("estimated total", estimate_result)
    mismatch = {"": Page((task_a, task_b), "", total=100, total_kind="exact")}
    assert collect(FakeAPI(mismatch), query).reason == "exact_total_mismatch"

    count_is_not_end = {
        "": Page((task_a,), "still-more", total=1, total_kind="exact"),
        "still-more": Page((), "", total=1, total_kind="exact"),
    }
    assert collect(FakeAPI(count_is_not_end), query).requests == 2
    empty = collect(FakeAPI({"": Page((), "", total=0, total_kind="exact")}), query)
    assert empty.status == "complete" and empty.tasks == ()
    denied = collect(FakeAPI(pages), replace(query, scope="team-B"))
    assert denied.status == "partial" and denied.tasks == ()
    wrong_scope = {"": Page((replace(task_a, scope="team-B"),), "")}
    assert collect(FakeAPI(wrong_scope), query).reason == "invalid_row"
    wrong_filter = {"": Page((task_a,), "", state="closed")}
    assert collect(FakeAPI(wrong_filter), query).reason == "scope_or_filter_changed"
    # Changing the caller's source dictionary cannot change the API snapshot.
    pages[""] = Page((), "")
    assert collect(api, query).tasks == (task_a, task_b)
    print("PASS: bounded exhaustive read, fixed context, partial reports, duplicate checks")


if __name__ == "__main__":
    main()