raise-cli 3.1.1__tar.gz → 3.1.3__tar.gz

{raise_cli-3.1.1 → raise_cli-3.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raise-cli
-Version: 3.1.1
+Version: 3.1.3
 Summary: RaiSE CLI - Reliable AI Software Engineering governance framework
 Project-URL: Homepage, https://raiseframework.ai
 Project-URL: Documentation, https://docs.raiseframework.ai
@@ -33,8 +33,9 @@ Requires-Dist: pydantic>=2.6.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: qrcode>=8.2
-Requires-Dist: raise-core==3.1.1
+Requires-Dist: raise-core==3.1.3
 Requires-Dist: rich>=13.7.0
+Requires-Dist: ruamel-yaml>=0.18
 Requires-Dist: textual>=0.89.0
 Requires-Dist: tokenizers>=0.19
 Requires-Dist: tree-sitter-c-sharp>=0.23.1

{raise_cli-3.1.1 → raise_cli-3.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "raise-cli"
-version = "3.1.1"
+version = "3.1.3"
 description = "RaiSE CLI - Reliable AI Software Engineering governance framework"
 authors = [
     {name = "Emilio Osorio", email = "emilio@humansys.ai"}
@@ -21,13 +21,14 @@ classifiers = [
 ]
 
 dependencies = [
-    "raise-core==3.1.1",
+    "raise-core==3.1.3",
     "typer>=0.12.0",
     "rich>=13.7.0",
     "pydantic>=2.6.0",
     "pydantic-settings>=2.2.0",
     "python-dotenv>=1.0.0",
     "pyyaml>=6.0.1",
+    "ruamel.yaml>=0.18",
     "packaging>=24.0",
     "networkx>=3.6.1",
     "tree-sitter>=0.25.2",
@@ -149,6 +150,7 @@ governance-trail-ci = "raise_cli.gates.governance.governance_trail_ci_gate:Gover
 gate-public-mirror-push = "raise_cli.gates.governance.public_mirror_push_gate:PublicMirrorPushGate"
 domain-model-ratified = "raise_cli.gates.ddd.domain_model_ratified_gate:DomainModelRatifiedGate"
 ddd-tactical-drift = "raise_cli.gates.ddd.tactical_drift_gate:TacticalDriftGate"
+gate-revert-scope = "raise_cli.gates.governance.revert_scope_gate:RevertScopeGate"
 
 [project.entry-points."rai.doctor.checks"]
 environment = "raise_cli.doctor.checks.environment:EnvironmentCheck"
@@ -169,7 +171,14 @@ pipeline-coverage = "raise_cli.doctor.checks.pipeline_coverage:PipelineCoverageC
 backlog-workflow-scope = "raise_cli.doctor.checks.backlog_workflow_scope:BacklogWorkflowScopeCheck"
 stash-hygiene = "raise_cli.doctor.checks.stash_hygiene:StashHygieneCheck"
 legacy-install = "raise_cli.doctor.checks.legacy_install:LegacyInstallCheck"
+legacy-residues = "raise_cli.doctor.checks.legacy_residues:LegacyResiduesCheck"
+legacy-work-items = "raise_cli.doctor.checks.legacy_work_items:LegacyWorkItemsCheck"
+graph-annotation-always-null-column = "raise_cli.doctor.checks.graph_annotations:GraphAnnotationAlwaysNullColumnCheck"
+graph-annotation-scoping-drift = "raise_cli.doctor.checks.graph_annotations:GraphAnnotationScopingDriftCheck"
 update = "raise_cli.doctor.checks.update:UpdateCheck"
+worktrees = "raise_cli.doctor.checks.worktrees:WorktreesCheck"
+session-index = "raise_cli.doctor.checks.session_index:SessionIndexCheck"
+hooks = "raise_cli.doctor.checks.hooks:HooksCheck"
 
 [project.entry-points."rai.adapters.pm"]
 filesystem = "raise_cli.adapters.filesystem:FilesystemPMAdapter"

{raise_cli-3.1.1 → raise_cli-3.1.3}/src/raise_cli/__main__.py

@@ -9,11 +9,31 @@ from raise_cli.cli.main import app
 from raise_cli.exceptions import RaiError
 
 
+def _handle_unexpected_error(error: Exception) -> None:
+    """Print unexpected exception safely — no frame locals, no traceback by default.
+
+    Frame locals are suppressed to prevent leaking API keys and tokens that may
+    be in scope when the exception occurs (RAISE-18038). Set RAI_DEBUG=1 to
+    include the full traceback for debugging.
+    """
+    import traceback
+
+    error_type = type(error).__name__
+    print(f"Unexpected error ({error_type}): {error}", file=sys.stderr)
+
+    if os.environ.get("RAI_DEBUG") == "1":
+        traceback.print_exc()
+    else:
+        print("Set RAI_DEBUG=1 for full traceback.", file=sys.stderr)
+
+
 def main() -> None:
     """Run the CLI application with error handling.
 
     Catches RaiError exceptions and displays them with proper formatting,
-    then exits with the appropriate exit code.
+    then exits with the appropriate exit code. Any other unhandled exception
+    is caught and displayed safely (without frame locals) to prevent leaking
+    API keys and tokens to the terminal and CI logs (RAISE-18038).
     """
     if os.environ.get("RAISE_TEST_BLOCK_GRAPH_BUILD") == "1" and sys.argv[1:3] == [
         "graph",
@@ -32,6 +52,9 @@ def main() -> None:
         output_format = get_output_format()
         exit_code = handle_error(error, output_format=output_format)
         sys.exit(exit_code)
+    except Exception as error:  # noqa: BLE001
+        _handle_unexpected_error(error)
+        sys.exit(1)
 
 
 if __name__ == "__main__":

{raise_cli-3.1.1 → raise_cli-3.1.3}/src/raise_cli/adapters/backlog_config.py

@@ -293,6 +293,22 @@ def derive_state_machine(  # noqa: C901
     if not state_map:
         return _empty()
 
+    # RAISE-17917: register status_mapping role-key aliases pointing at the
+    # same StateSpec as the state they resolve to. Pipeline YAMLs declare
+    # target_status using the canonical role key (e.g. "committed"), which
+    # only coincidentally matches slugify(display_name) — a real Jira typo
+    # ("Commited", one 't') otherwise makes the role key unresolvable.
+    # WorkflowStateMachine.resolve() returns the aliased StateSpec's own
+    # .slug, so alias and real-name resolution agree.
+    id_to_slug = {
+        spec.native_id: slug for slug, spec in state_map.items() if spec.native_id
+    }
+    for wf_config in sections.values():
+        for role, status_id in wf_config.status_mapping.items():
+            target_slug = id_to_slug.get(status_id)
+            if target_slug and role not in state_map:
+                state_map[role] = state_map[target_slug]
+
     # Full transition mesh — fail-open (C-2 mesh rule)
     all_slugs = frozenset(state_map.keys())
     transitions: dict[str, frozenset[str]] = {

{raise_cli-3.1.1 → raise_cli-3.1.3}/src/raise_cli/adapters/composite_pm.py

@@ -327,10 +327,18 @@ class CompositeBacklogAdapter:
                 break
         return local_ref
 
-    def _maybe_promote(self, staging_key: str, jira_key: str) -> IssueRef:
+    def _maybe_promote(
+        self,
+        staging_key: str,
+        jira_key: str,
+        *,
+        issue_type: str | None = None,
+    ) -> IssueRef:
         """Call promote_key on local adapter if supported; remove ledger entry.
 
         Returns IssueRef with jira_key on success, staging_key on any failure.
+        `issue_type` is forwarded to the self-map so the row is not seeded with
+        the key-shape default ('story' for remote-native keys, RAISE-17064).
         """
         promote = getattr(self._local, "promote_key", None)
         if promote is None:
@@ -340,7 +348,9 @@ class CompositeBacklogAdapter:
             self._wi_store.remove_jira_mapping(staging_key)
             # Self-map: jira_key → jira_key so _write_to_remotes_keyed treats it as
             # remote-native (not a local-canonical unsynced key).
-            self._wi_store.upsert_jira_mapping(jira_key, jira_key)
+            self._wi_store.upsert_jira_mapping(
+                jira_key, jira_key, issue_type=issue_type
+            )
             return IssueRef(key=jira_key)
         except Exception as exc:  # noqa: BLE001
             logger.warning(
@@ -857,9 +867,13 @@ class CompositeBacklogAdapter:
             try:
                 remote_ref: IssueRef = remote.create_issue(project_key, spec)
                 if not skip_ledger_update:
-                    self._wi_store.upsert_jira_mapping(op.key, remote_ref.key)
+                    self._wi_store.upsert_jira_mapping(
+                        op.key, remote_ref.key, issue_type=spec.issue_type
+                    )
                 completed.append(i)
-                promoted_ref = self._maybe_promote(op.key, remote_ref.key)
+                promoted_ref = self._maybe_promote(
+                    op.key, remote_ref.key, issue_type=spec.issue_type
+                )
                 with contextlib.suppress(Exception):
                     self._reconcile_local_mirror(
                         promoted_ref.key, remote_ref.key, remote

{raise_cli-3.1.1 → raise_cli-3.1.3}/src/raise_cli/adapters/filesystem.py

@@ -137,7 +137,7 @@ class FilesystemPMAdapter:
         """Resolve path for key; raises KeyError if not found."""
         path = self._resolve_item_path(key)
         if path is None:
-            raise KeyError(key)
+            raise KeyError(f"Issue {key} not found")
         return path
 
     def _load_item(self, key: str) -> BacklogItem:
@@ -508,7 +508,7 @@ class FilesystemPMAdapter:
         """
         old_path = self._resolve_item_path(old_key)
         if old_path is None:
-            raise KeyError(old_key)
+            raise KeyError(f"Issue {old_key} not found")
 
         # Load, update key field, determine new path
         raw = yaml.safe_load(old_path.read_text(encoding="utf-8"))

{raise_cli-3.1.1 → raise_cli-3.1.3}/src/raise_cli/adapters/graph_refresh.py

@@ -48,7 +48,10 @@ from raise_cli.adapters.models import (
 from raise_cli.adapters.protocols import SyncVerifiable
 from raise_cli.config.paths import checkout_scope_id
 from raise_cli.storage.connection import get_project_db_path, get_project_id
-from raise_core.cartridges.backlog_items import build_backlog_item_node
+from raise_core.cartridges.backlog_items import (
+    backlog_item_key,
+    build_backlog_item_node,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -126,14 +129,12 @@ def _upsert_items_json(items_path: Path, node: dict[str, Any], key: str) -> None
     else:
         nodes = []
 
-    # Match on both field names: a cartridge written before the jira_key→key
-    # rename (RAISE-16940) still carries `jira_key`, and matching only the new
-    # name would leave the stale entry behind and append a duplicate.
-    def _node_key(n: dict[str, Any]) -> object:
-        meta = n.get("metadata", {})
-        return meta.get("key") or meta.get("jira_key")
-
-    nodes = [n for n in nodes if _node_key(n) != key]
+    # backlog_item_key matches on both field names: a cartridge written before
+    # the jira_key→key rename (RAISE-16940) still carries `jira_key`, and
+    # matching only the new name would leave the stale entry behind and
+    # append a duplicate. Shared with generate_backlog_items_cartridge's bulk
+    # merge (RAISE-17005 D6.1) so both merge strategies never drift.
+    nodes = [n for n in nodes if backlog_item_key(n) != key]
     nodes.append(node)
 
     items_path.parent.mkdir(parents=True, exist_ok=True)
@@ -257,17 +258,13 @@ class GraphRefreshAdapter:
         """
         self._delegate.remove_link(link_id)
 
-    # -- Pass-through: comments -----------------------------------------------
+    # -- Comments (refresh after RAISE-17002) -----------------------------------
 
     def add_comment(self, key: str, body: str) -> CommentRef:
-        """Delegate untouched — comments are not part of the node.
-
-        `build_backlog_item_node` derives content and metadata from
-        key/status/type/summary/priority/labels/parent/assignee only, so a
-        comment cannot change the node. Refreshing here would be a wasted
-        round-trip.
-        """
-        return self._delegate.add_comment(key, body)  # type: ignore[no-any-return]
+        """Delegate then refresh — comments now live in node metadata (D-S2.7)."""
+        ref: CommentRef = self._delegate.add_comment(key, body)  # type: ignore[no-any-return]
+        self._refresh_node(key)
+        return ref
 
     def get_comments(
         self, key: str, limit: int = 10, offset: int = 0, fetch_all: bool = False

{raise_cli-3.1.1 → raise_cli-3.1.3}/src/raise_cli/adapters/jira_adapter.py

@@ -17,7 +17,7 @@ import os
 import re
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, Final
 
 from raise_cli.adapters.backlog_config import load_backlog_config, save_backlog_config
 from raise_cli.adapters.jira_adf import adf_to_markdown, markdown_to_adf
@@ -92,6 +92,45 @@ def normalize_status(status: str) -> str:
     return status.replace("-", " ").title()
 
 
+# ── Read-path field allowlist (RAISE-17001) ─────────────────────────
+
+# Fixed system block. Includes the five D2 fields (description, comment,
+# issuelinks, created, updated) so RAISE-17001 and RAISE-17002 stay
+# independent (epic design C3).
+# NEVER add customfield_* here — custom ids come from backlog.yaml
+# custom_fields (DD7); field_types is an uncurated auto-cache and must
+# never feed this constant or read_field_list (DD1).
+_SYSTEM_FIELDS: Final[tuple[str, ...]] = (
+    "summary",
+    "status",
+    "issuetype",
+    "parent",
+    "assignee",
+    "priority",
+    "labels",
+    "fixVersions",
+    "description",
+    "comment",
+    "issuelinks",
+    "created",
+    "updated",
+)
+
+
+def read_field_list(config: BacklogAdapterConfig) -> list[str]:
+    """Fields to request from Jira on the read path (RAISE-17001).
+
+    Authority is ``backlog.yaml`` ``custom_fields`` (curated by
+    ``rai-backlog-setup``) — NOT ``field_types``, which is an uncurated
+    auto-cache that fills with the whole instance on projects without setup
+    (``_auto_cache_field_types``). Empty ``custom_fields`` yields the system
+    block only; never ``'*all'``.
+    """
+    custom = sorted({cf.id for defs in config.custom_fields.values() for cf in defs})
+    seen: set[str] = set()
+    return [f for f in (*_SYSTEM_FIELDS, *custom) if not (f in seen or seen.add(f))]
+
+
 def _normalize_link_type(
     link_type: str, relation_types: list[dict[str, Any]]
 ) -> tuple[str, bool]:
@@ -221,8 +260,17 @@ class PythonApiJiraAdapter:
     # ── Response parsers ────────────────────────────────────────────
 
     @staticmethod
-    def _extract_issue_fields(data: dict[str, Any]) -> dict[str, Any]:
-        """Extract common fields from nested Jira API format.
+    def _extract_issue_fields(
+        data: dict[str, Any],
+        *,
+        custom_field_ids: frozenset[str] | None = None,
+        field_schemas: dict[str, str | FieldSchema] | None = None,
+    ) -> dict[str, Any]:
+        """Extract common fields from nested Jira API format (RAISE-17002 D2).
+
+        Returns a dict compatible with both ``IssueSummary(**result)`` and
+        ``IssueDetail(**result, url=...)``.  Absorbs all parsing previously
+        split between this method and ``_parse_issue_detail``.
 
         Format: ``fields.summary``, ``fields.status.name``, etc.
         """
@@ -232,33 +280,11 @@ class PythonApiJiraAdapter:
         priority: dict[str, Any] | None = fields.get("priority")
         raw_sp = fields.get("customfield_10004")
         story_points: float | None = float(raw_sp) if raw_sp is not None else None
-        return {
-            "key": data.get("key", ""),
-            "summary": fields.get("summary", ""),
-            "status": fields.get("status", {}).get("name", ""),
-            "issue_type": fields.get("issuetype", {}).get("name", ""),
-            "parent_key": parent.get("key") if parent else None,
-            "assignee": assignee.get("displayName") if assignee else None,
-            "priority": priority.get("name") if priority else None,
-            "labels": fields.get("labels", []),
-            "fix_versions": [
-                str(v.get("name", ""))
-                for v in fields.get("fixVersions") or []
-                if v.get("name")
-            ],
-            "status_category": str(
-                (fields.get("status", {}).get("statusCategory") or {}).get("key", "")
-            ),
-            "story_points": story_points,
-            "metadata": PythonApiJiraAdapter._extract_custom_fields(fields),
-        }
 
-    def _parse_issue_detail(self, data: dict[str, Any]) -> IssueDetail:
-        """Parse single nested issue -> IssueDetail."""
-        common = self._extract_issue_fields(data)
-        fields: dict[str, Any] = data.get("fields") or {}
-        comment_field: dict[str, Any] = fields.get("comment") or {}
+        # D2: description
+        description = adf_to_markdown(fields.get("description", ""))
 
+        # D2: links (lifted from _parse_issue_detail)
         raw_links: list[dict[str, Any]] = fields.get("issuelinks") or []
         links: list[IssueLink] = []
         for link in raw_links:
@@ -280,29 +306,144 @@ class PythonApiJiraAdapter:
                     )
                 )
 
+        # D2: comments (lifted from _parse_issue_detail, bodies are new)
+        comment_field: dict[str, Any] = fields.get("comment") or {}
+        comment_count = int(comment_field.get("total", 0))
+        raw_comments: list[dict[str, Any]] = comment_field.get("comments") or []
+        comments: list[Comment] = [
+            Comment(
+                id=str(c.get("id", "")),
+                body=adf_to_markdown(c.get("body", "")),
+                author=c.get("author", {}).get("displayName", ""),
+                created=c.get("created", ""),
+            )
+            for c in raw_comments
+        ]
+
+        return {
+            "key": data.get("key", ""),
+            "summary": fields.get("summary", ""),
+            "status": fields.get("status", {}).get("name", ""),
+            "issue_type": fields.get("issuetype", {}).get("name", ""),
+            "parent_key": parent.get("key") if parent else None,
+            "assignee": assignee.get("displayName") if assignee else None,
+            "priority": priority.get("name") if priority else None,
+            "labels": fields.get("labels", []),
+            "fix_versions": [
+                str(v.get("name", ""))
+                for v in fields.get("fixVersions") or []
+                if v.get("name")
+            ],
+            "status_category": str(
+                (fields.get("status", {}).get("statusCategory") or {}).get("key", "")
+            ),
+            "story_points": story_points,
+            "metadata": PythonApiJiraAdapter._extract_custom_fields(
+                fields,
+                allowlist=custom_field_ids,
+                schemas=field_schemas,
+            ),
+            "description": description,
+            "created": fields.get("created", ""),
+            "updated": fields.get("updated", ""),
+            "links": links,
+            "comments": comments,
+            "comment_count": comment_count,
+        }
+
+    def _custom_field_ids(self) -> frozenset[str] | None:
+        """Derive custom field allowlist from config.custom_fields (RAISE-17002 D2).
+
+        Returns None when no custom fields are configured — callers treat
+        None as "pass all through" (backward compat for projects that have
+        not run ``rai backlog fields discover`` yet).
+        """
+        ids = frozenset(
+            cf.id for defs in self._config.custom_fields.values() for cf in defs
+        )
+        return ids if ids else None
+
+    def _parse_issue_detail(self, data: dict[str, Any]) -> IssueDetail:
+        """Parse single nested issue -> IssueDetail (RAISE-17002: delegates to _extract_issue_fields)."""
+        schemas = self._get_field_schemas(
+            self._client_for_org(self._config.default_org)
+        )
+        common = self._extract_issue_fields(
+            data,
+            custom_field_ids=self._custom_field_ids(),
+            field_schemas=schemas,
+        )
         return IssueDetail(
             **common,
             url=self._build_url(common["key"]),
-            description=adf_to_markdown(fields.get("description", "")),
-            created=fields.get("created", ""),
-            updated=fields.get("updated", ""),
-            comment_count=int(comment_field.get("total", 0)),
-            links=links,
         )
 
     @staticmethod
-    def _extract_custom_fields(fields: dict[str, Any]) -> dict[str, Any]:
-        """Surface raw ``customfield_*`` values through ``IssueDetail.metadata``.
-
-        ``IssueDetail`` only models the common Jira system fields; tool-specific
-        custom fields (Origin, Bug Type, Severity, …) were previously dropped on
-        the read path. Callers that need them (e.g. the quality lens reading
-        ``customfield_13269``) read them back from ``metadata`` keyed by raw
-        field id. Values are passed through verbatim — Jira returns custom-field
-        values in heterogeneous shapes (``{"value": ...}`` for selects, scalars
-        for text/number), so normalization is the caller's concern.
+    def _extract_custom_fields(
+        fields: dict[str, Any],
+        *,
+        allowlist: frozenset[str] | None = None,
+        schemas: dict[str, str | FieldSchema] | None = None,
+    ) -> dict[str, Any]:
+        """Surface ``customfield_*`` values through ``IssueDetail.metadata`` (RAISE-17002 D2).
+
+        When *allowlist* is provided, only fields in the allowlist are included.
+        When *allowlist* is None, falls back to passthrough (backward compat).
+
+        When *schemas* is provided, complex shapes (option dicts, arrays) are
+        flattened to scalar values so ``--filter custom_fields.X:value`` works
+        (RAISE-16889).
+        """
+        raw: dict[str, Any] = {
+            k: v for k, v in fields.items() if k.startswith("customfield_")
+        }
+        if allowlist is not None:
+            raw = {k: v for k, v in raw.items() if k in allowlist}
+
+        if schemas is None:
+            return raw
+
+        result: dict[str, Any] = {}
+        for k, v in raw.items():
+            result[k] = PythonApiJiraAdapter._flatten_custom_value(v, schemas.get(k))
+        return result
+
+    @staticmethod
+    def _flatten_dict_value(value: dict[str, Any]) -> Any:
+        """Extract scalar from a Jira dict shape (RAISE-17002 D2)."""
+        for key in ("value", "displayName", "name"):
+            if key in value:
+                return value[key]
+        return value  # unknown dict — pass through
+
+    @staticmethod
+    def _flatten_custom_value(
+        value: Any,
+        schema: str | FieldSchema | None,  # noqa: ARG004
+    ) -> Any:
+        """Flatten a Jira custom field value to scalar (RAISE-17002 D2, RAISE-16889).
+
+        Flattening rules:
+        - dict with ``"value"``/``"displayName"``/``"name"`` key: extract it
+        - list: flatten each element, join with comma
+        - scalar/None: pass through
         """
-        return {k: v for k, v in fields.items() if k.startswith("customfield_")}
+        if value is None:
+            return None
+
+        if isinstance(value, list):
+            parts = [
+                str(flat)
+                for item in value
+                if (flat := PythonApiJiraAdapter._flatten_custom_value(item, None))
+                is not None
+            ]
+            return ", ".join(parts) if parts else None
+
+        if isinstance(value, dict):
+            return PythonApiJiraAdapter._flatten_dict_value(value)
+
+        return value
 
     # ── Field schema ─────────────────────────────────────────────────
 
@@ -630,11 +771,11 @@ class PythonApiJiraAdapter:
             canonical_map = self._merged_status_mapping()
             target_name = canonical_map.get(status) or normalize_status(status)
             match = next(
-                (t for t in transitions if t["name"].lower() == target_name.lower()),
+                (t for t in transitions if t["to"].lower() == target_name.lower()),
                 None,
             )
             if not match:
-                available = [t["name"] for t in transitions]
+                available = [t["to"] for t in transitions]
                 raise JiraApiError(
                     f"No transition to '{target_name}' for {key}. Available: {available}"
                 )
@@ -691,18 +832,29 @@ class PythonApiJiraAdapter:
             if project_key is not None
             else self._client_for_org(self._config.default_org)
         )
+        fields = read_field_list(self._config)
+        schemas = self._get_field_schemas(client)
+        cf_ids = self._custom_field_ids()
+
+        def _to_summary(raw: dict[str, Any]) -> IssueSummary:
+            return IssueSummary(
+                **self._extract_issue_fields(
+                    raw, custom_field_ids=cf_ids, field_schemas=schemas
+                )
+            )
+
         if fetch_all:
-            all_raw = client.jql_all(jql)
-            return [IssueSummary(**self._extract_issue_fields(i)) for i in all_raw]
+            all_raw = client.jql_all(jql, fields=fields)
+            return [_to_summary(i) for i in all_raw]
         # Jira Cloud caps a single jql page at maxResults=100. When the requested
         # window reaches past the first page, page-walk via jql_all() (bounded by
         # cap) and truncate, instead of silently returning only 100 (RAISE-10763).
         if offset + limit > self._MAX_SINGLE_PAGE:
-            all_raw = client.jql_all(jql, cap=offset + limit)
+            all_raw = client.jql_all(jql, cap=offset + limit, fields=fields)
             window = all_raw[offset : offset + limit]
-            return [IssueSummary(**self._extract_issue_fields(i)) for i in window]
-        issues = client.jql(jql, limit=limit, start=offset)
-        return [IssueSummary(**self._extract_issue_fields(i)) for i in issues]
+            return [_to_summary(i) for i in window]
+        issues = client.jql(jql, limit=limit, start=offset, fields=fields)
+        return [_to_summary(i) for i in issues]
 
     # Jira Cloud caps a single jql/enhanced_jql page at maxResults=100.
     _MAX_SINGLE_PAGE = 100