feat: lifecycle role/hazard labels and canonical state mapping (#603)

Add orthogonal role:* (single-active owner) and hazard:* (additive warning)
lifecycle labels plus status:changes-requested, folding the #603 state:*
vocabulary into the canonical status:* set rather than a conflicting parallel
prefix.

- issue_workflow_labels.py: ROLE_/HAZARD_ specs + frozensets; role/hazard
  transition maps and helpers (transition_role_labels, add/clear_hazard_label,
  canonical_role_label, canonical_hazard_label, is_discussion,
  is_implementation_candidate, requires_blocking_reason); state:* -> status:*
  synonym transitions; assess_issue_labels surfaces role/hazard dims and flags
  multiple active role labels
- docs/label-taxonomy.md: role, hazard, state->canonical migration, and
  allocator cross-check sections
- tests: role/hazard/discussion/blocking-reason/state-synonym coverage
- manage_labels.py seeds the new labels automatically via CANONICAL_LABEL_SPECS

Labels remain advisory; control-plane leases (#601) and live PR state stay the
source of truth for mutations (#603 AC2).

Closes #603

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

docs/label-taxonomy.md

@@ -39,6 +39,7 @@ one.
 | `status:blocked` | Issue is blocked |
 | `status:needs-review` | Issue work needs review |
 | `status:pr-open` | A linked PR is open |
+| `status:changes-requested` | Reviewer requested changes on the linked PR |
 | `status:approved` | Linked PR is approved |
 | `status:merged` | Linked PR is merged |
 | `status:reconcile` | Issue needs reconciliation |
@@ -46,6 +47,72 @@ one.
 | `status:duplicate` | Issue is a duplicate |
 | `status:wontfix` | Issue will not be fixed |
 
+## Role Ownership Labels (#603)
+
+A single `role:*` label shows which workflow role currently owns the item. It is
+advisory visibility only — the control-plane lease (#601) is the source of truth
+for mutation authority. Only one `role:*` label is active at a time; tooling
+replaces it on handoff via `transition_role_labels`.
+
+| Label | Use |
+| --- | --- |
+| `role:author` | Author currently owns the item |
+| `role:reviewer` | Reviewer currently owns the item |
+| `role:merger` | Merger currently owns the item |
+
+## Hazard Labels (#603)
+
+Hazard labels are orthogonal warning flags. Unlike `status:*` and `role:*`,
+**more than one hazard may be active at once**, and a hazard never substitutes
+for a live lease / PR-state check. Add/remove with `add_hazard_label` /
+`clear_hazard_label`.
+
+| Label | Use |
+| --- | --- |
+| `hazard:stale-lease` | A stale or expired lease references this item |
+| `hazard:workflow-contaminated` | Session/workflow state is contaminated; do not mutate |
+| `hazard:conflicted` | Linked PR has merge conflicts |
+| `hazard:root-mutation` | Work was mutated in the project root checkout |
+| `hazard:manual-state` | Session or lease state was edited manually |
+| `hazard:terminal-blocker` | A terminal review/merge lock blocks progress (#332/#602) |
+
+Any item that carries `status:blocked` or any `hazard:*` flag must also have a
+blocking-reason / next-action comment (`requires_blocking_reason`).
+
+## `state:*` → canonical mapping (#603 migration)
+
+Issue #603 proposed a parallel `state:*` vocabulary. To avoid a conflicting
+second lifecycle prefix, those requested states are folded into the existing
+canonical labels rather than introduced as `state:*`. `state:*` is **not** a
+supported prefix; use the canonical label on the right.
+
+| Requested `state:*` | Canonical label |
+| --- | --- |
+| `state:needs-triage` | `status:triage` |
+| `state:claimed` | `status:claimed` |
+| `state:authoring` | `status:in-progress` |
+| `state:needs-review` | `status:needs-review` |
+| `state:reviewing` | `status:needs-review` |
+| `state:changes-requested` | `status:changes-requested` |
+| `state:approved` | `status:approved` |
+| `state:merge-ready` | `status:approved` |
+| `state:merged` | `status:merged` |
+| `state:blocked` | `status:blocked` |
+| `state:terminal-blocker` | `hazard:terminal-blocker` |
+| `state:abandoned` | `status:wontfix` |
+
+The transition helpers accept these names as synonyms (e.g.
+`canonical_status_label("authoring")` → `status:in-progress`), so callers may use
+the #603 wording while a single canonical status stays active.
+
+## Allocator Cross-Check (#603)
+
+Labels are advisory queue hints. The work allocator (#600/#613) uses labels as
+one signal but **cross-checks live leases and PR state** and never trusts labels
+alone. Discussion issues (`type:discussion`) are excluded from implementation
+queues (`is_implementation_candidate`) unless a controller explicitly selects
+them.
+
 ## Transition Rules
 
 Suggested lifecycle:

gitea_auth.py

@@ -20,14 +20,15 @@ from dotenv import dotenv_values, load_dotenv
 
 import gitea_config
 
+PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
+
 # Load standard .env if present
-load_dotenv()
+load_dotenv(os.path.join(PROJECT_ROOT, ".env"))
 
 # Dictionary to store configurations parsed dynamically from .env.* files
 DYNAMIC_CONFIGS = {}
 
 # Scan all files starting with .env in the project root to load multiple configurations
-PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
 for env_path in glob.glob(os.path.join(PROJECT_ROOT, ".env*")):
     # Skip directories and the example template
     if os.path.basename(env_path) == ".env.example":

gitea_mcp_server.py

@@ -1216,12 +1216,32 @@ def extract_linked_issue_numbers(text: str | None, branch_name: str | None = Non
     return sorted(list(issues))
 
 def _repo_label_id_map(base: str, auth: str) -> dict[str, int]:
-    labels = api_get_all(f"{base}/labels", auth) or []
-    return {
-        str(lb["name"]): int(lb["id"])
-        for lb in labels
-        if isinstance(lb, dict) and lb.get("name") and lb.get("id") is not None
-    }
+    """Map repository label names to IDs across **all** label pages (#627).
+
+    Uses :func:`api_get_all` so inventories larger than Gitea's per-page cap
+    (50) are complete. Duplicate names keep the **first-seen** id for
+    deterministic resolution (fail-open for attach; names still resolve).
+    """
+    labels = api_get_all(f"{base}/labels", auth)
+    if labels is None:
+        labels = []
+    if not isinstance(labels, list):
+        raise RuntimeError(
+            "failed to list repository labels: expected a list page sequence, "
+            f"got {type(labels).__name__}"
+        )
+    name_to_id: dict[str, int] = {}
+    for lb in labels:
+        if not isinstance(lb, dict):
+            continue
+        name = lb.get("name")
+        lid = lb.get("id")
+        if not name or lid is None:
+            continue
+        key = str(name)
+        if key not in name_to_id:
+            name_to_id[key] = int(lid)
+    return name_to_id
 
 def _issue_label_names(base: str, auth: str, issue_number: int) -> list[str]:
     issue = api_request("GET", f"{base}/issues/{issue_number}", auth) or {}
@@ -1235,20 +1255,46 @@ def _put_issue_label_names(
     names: list[str],
     label_ids_by_name: dict[str, int] | None = None,
 ) -> list[dict]:
+    """Full-set label replacement with complete inventory + post-mutation check.
+
+    Missing requested names fail closed before PUT. After PUT, the returned
+    label set must match the requested names (order-independent) so callers
+    never silently drop labels (#627).
+    """
     by_name = label_ids_by_name or _repo_label_id_map(base, auth)
     missing = [name for name in names if name not in by_name]
     if missing:
         raise RuntimeError(
             f"The following labels do not exist on the repository: {missing}. "
-            "Create the canonical workflow labels first."
+            "Please create them first using gitea_create_label."
         )
     ids = [by_name[name] for name in names]
-    return api_request(
+    res = api_request(
         "PUT",
         f"{base}/issues/{issue_number}/labels",
         auth,
         {"labels": ids},
     )
+    if not isinstance(res, list):
+        raise RuntimeError(
+            "Post-mutation label verification failed: expected a list of labels "
+            f"from Gitea, got {type(res).__name__}."
+        )
+    final_names = {
+        str(lb.get("name"))
+        for lb in res
+        if isinstance(lb, dict) and lb.get("name")
+    }
+    expected = {str(n) for n in names}
+    if final_names != expected:
+        missing_after = sorted(expected - final_names)
+        extra_after = sorted(final_names - expected)
+        raise RuntimeError(
+            "Post-mutation label verification failed: "
+            f"missing={missing_after} unexpected={extra_after}. "
+            "Full-set replacement did not match the requested label set."
+        )
+    return res
 
 def _transition_issue_status(
     *,
@@ -1326,12 +1372,9 @@ def release_in_progress_label(issue_numbers: list[int], remote: str, host: str |
     base = repo_api_url(h, o, r)
 
     try:
-        labels = api_request("GET", f"{base}/labels?limit=100", auth)
-        label_id = None
-        for lb in labels:
-            if lb["name"] == "status:in-progress":
-                label_id = lb["id"]
-                break
+        # Paginated inventory (#627): status labels must resolve even when
+        # the repo has more labels than one Gitea page.
+        label_id = _repo_label_id_map(base, auth).get("status:in-progress")
     except Exception as exc:
         return {num: f"error fetching repo labels: {_redact(str(exc))}" for num in issue_numbers}
 
@@ -10286,11 +10329,8 @@ def gitea_cleanup_stale_claims(
     h, o, r = _resolve(remote, host, org, repo)
     auth = _auth(h)
     base = repo_api_url(h, o, r)
-    labels = api_request("GET", f"{base}/labels?limit=100", auth)
-    label_id = next(
-        (lb["id"] for lb in labels if lb.get("name") == "status:in-progress"),
-        None,
-    )
+    # Paginated inventory (#627) — do not use single-page labels?limit=100.
+    label_id = _repo_label_id_map(base, auth).get("status:in-progress")
     if label_id is None:
         raise RuntimeError("Label 'status:in-progress' not found")
 
@@ -10448,29 +10488,16 @@ def gitea_set_issue_labels(
     auth = _auth(h)
     base = repo_api_url(h, o, r)
 
-    # 1. Fetch existing labels on the repo to resolve names -> IDs
-    existing = api_request("GET", f"{base}/labels?limit=100", auth)
-    name_to_id = {lb["name"]: lb["id"] for lb in existing}
-
-    # 2. Check if any requested labels do not exist, and raise error
-    label_ids = []
-    missing_labels = []
-    for name in labels:
-        if name in name_to_id:
-            label_ids.append(name_to_id[name])
-        else:
-            missing_labels.append(name)
-
-    if missing_labels:
-        raise RuntimeError(
-            f"The following labels do not exist on the repository: {missing_labels}. "
-            "Please create them first using gitea_create_label."
-        )
-
-    # 3. PUT the labels to the issue
+    # Full-set replacement via paginated name→id map + post-mutation verify (#627).
+    # Never use single-page GET labels?limit=100 — Gitea caps pages at 50.
     with _audited("set_issue_labels", host=h, remote=remote, org=o, repo=r,
-                  issue_number=issue_number, request_metadata={"labels": labels}):
-        res = api_request("PUT", f"{base}/issues/{issue_number}/labels", auth, {"labels": label_ids})
+                  issue_number=issue_number, request_metadata={"labels": list(labels)}):
+        res = _put_issue_label_names(
+            base=base,
+            auth=auth,
+            issue_number=issue_number,
+            names=list(labels),
+        )
     return res
 
 

issue_workflow_labels.py

@@ -34,6 +34,11 @@ STATUS_LABEL_SPECS: tuple[LabelSpec, ...] = (
     LabelSpec("status:blocked", "b60205", "Issue is blocked"),
     LabelSpec("status:needs-review", "0052cc", "Issue work needs review"),
     LabelSpec("status:pr-open", "1d76db", "A linked PR is open"),
+    LabelSpec(
+        "status:changes-requested",
+        "e11d21",
+        "Reviewer requested changes on the linked PR",
+    ),
     LabelSpec("status:approved", "0e8a16", "Linked PR is approved"),
     LabelSpec("status:merged", "5319e7", "Linked PR is merged"),
     LabelSpec("status:reconcile", "d93f0b", "Issue needs reconciliation"),
@@ -65,8 +70,42 @@ VALIDATION_LABEL_SPECS: tuple[LabelSpec, ...] = (
     ),
 )
 
+# Lifecycle role-ownership labels (#603): which workflow role currently owns the
+# item. Advisory visibility only — the control-plane lease (#601) remains the
+# source of truth for mutation authority. Only one role:* label is active at a
+# time, mirroring the single-active-status invariant.
+ROLE_LABEL_SPECS: tuple[LabelSpec, ...] = (
+    LabelSpec("role:author", "1d76db", "Author currently owns the item"),
+    LabelSpec("role:reviewer", "5319e7", "Reviewer currently owns the item"),
+    LabelSpec("role:merger", "0e8a16", "Merger currently owns the item"),
+)
+
+# Lifecycle hazard labels (#603): orthogonal warning flags surfacing dangerous
+# coordination conditions. Unlike status/role, multiple hazard:* labels may be
+# active at once, and they never substitute for live lease / PR state checks.
+HAZARD_LABEL_SPECS: tuple[LabelSpec, ...] = (
+    LabelSpec("hazard:stale-lease", "d93f0b", "A stale or expired lease references this item"),
+    LabelSpec(
+        "hazard:workflow-contaminated",
+        "b60205",
+        "Session/workflow state is contaminated and must not mutate",
+    ),
+    LabelSpec("hazard:conflicted", "e11d21", "Linked PR has merge conflicts"),
+    LabelSpec("hazard:root-mutation", "b60205", "Work was mutated in the project root checkout"),
+    LabelSpec("hazard:manual-state", "d93f0b", "Session or lease state was edited manually"),
+    LabelSpec(
+        "hazard:terminal-blocker",
+        "000000",
+        "A terminal review/merge lock blocks progress (#332/#602)",
+    ),
+)
+
 CANONICAL_LABEL_SPECS: tuple[LabelSpec, ...] = (
-    TYPE_LABEL_SPECS + STATUS_LABEL_SPECS + VALIDATION_LABEL_SPECS
+    TYPE_LABEL_SPECS
+    + STATUS_LABEL_SPECS
+    + VALIDATION_LABEL_SPECS
+    + ROLE_LABEL_SPECS
+    + HAZARD_LABEL_SPECS
 )
 
 TYPE_LABELS: frozenset[str] = frozenset(spec.name for spec in TYPE_LABEL_SPECS)
@@ -74,6 +113,8 @@ STATUS_LABELS: frozenset[str] = frozenset(spec.name for spec in STATUS_LABEL_SPE
 VALIDATION_LABELS: frozenset[str] = frozenset(
     spec.name for spec in VALIDATION_LABEL_SPECS
 )
+ROLE_LABELS: frozenset[str] = frozenset(spec.name for spec in ROLE_LABEL_SPECS)
+HAZARD_LABELS: frozenset[str] = frozenset(spec.name for spec in HAZARD_LABEL_SPECS)
 CANONICAL_LABELS: frozenset[str] = frozenset(
     spec.name for spec in CANONICAL_LABEL_SPECS
 )
@@ -91,9 +132,15 @@ STATUS_TRANSITIONS: dict[str, str] = {
     "blocked": "status:blocked",
     "needs_review": "status:needs-review",
     "needs-review": "status:needs-review",
+    "reviewing": "status:needs-review",
     "pr_open": "status:pr-open",
     "pr-open": "status:pr-open",
+    "changes_requested": "status:changes-requested",
+    "changes-requested": "status:changes-requested",
+    "changes": "status:changes-requested",
     "approved": "status:approved",
+    "merge_ready": "status:approved",
+    "merge-ready": "status:approved",
     "merge": "status:reconcile",
     "merged": "status:reconcile",
     "reconcile": "status:reconcile",
@@ -101,6 +148,37 @@ STATUS_TRANSITIONS: dict[str, str] = {
     "complete": "status:done",
     "duplicate": "status:duplicate",
     "wontfix": "status:wontfix",
+    "abandoned": "status:wontfix",
+    # #603 requested state:* synonyms folded into the canonical status vocabulary
+    "needs_triage": "status:triage",
+    "needs-triage": "status:triage",
+    "authoring": "status:in-progress",
+}
+
+# #603: single-active role ownership. Maps role kinds / role:* labels to the
+# canonical role label. Mirrors STATUS_TRANSITIONS for the role dimension.
+ROLE_TRANSITIONS: dict[str, str] = {
+    "author": "role:author",
+    "reviewer": "role:reviewer",
+    "merger": "role:merger",
+}
+
+# #603: hazard flag synonyms. Hazards are additive (not single-active), so this
+# only normalizes names; it does not drive replacement.
+HAZARD_TRANSITIONS: dict[str, str] = {
+    "stale_lease": "hazard:stale-lease",
+    "stale-lease": "hazard:stale-lease",
+    "workflow_contaminated": "hazard:workflow-contaminated",
+    "workflow-contaminated": "hazard:workflow-contaminated",
+    "contaminated": "hazard:workflow-contaminated",
+    "conflicted": "hazard:conflicted",
+    "conflict": "hazard:conflicted",
+    "root_mutation": "hazard:root-mutation",
+    "root-mutation": "hazard:root-mutation",
+    "manual_state": "hazard:manual-state",
+    "manual-state": "hazard:manual-state",
+    "terminal_blocker": "hazard:terminal-blocker",
+    "terminal-blocker": "hazard:terminal-blocker",
 }
 
 
@@ -155,6 +233,100 @@ def transition_status_labels(
     return kept
 
 
+def role_labels(labels: Iterable[str | Mapping[str, object]] | Mapping[str, object]) -> list[str]:
+    return [name for name in label_names(labels) if name.startswith("role:")]
+
+
+def hazard_labels(labels: Iterable[str | Mapping[str, object]] | Mapping[str, object]) -> list[str]:
+    return [name for name in label_names(labels) if name.startswith("hazard:")]
+
+
+def canonical_role_label(role_or_transition: str) -> str:
+    role = role_or_transition.strip()
+    if role in ROLE_LABELS:
+        return role
+    normalized = role.lower().replace(" ", "-")
+    try:
+        return ROLE_TRANSITIONS[normalized]
+    except KeyError as exc:
+        raise ValueError(
+            f"unknown workflow role or transition '{role_or_transition}'"
+        ) from exc
+
+
+def transition_role_labels(
+    existing_labels: Iterable[str | Mapping[str, object]] | Mapping[str, object],
+    role_or_transition: str,
+) -> list[str]:
+    """Replace all active role labels with the requested canonical role."""
+    new_role = canonical_role_label(role_or_transition)
+    kept = [name for name in label_names(existing_labels) if not name.startswith("role:")]
+    if new_role not in kept:
+        kept.append(new_role)
+    return kept
+
+
+def canonical_hazard_label(hazard: str) -> str:
+    name = hazard.strip()
+    if name in HAZARD_LABELS:
+        return name
+    normalized = name.lower().replace(" ", "-")
+    try:
+        return HAZARD_TRANSITIONS[normalized]
+    except KeyError as exc:
+        raise ValueError(f"unknown workflow hazard '{hazard}'") from exc
+
+
+def add_hazard_label(
+    existing_labels: Iterable[str | Mapping[str, object]] | Mapping[str, object],
+    hazard: str,
+) -> list[str]:
+    """Add a hazard flag without disturbing status/role/type labels (additive)."""
+    new_hazard = canonical_hazard_label(hazard)
+    kept = label_names(existing_labels)
+    if new_hazard not in kept:
+        kept.append(new_hazard)
+    return kept
+
+
+def clear_hazard_label(
+    existing_labels: Iterable[str | Mapping[str, object]] | Mapping[str, object],
+    hazard: str,
+) -> list[str]:
+    """Remove a single hazard flag, leaving all other labels intact."""
+    target = canonical_hazard_label(hazard)
+    return [name for name in label_names(existing_labels) if name != target]
+
+
+def is_discussion(labels: Iterable[str | Mapping[str, object]] | Mapping[str, object]) -> bool:
+    return "type:discussion" in type_labels(labels)
+
+
+def is_implementation_candidate(
+    labels: Iterable[str | Mapping[str, object]] | Mapping[str, object],
+) -> bool:
+    """Whether an item may enter an implementation queue on labels alone.
+
+    Discussion issues are excluded (#603 AC3) unless a controller explicitly
+    selects them; the allocator still cross-checks live lease/PR state and never
+    trusts labels alone (#603 AC2).
+    """
+    return not is_discussion(labels)
+
+
+def requires_blocking_reason(
+    labels: Iterable[str | Mapping[str, object]] | Mapping[str, object],
+) -> bool:
+    """Whether the item must carry a blocking-reason / next-action comment (AC4).
+
+    True when blocked or when any hazard flag is present.
+    """
+    names = label_names(labels)
+    if "status:blocked" in names:
+        return True
+    return any(name.startswith("hazard:") for name in names)
+
+
 def labels_for_new_issue(
     issue_type: str | None = None,
     initial_status: str | None = None,
@@ -188,6 +360,8 @@ def assess_issue_labels(
     names = label_names(labels)
     found_types = type_labels(names)
     found_statuses = status_labels(names)
+    found_roles = role_labels(names)
+    found_hazards = hazard_labels(names)
     errors: list[str] = []
     warnings: list[str] = []
 
@@ -202,6 +376,10 @@ def assess_issue_labels(
             "issue has multiple active status:* labels: "
             + ", ".join(found_statuses)
         )
+    if len(found_roles) > 1:
+        errors.append(
+            "issue has multiple active role:* labels: " + ", ".join(found_roles)
+        )
 
     for name in found_types:
         if name not in TYPE_LABELS:
@@ -209,12 +387,20 @@ def assess_issue_labels(
     for name in found_statuses:
         if name not in STATUS_LABELS:
             warnings.append(f"unknown status label '{name}'")
+    for name in found_roles:
+        if name not in ROLE_LABELS:
+            warnings.append(f"unknown role label '{name}'")
+    for name in found_hazards:
+        if name not in HAZARD_LABELS:
+            warnings.append(f"unknown hazard label '{name}'")
 
     return {
         "valid": not errors,
         "labels": names,
         "type_labels": found_types,
         "status_labels": found_statuses,
+        "role_labels": found_roles,
+        "hazard_labels": found_hazards,
         "errors": errors,
         "warnings": warnings,
     }

manage_labels.py

@@ -22,7 +22,7 @@ venv_python = os.path.join(PROJECT_ROOT, "venv", "bin", "python3")
 if os.path.exists(venv_python) and sys.executable != venv_python:
     os.execv(venv_python, [venv_python] + sys.argv)
 
-from gitea_auth import get_auth_header, api_request, repo_api_url
+from gitea_auth import get_auth_header, api_request, api_get_all, repo_api_url
 import issue_workflow_labels
 
 HOST = "gitea.dadeschools.net"
@@ -82,9 +82,17 @@ def api(method, path, auth, payload=None):
 
 
 def _labels_by_name(auth):
-    """Return {label name: id} for the repo's existing labels."""
-    existing = api("GET", "/labels?limit=100", auth) or []
-    return {lb["name"]: lb["id"] for lb in existing}
+    """Return {label name: id} for the repo's existing labels (all pages, #627)."""
+    existing = api_get_all(f"{BASE_URL}/labels", auth) or []
+    name_to_id = {}
+    for lb in existing:
+        if not isinstance(lb, dict):
+            continue
+        name = lb.get("name")
+        lid = lb.get("id")
+        if name and lid is not None and name not in name_to_id:
+            name_to_id[name] = lid
+    return name_to_id
 
 
 def create_labels(auth, dry=False):

mark_issue.py

@@ -17,7 +17,7 @@ if os.path.exists(venv_python) and sys.executable != venv_python:
 
 from gitea_auth import (
     get_auth_header, resolve_remote, add_remote_args,
-    api_request, repo_api_url,
+    api_request, api_get_all, repo_api_url,
 )
 
 LABEL_NAME = "status:in-progress"
@@ -45,12 +45,12 @@ def main(argv=None):
     base = repo_api_url(host, org, repo)
 
     try:
-        # Find the label ID
-        labels = api_request("GET", f"{base}/labels?limit=100", auth)
+        # Paginated inventory (#627): Gitea caps single pages at 50.
+        labels = api_get_all(f"{base}/labels", auth) or []
         label_id = None
         for lb in labels:
-            if lb["name"] == LABEL_NAME:
-                label_id = lb["id"]
+            if lb.get("name") == LABEL_NAME:
+                label_id = lb.get("id")
                 break
 
         if label_id is None:

tests/test_issue_workflow_labels.py

@@ -69,5 +69,139 @@ class TestIssueWorkflowStatusTransitions(unittest.TestCase):
         self.assertEqual(result, ["type:process", "status:duplicate"])
 
 
+class TestLifecycleRoleLabels(unittest.TestCase):
+    def test_role_transition_author_to_reviewer_to_merger_single_active(self):
+        after_author = labels.transition_role_labels(
+            ["type:feature", "status:pr-open"], "author"
+        )
+        self.assertEqual(after_author, ["type:feature", "status:pr-open", "role:author"])
+
+        after_reviewer = labels.transition_role_labels(after_author, "reviewer")
+        self.assertEqual(
+            after_reviewer, ["type:feature", "status:pr-open", "role:reviewer"]
+        )
+        self.assertNotIn("role:author", after_reviewer)
+
+        after_merger = labels.transition_role_labels(after_reviewer, "merger")
+        self.assertEqual(labels.role_labels(after_merger), ["role:merger"])
+
+    def test_role_transition_accepts_canonical_label(self):
+        result = labels.transition_role_labels(["type:bug"], "role:reviewer")
+        self.assertEqual(result, ["type:bug", "role:reviewer"])
+
+    def test_unknown_role_raises(self):
+        with self.assertRaises(ValueError):
+            labels.canonical_role_label("wizard")
+
+    def test_assess_reports_multiple_active_role_labels(self):
+        result = labels.assess_issue_labels(
+            ["type:feature", "status:pr-open", "role:author", "role:reviewer"]
+        )
+        self.assertFalse(result["valid"])
+        self.assertTrue(
+            any("multiple active role:* labels" in err for err in result["errors"])
+        )
+        self.assertEqual(
+            sorted(result["role_labels"]), ["role:author", "role:reviewer"]
+        )
+
+
+class TestLifecycleHazardLabels(unittest.TestCase):
+    def test_hazards_are_additive_and_multiple(self):
+        one = labels.add_hazard_label(["type:bug", "status:blocked"], "conflicted")
+        two = labels.add_hazard_label(one, "stale-lease")
+        self.assertIn("hazard:conflicted", two)
+        self.assertIn("hazard:stale-lease", two)
+        # status/type untouched
+        self.assertIn("status:blocked", two)
+        self.assertIn("type:bug", two)
+        self.assertEqual(len(labels.hazard_labels(two)), 2)
+
+    def test_add_hazard_is_idempotent(self):
+        once = labels.add_hazard_label(["type:bug", "status:ready"], "root-mutation")
+        twice = labels.add_hazard_label(once, "root_mutation")
+        self.assertEqual(twice.count("hazard:root-mutation"), 1)
+
+    def test_clear_hazard_leaves_others_intact(self):
+        start = ["type:bug", "status:blocked", "hazard:conflicted", "hazard:stale-lease"]
+        cleared = labels.clear_hazard_label(start, "conflicted")
+        self.assertNotIn("hazard:conflicted", cleared)
+        self.assertIn("hazard:stale-lease", cleared)
+        self.assertIn("status:blocked", cleared)
+
+    def test_terminal_blocker_hazard_normalizes(self):
+        self.assertEqual(
+            labels.canonical_hazard_label("terminal-blocker"),
+            "hazard:terminal-blocker",
+        )
+
+    def test_assess_surfaces_hazard_labels(self):
+        result = labels.assess_issue_labels(
+            ["type:bug", "status:blocked", "hazard:conflicted"]
+        )
+        self.assertEqual(result["hazard_labels"], ["hazard:conflicted"])
+
+
+class TestDiscussionExclusion(unittest.TestCase):
+    def test_discussion_issue_excluded_from_implementation_queue(self):
+        self.assertTrue(labels.is_discussion(["type:discussion", "status:ready"]))
+        self.assertFalse(
+            labels.is_implementation_candidate(["type:discussion", "status:ready"])
+        )
+
+    def test_non_discussion_issue_is_candidate(self):
+        self.assertTrue(
+            labels.is_implementation_candidate(["type:feature", "status:ready"])
+        )
+
+
+class TestBlockingReasonRequirement(unittest.TestCase):
+    def test_blocked_requires_reason(self):
+        self.assertTrue(
+            labels.requires_blocking_reason(["type:bug", "status:blocked"])
+        )
+
+    def test_hazard_requires_reason(self):
+        self.assertTrue(
+            labels.requires_blocking_reason(
+                ["type:bug", "status:ready", "hazard:stale-lease"]
+            )
+        )
+
+    def test_clean_ready_issue_needs_no_reason(self):
+        self.assertFalse(
+            labels.requires_blocking_reason(["type:feature", "status:ready"])
+        )
+
+
+class TestState603SynonymTransitions(unittest.TestCase):
+    def test_authoring_maps_to_in_progress(self):
+        self.assertEqual(
+            labels.canonical_status_label("authoring"), "status:in-progress"
+        )
+
+    def test_changes_requested_transition(self):
+        result = labels.transition_status_labels(
+            ["type:feature", "status:needs-review"], "changes-requested"
+        )
+        self.assertEqual(result, ["type:feature", "status:changes-requested"])
+
+    def test_merge_ready_maps_to_approved(self):
+        self.assertEqual(labels.canonical_status_label("merge-ready"), "status:approved")
+
+    def test_abandoned_maps_to_wontfix(self):
+        self.assertEqual(labels.canonical_status_label("abandoned"), "status:wontfix")
+
+    def test_blocked_and_merged_transitions(self):
+        blocked = labels.transition_status_labels(
+            ["type:bug", "status:in-progress"], "blocked"
+        )
+        self.assertEqual(blocked, ["type:bug", "status:blocked"])
+        merged = labels.transition_status_labels(
+            ["type:feature", "status:approved"], "merged"
+        )
+        self.assertEqual(merged, ["type:feature", "status:reconcile"])
+
+
 if __name__ == "__main__":
     unittest.main()

tests/test_manage_labels.py

@@ -28,33 +28,31 @@ class TestLabelCreation(unittest.TestCase):
     """Verify create-or-skip logic for the label set."""
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all")
     @patch("manage_labels.api")
-    def test_skips_existing_labels(self, mock_api, _auth):
-        # Simulate all labels already exist
+    def test_skips_existing_labels(self, mock_api, mock_get_all, _auth):
+        # Simulate all labels already exist (paginated inventory #627)
         existing = [_make_label(l["name"], i) for i, l in enumerate(manage_labels.LABELS)]
-        mock_api.return_value = existing  # first call is GET /labels
+        mock_get_all.return_value = existing
 
         # Patch sys.argv to avoid --dry
         with patch.object(sys, "argv", ["manage_labels.py"]):
             with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
                 manage_labels.main()
 
-        # The GET call happens, but no POST calls for label creation
-        get_calls = [c for c in mock_api.call_args_list if c[0][0] == "GET"]
+        mock_get_all.assert_called()
         post_label_calls = [
             c for c in mock_api.call_args_list
             if c[0][0] == "POST" and c[0][1] == "/labels"
         ]
-        self.assertGreaterEqual(len(get_calls), 1)
         self.assertEqual(len(post_label_calls), 0)
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all", return_value=[])
     @patch("manage_labels.api")
-    def test_creates_missing_labels(self, mock_api, _auth):
+    def test_creates_missing_labels(self, mock_api, _get_all, _auth):
         # Simulate no existing labels
         def side_effect(method, path, auth, payload=None):
-            if method == "GET" and "/labels" in path:
-                return []  # no existing labels
             if method == "POST" and path == "/labels":
                 return {"id": 999, "name": payload["name"]}
             if method == "PUT":
@@ -79,15 +77,14 @@ class TestLabelCreation(unittest.TestCase):
 class TestDryRun(unittest.TestCase):
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all", return_value=[])
     @patch("manage_labels.api")
-    def test_dry_run_makes_no_writes(self, mock_api, _auth):
-        mock_api.return_value = []  # no existing labels
-
+    def test_dry_run_makes_no_writes(self, mock_api, _get_all, _auth):
         with patch.object(sys, "argv", ["manage_labels.py", "--dry"]):
             with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
                 manage_labels.main()
 
-        # Only the GET call should be made, no POST or PUT
+        # Dry run should not call write methods via api()
         for c in mock_api.call_args_list:
             method = c[0][0]
             self.assertEqual(method, "GET",
@@ -100,13 +97,13 @@ class TestDryRun(unittest.TestCase):
 class TestLabelMapping(unittest.TestCase):
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all")
     @patch("manage_labels.api")
-    def test_applies_mapping_to_issues(self, mock_api, _auth):
+    def test_applies_mapping_to_issues(self, mock_api, mock_get_all, _auth):
         existing = [_make_label(l["name"], i + 1) for i, l in enumerate(manage_labels.LABELS)]
+        mock_get_all.return_value = existing
 
         def side_effect(method, path, auth, payload=None):
-            if method == "GET":
-                return existing
             if method == "PUT":
                 return [{"name": "applied"}]
             return None
@@ -158,11 +155,10 @@ class TestModes(unittest.TestCase):
         return [(c[0][0], c[0][1]) for c in mock_api.call_args_list]
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all", return_value=[])
     @patch("manage_labels.api")
-    def test_create_labels_only_no_mapping(self, mock_api, _auth):
+    def test_create_labels_only_no_mapping(self, mock_api, _get_all, _auth):
         def se(method, path, auth, payload=None):
-            if method == "GET":
-                return []  # no existing labels
             if method == "POST" and path == "/labels":
                 return {"id": 1, "name": payload["name"]}
             return None
@@ -173,14 +169,14 @@ class TestModes(unittest.TestCase):
         self.assertFalse(any(m[0] == "PUT" for m in methods))  # no mapping applied
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all")
     @patch("manage_labels.api")
-    def test_apply_mapping_only_no_label_creation(self, mock_api, _auth):
+    def test_apply_mapping_only_no_label_creation(self, mock_api, mock_get_all, _auth):
         existing = [_make_label(l["name"], i + 1)
                     for i, l in enumerate(manage_labels.LABELS)]
+        mock_get_all.return_value = existing
 
         def se(method, path, auth, payload=None):
-            if method == "GET":
-                return existing
             if method == "PUT":
                 return [{"name": "applied"}]
             return None
@@ -192,13 +188,10 @@ class TestModes(unittest.TestCase):
         self.assertEqual(len(put_calls), len(manage_labels.MAPPING))
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all", return_value=[_make_label("chore", 5)])
     @patch("manage_labels.api")
-    def test_add_label_appends_to_issue(self, mock_api, _auth):
-        existing = [_make_label("chore", 5)]
-
+    def test_add_label_appends_to_issue(self, mock_api, _get_all, _auth):
         def se(method, path, auth, payload=None):
-            if method == "GET":
-                return existing
             if method == "POST":
                 return [{"name": "chore"}]
             return None
@@ -212,19 +205,21 @@ class TestModes(unittest.TestCase):
         self.assertFalse(any(c[0][0] == "PUT" for c in mock_api.call_args_list))
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all", return_value=[])
     @patch("manage_labels.api")
-    def test_add_label_unknown_makes_no_write(self, mock_api, _auth):
-        mock_api.side_effect = lambda *a, **k: [] if a[0] == "GET" else None
+    def test_add_label_unknown_makes_no_write(self, mock_api, _get_all, _auth):
         manage_labels.main(["--add-label", "42", "ghost"])
-        # Only the GET label lookup; no POST/PUT for an undefined label.
-        self.assertTrue(all(c[0][0] == "GET" for c in mock_api.call_args_list))
+        # No write via api() for an undefined label.
+        self.assertTrue(all(c[0][0] == "GET" for c in mock_api.call_args_list)
+                        or len(mock_api.call_args_list) == 0)
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
+    @patch("manage_labels.api_get_all", return_value=[_make_label("chore", 5)])
     @patch("manage_labels.api")
-    def test_add_label_dry_makes_no_write(self, mock_api, _auth):
-        mock_api.side_effect = lambda *a, **k: [_make_label("chore", 5)] if a[0] == "GET" else None
+    def test_add_label_dry_makes_no_write(self, mock_api, _get_all, _auth):
         manage_labels.main(["--dry", "--add-label", "42", "chore"])
-        self.assertTrue(all(c[0][0] == "GET" for c in mock_api.call_args_list))
+        self.assertTrue(all(c[0][0] == "GET" for c in mock_api.call_args_list)
+                        or len(mock_api.call_args_list) == 0)
 
     @patch("manage_labels.get_auth_header", return_value=FAKE_AUTH)
     @patch("manage_labels.api")

tests/test_python_cli.py

@@ -64,54 +64,45 @@ class TestMarkIssueCLI(unittest.TestCase):
         with self.assertRaises(SystemExit):
             mark_issue.main(["10", "bogus_action"])
 
+    @patch("mark_issue.api_get_all", return_value=[{"id": 101, "name": "status:in-progress"}])
     @patch("mark_issue.api_request")
     @patch("mark_issue.get_auth_header", return_value=FAKE_AUTH)
-    def test_successful_start(self, _auth, mock_api):
-        # First call is GET labels, second is POST label
-        mock_api.side_effect = [
-            [{"id": 101, "name": "status:in-progress"}],
-            [{"name": "status:in-progress"}],
-        ]
+    def test_successful_start(self, _auth, mock_api, mock_get_all):
+        mock_api.return_value = [{"name": "status:in-progress"}]
         with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
             rc = mark_issue.main(["15", "start"])
         self.assertEqual(rc, 0)
-        self.assertEqual(mock_api.call_count, 2)
-        
-        # Verify GET labels call
-        get_call = mock_api.call_args_list[0]
-        self.assertEqual(get_call[0][0], "GET")
-        self.assertIn("/labels?limit=100", get_call[0][1])
+        mock_get_all.assert_called()
+        self.assertIn("/labels", mock_get_all.call_args[0][0])
 
         # Verify POST labels call
-        post_call = mock_api.call_args_list[1]
+        post_call = mock_api.call_args_list[0]
         self.assertEqual(post_call[0][0], "POST")
         self.assertIn("/issues/15/labels", post_call[0][1])
         self.assertEqual(post_call[0][3], {"labels": [101]})
 
+    @patch("mark_issue.api_get_all", return_value=[{"id": 101, "name": "status:in-progress"}])
     @patch("mark_issue.api_request")
     @patch("mark_issue.get_auth_header", return_value=FAKE_AUTH)
-    def test_successful_done(self, _auth, mock_api):
-        # First call is GET labels, second is DELETE label
-        mock_api.side_effect = [
-            [{"id": 101, "name": "status:in-progress"}],
-            None,
-        ]
+    def test_successful_done(self, _auth, mock_api, _get_all):
+        mock_api.return_value = None
         rc = mark_issue.main(["15", "done"])
         self.assertEqual(rc, 0)
-        self.assertEqual(mock_api.call_count, 2)
+        self.assertEqual(mock_api.call_count, 1)
 
         # Verify DELETE labels call
-        delete_call = mock_api.call_args_list[1]
+        delete_call = mock_api.call_args_list[0]
         self.assertEqual(delete_call[0][0], "DELETE")
         self.assertIn("/issues/15/labels/101", delete_call[0][1])
 
+    @patch("mark_issue.api_get_all", return_value=[{"id": 1, "name": "bug"}])
     @patch("mark_issue.api_request")
     @patch("mark_issue.get_auth_header", return_value=FAKE_AUTH)
-    def test_label_not_found(self, _auth, mock_api):
-        # GET labels returns no status:in-progress label
-        mock_api.return_value = [{"id": 1, "name": "bug"}]
+    def test_label_not_found(self, _auth, mock_api, _get_all):
+        # Paginated inventory returns no status:in-progress label
         rc = mark_issue.main(["15", "start"])
         self.assertEqual(rc, 1)
+        mock_api.assert_not_called()
 
 
 if __name__ == "__main__":

tests/test_set_issue_labels_pagination.py

@@ -0,0 +1,318 @@
+"""#627: paginated repository-label resolution for gitea_set_issue_labels.
+
+Reproduces the post-merge #601 reconciliation failure where later-page
+labels (e.g. type:feature, workflow-hardening) were falsely rejected as
+nonexistent because inventory used a single-page GET labels?limit=100.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from unittest.mock import patch, call
+
+sys.path.insert(0, str(__import__("pathlib").Path(__file__).resolve().parent.parent))
+
+import mcp_server
+import gitea_auth
+
+
+FAKE_AUTH = "token test-token"
+PAGE_SIZE = 50  # Gitea effective max; see gitea_auth.api_get_all
+
+
+def _lb(name: str, lid: int) -> dict:
+    return {"id": lid, "name": name, "color": "000000"}
+
+
+def _pages(labels: list[dict], page_size: int = PAGE_SIZE) -> list[list[dict]]:
+    if not labels:
+        return [[]]
+    pages = []
+    for i in range(0, len(labels), page_size):
+        pages.append(labels[i : i + page_size])
+    return pages
+
+
+class TestRepoLabelIdMapPagination(unittest.TestCase):
+    """_repo_label_id_map must use api_get_all (all pages)."""
+
+    @patch("mcp_server.api_get_all")
+    def test_fewer_than_one_page(self, mock_all):
+        labels = [_lb(f"l{i}", i) for i in range(3)]
+        mock_all.return_value = labels
+        m = mcp_server._repo_label_id_map("https://gitea.example/api/v1/repos/o/r", FAKE_AUTH)
+        self.assertEqual(m, {"l0": 0, "l1": 1, "l2": 2})
+        mock_all.assert_called_once()
+        self.assertIn("/labels", mock_all.call_args[0][0])
+        self.assertNotIn("limit=100", mock_all.call_args[0][0])
+
+    @patch("mcp_server.api_get_all")
+    def test_exactly_one_full_page(self, mock_all):
+        labels = [_lb(f"l{i:03d}", i) for i in range(PAGE_SIZE)]
+        mock_all.return_value = labels
+        m = mcp_server._repo_label_id_map("https://gitea.example/api/v1/repos/o/r", FAKE_AUTH)
+        self.assertEqual(len(m), PAGE_SIZE)
+        self.assertEqual(m["l000"], 0)
+        self.assertEqual(m[f"l{PAGE_SIZE - 1:03d}"], PAGE_SIZE - 1)
+
+    @patch("mcp_server.api_get_all")
+    def test_more_than_one_page_includes_later_labels(self, mock_all):
+        # Page 1: 50 early labels; page 2: type:feature + workflow-hardening (#601 style)
+        early = [_lb(f"early-{i:02d}", i) for i in range(PAGE_SIZE)]
+        late = [
+            _lb("type:feature", 1001),
+            _lb("workflow-hardening", 1002),
+        ]
+        mock_all.return_value = early + late
+        m = mcp_server._repo_label_id_map("https://gitea.example/api/v1/repos/o/r", FAKE_AUTH)
+        self.assertEqual(len(m), PAGE_SIZE + 2)
+        self.assertEqual(m["type:feature"], 1001)
+        self.assertEqual(m["workflow-hardening"], 1002)
+
+    @patch("mcp_server.api_get_all")
+    def test_duplicate_names_keep_first_seen_id(self, mock_all):
+        mock_all.return_value = [
+            _lb("type:feature", 103),
+            _lb("type:feature", 130),  # duplicate id later
+            _lb("workflow-hardening", 105),
+            _lb("workflow-hardening", 128),
+        ]
+        m = mcp_server._repo_label_id_map("https://gitea.example/api/v1/repos/o/r", FAKE_AUTH)
+        self.assertEqual(m["type:feature"], 103)
+        self.assertEqual(m["workflow-hardening"], 105)
+
+    @patch("mcp_server.api_get_all", return_value={"not": "a list"})
+    def test_non_list_inventory_fails_closed(self, _all):
+        with self.assertRaises(RuntimeError) as ctx:
+            mcp_server._repo_label_id_map("https://gitea.example/api/v1/repos/o/r", FAKE_AUTH)
+        self.assertIn("expected a list", str(ctx.exception).lower())
+
+    @patch("mcp_server.api_get_all", side_effect=RuntimeError("page 2 failed: connection reset"))
+    def test_later_page_failure_propagates(self, _all):
+        with self.assertRaises(RuntimeError) as ctx:
+            mcp_server._repo_label_id_map("https://gitea.example/api/v1/repos/o/r", FAKE_AUTH)
+        self.assertIn("page 2 failed", str(ctx.exception))
+
+
+class TestSetIssueLabelsPagination(unittest.TestCase):
+    """gitea_set_issue_labels full-set replacement with multi-page inventory."""
+
+    def setUp(self):
+        self._remotes = patch.dict(
+            mcp_server.REMOTES,
+            {"prgs": {"host": "gitea.example.com", "org": "Scaled-Tech-Consulting",
+                      "repo": "Gitea-Tools"}},
+        )
+        self._remotes.start()
+        # Allow mutation path without full preflight stack when possible
+        self._preflight = patch(
+            "mcp_server.verify_preflight_purity", return_value=None
+        )
+        self._preflight.start()
+        self._perm = patch(
+            "mcp_server._profile_permission_block", return_value=None
+        )
+        self._perm.start()
+        self._auth = patch(
+            "mcp_server._auth", return_value=FAKE_AUTH
+        )
+        self._auth.start()
+        self._audited = patch("mcp_server._audited")
+        mock_aud = self._audited.start()
+        mock_aud.return_value.__enter__ = lambda s: None
+        mock_aud.return_value.__exit__ = lambda s, *a: None
+
+    def tearDown(self):
+        self._remotes.stop()
+        self._preflight.stop()
+        self._perm.stop()
+        self._auth.stop()
+        self._audited.stop()
+
+    def _inventory_early_and_late(self) -> list[dict]:
+        early = [_lb(f"alpha-{i:02d}", i + 1) for i in range(PAGE_SIZE)]
+        late = [
+            _lb("type:feature", 9001),
+            _lb("workflow-hardening", 9002),
+            _lb("status:ready", 9003),
+            _lb("anti-stomp", 9004),
+            _lb("leases", 9005),
+            _lb("recovery", 9006),
+        ]
+        return early + late
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_requested_labels_split_across_pages(self, mock_all, mock_req):
+        inv = self._inventory_early_and_late()
+        mock_all.return_value = inv
+        requested = ["alpha-00", "type:feature", "workflow-hardening"]
+        mock_req.return_value = [_lb(n, inv_i["id"]) for n in requested
+                                 for inv_i in inv if inv_i["name"] == n]
+
+        res = mcp_server.gitea_set_issue_labels(
+            issue_number=601,
+            labels=requested,
+            remote="prgs",
+        )
+        self.assertEqual({lb["name"] for lb in res}, set(requested))
+        # PUT must use ids from both pages
+        put = mock_req.call_args
+        self.assertEqual(put[0][0], "PUT")
+        payload_ids = put[0][3]["labels"]
+        self.assertEqual(payload_ids, [1, 9001, 9002])
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_missing_requested_label_rejected_before_put(self, mock_all, mock_req):
+        mock_all.return_value = [_lb("bug", 1), _lb("status:ready", 2)]
+        with self.assertRaises(RuntimeError) as ctx:
+            mcp_server.gitea_set_issue_labels(
+                issue_number=9,
+                labels=["bug", "does-not-exist"],
+                remote="prgs",
+            )
+        self.assertIn("do not exist", str(ctx.exception))
+        self.assertIn("does-not-exist", str(ctx.exception))
+        mock_req.assert_not_called()
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_complete_set_preserves_later_page_labels(self, mock_all, mock_req):
+        inv = self._inventory_early_and_late()
+        mock_all.return_value = inv
+        # Full-set replacement removing only status:pr-open style stale label:
+        # keep later-page feature labels (the #601 reconciliation shape).
+        requested = [
+            "anti-stomp",
+            "leases",
+            "recovery",
+            "type:feature",
+            "workflow-hardening",
+        ]
+        mock_req.return_value = [_lb(n, next(x["id"] for x in inv if x["name"] == n))
+                                 for n in requested]
+        res = mcp_server.gitea_set_issue_labels(
+            issue_number=601, labels=requested, remote="prgs"
+        )
+        self.assertEqual([lb["name"] for lb in res], requested)
+        payload_ids = mock_req.call_args[0][3]["labels"]
+        self.assertEqual(payload_ids, [9004, 9005, 9006, 9001, 9002])
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_issue_601_regression_later_page_names_accepted(self, mock_all, mock_req):
+        """Regression: #601 reconciler rejected type:feature + workflow-hardening.
+
+        Single-page inventory would omit them; paginated inventory must accept.
+        """
+        early = [_lb(f"page1-{i:02d}", i + 1) for i in range(PAGE_SIZE)]
+        # Exactly the labels from the #601 residual set (minus status:pr-open)
+        late = [
+            _lb("type:feature", 103),
+            _lb("workflow-hardening", 105),
+            _lb("anti-stomp", 106),
+            _lb("leases", 109),
+            _lb("recovery", 110),
+        ]
+        mock_all.return_value = early + late
+        requested = [
+            "anti-stomp",
+            "leases",
+            "recovery",
+            "type:feature",
+            "workflow-hardening",
+        ]
+        mock_req.return_value = [
+            _lb(n, next(x["id"] for x in late if x["name"] == n)) for n in requested
+        ]
+        res = mcp_server.gitea_set_issue_labels(
+            issue_number=601, labels=requested, remote="prgs"
+        )
+        names = {lb["name"] for lb in res}
+        self.assertEqual(names, set(requested))
+        self.assertNotIn("status:pr-open", names)
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_duplicate_label_ids_resolve_deterministically(self, mock_all, mock_req):
+        mock_all.return_value = [
+            _lb("type:feature", 103),
+            _lb("type:feature", 130),
+            _lb("workflow-hardening", 105),
+            _lb("workflow-hardening", 128),
+        ]
+        requested = ["type:feature", "workflow-hardening"]
+        mock_req.return_value = [_lb("type:feature", 103), _lb("workflow-hardening", 105)]
+        mcp_server.gitea_set_issue_labels(
+            issue_number=1, labels=requested, remote="prgs"
+        )
+        self.assertEqual(mock_req.call_args[0][3]["labels"], [103, 105])
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_post_mutation_mismatch_fails_closed(self, mock_all, mock_req):
+        mock_all.return_value = [_lb("bug", 1), _lb("status:ready", 2)]
+        # Server returns incomplete set → verification must fail
+        mock_req.return_value = [_lb("bug", 1)]
+        with self.assertRaises(RuntimeError) as ctx:
+            mcp_server.gitea_set_issue_labels(
+                issue_number=9,
+                labels=["bug", "status:ready"],
+                remote="prgs",
+            )
+        self.assertIn("Post-mutation label verification failed", str(ctx.exception))
+        self.assertIn("status:ready", str(ctx.exception))
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all", side_effect=RuntimeError("Gitea 502 on page 2"))
+    def test_pagination_failure_fails_closed_before_put(self, _all, mock_req):
+        with self.assertRaises(RuntimeError) as ctx:
+            mcp_server.gitea_set_issue_labels(
+                issue_number=9, labels=["bug"], remote="prgs"
+            )
+        self.assertIn("page 2", str(ctx.exception))
+        mock_req.assert_not_called()
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_empty_label_set_clears_all(self, mock_all, mock_req):
+        mock_all.return_value = [_lb("bug", 1)]
+        mock_req.return_value = []
+        res = mcp_server.gitea_set_issue_labels(
+            issue_number=9, labels=[], remote="prgs"
+        )
+        self.assertEqual(res, [])
+        self.assertEqual(mock_req.call_args[0][3]["labels"], [])
+
+    @patch("mcp_server.api_request")
+    @patch("mcp_server.api_get_all")
+    def test_does_not_call_single_page_limit_100(self, mock_all, mock_req):
+        mock_all.return_value = [_lb("bug", 1)]
+        mock_req.return_value = [_lb("bug", 1)]
+        mcp_server.gitea_set_issue_labels(
+            issue_number=9, labels=["bug"], remote="prgs"
+        )
+        for c in mock_req.call_args_list:
+            url = c[0][1] if len(c[0]) > 1 else ""
+            self.assertNotIn("labels?limit=100", str(url))
+        mock_all.assert_called()
+
+
+class TestApiGetAllPageCapDocumentsGiteaLimit(unittest.TestCase):
+    """Sanity: api_get_all clamps page_size to 50 (root cause of limit=100 trap)."""
+
+    @patch("gitea_auth.api_request")
+    def test_page_size_clamped_to_fifty(self, mock_req):
+        mock_req.return_value = []
+        gitea_auth.api_get_all("https://gitea.example/api/v1/repos/o/r/labels",
+                               FAKE_AUTH, page_size=100)
+        # First (only) call must use limit=50, not 100
+        url = mock_req.call_args[0][1]
+        self.assertIn("limit=50", url)
+        self.assertNotIn("limit=100", url)
+
+
+if __name__ == "__main__":
+    unittest.main()