@@ -35,5 +35,15 @@ names differently.
 A GitLab project that a Jira issue's Web links point to through a merge request or commit, other than the service
 the row belongs to. It need not be in the report.
 
+**Issue scope**:
+The Jira issues a `--jira` run was given. Its services are the projects those issues link to.
+
+**Target**:
+In an issue scope, the newest row on the default branch whose merge request or commit an issue links to. Rows run
+from the production baseline to the target.
+
+**Release tag**:
+The nearest tag at or above the target: the earliest tag that ships it. Absent when a new tag is needed.
+
 **Settled fact**:
 Data GitLab will not change for the same key, and so the only data the cache may hold.
@@ -33,6 +33,21 @@ disabled is reported with a warning and no rows, without querying it. Only a rej
 passed on the command line that the token cannot see, stops the run. A failed Jira search is recorded in the report
 and also exits `1`; the GitLab part is still written.
 
+## Jira issues
+
+`--jira` scopes the report to Jira issues instead of groups or projects, and needs the Jira settings:
+
+```sh
+uvx release-scope collect --jira SHOP-140 --jira SHOP-141 --output report.json --cache cache.json
+```
+
+It reads the issues and their GitLab links, then collects every project they link to. In each project the rows run
+from the production baseline up to the latest linked change, so they show everything that ships with the issues. The service
+records the release state: `pending` with the nearest tag at or above that change (or none, when a new tag is
+needed), `in_production` when every linked merge request is already deployed, `not_merged` when only open merge
+requests link to it, or `not_found`. Open merge requests and merges into other branches are listed either way.
+`--jira` is repeatable and cannot be combined with `--group` or `--project`; an issue Jira does not return exits `1`.
+
 ## Configuration
 
 Every setting is an environment variable; nothing about a GitLab or Jira instance is built in.
@@ -82,8 +97,9 @@ The page opens with a table of the services that have pending changes or problem
 services already up to date collapse into one expandable table. Each service with changes then has a collapsible table
 of its rows: the tag linked to its pipeline, the merge requests or direct commit, Jira keys with summary and status,
 the other services its Jira issues link to, where the change is deployed, and the failed jobs of its main-branch
-and tag pipelines. With Jira issues, the
-summary table also counts the issues per service whose status is not done.
+and tag pipelines. With Jira issues, the summary table also counts the issues per service whose status is not done.
+A `--jira` report names its issues at the top, shows the tag to release per service, and marks the rows linked to
+the issues.
 
 Chain the two commands with `;`, not `&&`: `collect` exits `1` when a service failed, which is exactly when the page
 should show it. Alert on the exit code of `collect`, not on whether to render. `render` fails only when it cannot
@@ -92,7 +108,8 @@ read the report or write the page.
 ## Cache
 
 `--cache` names a JSON file that is read if present and rewritten atomically after the run. It holds only facts
-that do not change once settled: which merge requests a commit belongs to, and the failed jobs of a finished
-pipeline keyed by its `updated_at`, so a retried job invalidates the entry. Entries the run did not use are
-dropped. A missing, corrupt, or older-schema cache is ignored with a warning; the cache only saves requests and
-never changes the report.
+that do not change once settled: which merge requests a commit belongs to, a merged merge request, and the failed
+jobs of a finished pipeline keyed by its `updated_at`, so a retried job invalidates the entry. Within each project
+the run collected, entries it did not use are dropped; other projects keep theirs, so one cache file serves both
+group and `--jira` runs. A missing, corrupt, or older-schema cache is ignored with a warning; the cache only saves
+requests and never changes the report.
@@ -10,6 +10,7 @@
 from release_scope._cache import Cache
 from release_scope._errors import ConfigError, ReleaseScopeError
 from release_scope._files import write_text_atomic
+from release_scope._jira_keys import JIRA_KEY_PATTERN
 from release_scope._render import render_markdown
 from release_scope._report import SCHEMA_VERSION, Report
 from release_scope._settings import Settings, load_settings
@@ -70,19 +71,25 @@ def _collect_command(  # noqa: PLR0913, PLR0917
         pathlib.Path | None,
         typer.Option("--cache", help="Cache JSON; read if present, rewritten in place after the run."),
     ] = None,
+    jira: typing.Annotated[
+        list[str] | None,
+        typer.Option("--jira", "-j", help="Jira issue key; collect only the services it links to. Repeatable."),
+    ] = None,
 ) -> None:
     try:
-        if not group and not project:
-            msg = "Pass at least one --group or --project."
-            raise ConfigError(msg)
+        _check_selection(groups=group or [], projects=project or [], keys=jira or [])
         settings = load_settings({})
         modern_di_typer.fetch_di_container(ctx).set_context(Settings, settings)
         cache, cache_warning = Cache.load(cache_path) if cache_path else (Cache(), None)
         if cache_warning:
             typer.echo(f"Warning: {cache_warning}", err=True)
-        report = _resolve_use_case(ctx=ctx)(
-            groups=group or [], projects=project or [], include_subgroups=include_subgroups, cache=cache
-        )
+        use_case = _resolve_use_case(ctx=ctx)
+        if jira:
+            report = use_case.for_issues(keys=list(dict.fromkeys(jira)), cache=cache)
+        else:
+            report = use_case(
+                groups=group or [], projects=project or [], include_subgroups=include_subgroups, cache=cache
+            )
     except ReleaseScopeError as err:
         typer.echo(f"Error: {err}", err=True)
         raise typer.Exit(code=err.exit_code) from err
@@ -95,13 +102,37 @@ def _collect_command(  # noqa: PLR0913, PLR0917
     typer.echo(f"{len(report.services)} services, {rows} rows, {len(failed)} failed -> {output}", err=True)
     for service in failed:
         typer.echo(f"Error: {service.error}", err=True)
-    jira_error: typing.Final = report.jira.error if report.jira else None
-    if jira_error:
-        typer.echo(f"Error: {jira_error}", err=True)
-    if failed or jira_error:
+    jira_errors: typing.Final = _jira_errors(report)
+    for message in jira_errors:
+        typer.echo(f"Error: {message}", err=True)
+    if failed or jira_errors:
         raise typer.Exit(code=1)
 
 
+def _check_selection(
+    *, groups: typing.Sequence[str], projects: typing.Sequence[str], keys: typing.Sequence[str]
+) -> None:
+    if keys and (groups or projects):
+        msg = "Pass either --jira or --group/--project, not both."
+        raise ConfigError(msg)
+    if not keys and not groups and not projects:
+        msg = "Pass --jira, or at least one --group or --project."
+        raise ConfigError(msg)
+    for key in keys:
+        if not JIRA_KEY_PATTERN.fullmatch(key):
+            msg = f"Not a Jira issue key: {key}."
+            raise ConfigError(msg)
+
+
+def _jira_errors(report: Report) -> list[str]:
+    if report.jira is None:
+        return []
+    errors: typing.Final = [f"Jira has no issue {key}." for key in report.jira_scope if key in report.jira.missing]
+    if report.jira.error:
+        errors.append(report.jira.error)
+    return errors
+
+
 @MAIN_APP.command("render", help="Render a JSON report as a Markdown page for a GitLab wiki.")
 def _render_command(
     report_path: typing.Annotated[pathlib.Path, typer.Argument(help="Report JSON written by `collect`.")],
 
@@ -11,6 +11,8 @@
 
 CACHE_SCHEMA_VERSION: typing.Final = 1
 
+_EntryT = typing.TypeVar("_EntryT")
+
 
 class CachedPipeline(pydantic.BaseModel):
     updated_at: str
@@ -21,12 +23,14 @@ class CacheData(pydantic.BaseModel):
     schema_version: typing.Literal[1] = CACHE_SCHEMA_VERSION
     commit_merge_requests: dict[str, dict[str, list[MergeRequest]]] = pydantic.Field(default_factory=dict)
     pipelines: dict[str, dict[str, CachedPipeline]] = pydantic.Field(default_factory=dict)
+    merge_requests: dict[str, dict[str, MergeRequest]] = pydantic.Field(default_factory=dict)
 
 
 @dataclasses.dataclass(slots=True, kw_only=True)
 class Cache:
     previous: CacheData = dataclasses.field(default_factory=CacheData)
     current: CacheData = dataclasses.field(default_factory=CacheData)
+    visited: set[str] = dataclasses.field(default_factory=set)
 
     @classmethod
     def load(cls, path: pathlib.Path) -> tuple["Cache", str | None]:
@@ -38,7 +42,30 @@ def load(cls, path: pathlib.Path) -> tuple["Cache", str | None]:
             return cls(), f"Ignoring unreadable cache {path}: {type(exc).__name__}."
 
     def save(self, path: pathlib.Path) -> None:
-        write_text_atomic(path, self.current.model_dump_json(indent=2))
+        write_text_atomic(path, self.pruned().model_dump_json(indent=2))
+
+    def visit(self, project_id: int) -> None:
+        self.visited.add(str(project_id))
+
+    def pruned(self) -> CacheData:
+        return CacheData(
+            commit_merge_requests=self._unvisited(self.previous.commit_merge_requests)
+            | self.current.commit_merge_requests,
+            pipelines=self._unvisited(self.previous.pipelines) | self.current.pipelines,
+            merge_requests=self._unvisited(self.previous.merge_requests) | self.current.merge_requests,
+        )
+
+    def _unvisited(self, entries: dict[str, _EntryT]) -> dict[str, _EntryT]:
+        return {project: entry for project, entry in entries.items() if project not in self.visited}
+
+    def get_merge_request(self, project_id: int, iid: int) -> MergeRequest | None:
+        cached = self.previous.merge_requests.get(str(project_id), {}).get(str(iid))
+        if cached is not None:
+            self.put_merge_request(project_id, cached)
+        return cached
+
+    def put_merge_request(self, project_id: int, merge_request: MergeRequest) -> None:
+        self.current.merge_requests.setdefault(str(project_id), {})[str(merge_request.iid)] = merge_request
 
     def get_commit_merge_requests(self, project_id: int, sha: str) -> list[MergeRequest] | None:
         cached = self.previous.commit_merge_requests.get(str(project_id), {}).get(sha)
@@ -69,3 +96,7 @@ def keep_project(self, project_id: int) -> None:
             **self.previous.pipelines.get(key, {}),
             **self.current.pipelines.get(key, {}),
         }
+        self.current.merge_requests[key] = {
+            **self.previous.merge_requests.get(key, {}),
+            **self.current.merge_requests.get(key, {}),
+        }
@@ -237,6 +237,11 @@ def list_merged_merge_requests(
         )
         return merge_requests
 
+    def get_merge_request(self, project_id: int, iid: int) -> MergeRequest:
+        return self._get(
+            f"{_API}/projects/{project_id}/merge_requests/{iid}", {}, MergeRequest, resource="merge_requests"
+        )
+
     def commit_merge_requests(self, project_id: int, sha: str) -> list[MergeRequest]:
         merge_requests, _ = self._pages(
             f"{_API}/projects/{project_id}/repository/commits/{sha}/merge_requests",
 
@@ -34,6 +34,8 @@
     "Legend: ✅ success · ❌ failed · 🔄 running · ⏭ canceled or skipped · ⚠️ warning or allowed failure"
 )
 _FAILED, _SKIPPED, _PENDING = 0, 1, 2
+_UNRELEASED: typing.Final = {"not_merged": "⏳ not merged", "not_found": "⚠️ linked change not found"}
+_LINKED: typing.Final = "🎯"
 
 
 def _inline(value: str) -> str:
@@ -79,6 +81,8 @@ def _state(service: Service) -> int | None:
         return _FAILED
     if service.rows:
         return _PENDING
+    if service.release and service.release.state in _UNRELEASED:
+        return _SKIPPED
     return _SKIPPED if service.warnings else None
 
 
@@ -109,12 +113,16 @@ def _failure_counts(service: Service) -> str:
 
 def _pending(service: Service) -> str:
     state: typing.Final = _state(service)
+    release: typing.Final = service.release
     if state == _FAILED:
         return "❌ failed to collect"
     if state == _SKIPPED:
-        return "⚠️ see below"
-    untagged: typing.Final = "" if service.rows[0].tags else " · untagged head"
-    return f"{_plural(len(service.rows), 'change')}{untagged}"
+        return _UNRELEASED.get(release.state, "⚠️ see below") if release else "⚠️ see below"
+    if release:
+        suffix = f" · release {_tag(release.tag)}" if release.tag else " · needs a new tag"
+    else:
+        suffix = "" if service.rows[0].tags else " · untagged head"
+    return f"{_plural(len(service.rows), 'change')}{suffix}"
 
 
 def _not_done(service: Service, issues: dict[str, JiraIssue]) -> str:
@@ -199,7 +207,7 @@ def _row(row: Row, project: str, jira: JiraState | None) -> list[str]:
     issues: typing.Final = jira.issues if jira else {}
     return [
         "<br>".join(_tag(tag) for tag in row.tags),
-        _merge_requests_or_commits(row),
+        f"{_LINKED} {_merge_requests_or_commits(row)}" if row.linked else _merge_requests_or_commits(row),
         "<br>".join(_jira_key(key, issues) for key in row.jira_keys),
         *([_related_services(row, project, issues)] if jira else []),
         ", ".join(_cell(name) for name in row.environments),
@@ -238,26 +246,44 @@ def _service_section(service: Service, production: str, jira: JiraState | None)
     if service.error:
         lines.extend([f"❌ {_inline(service.error)}", ""])
     lines.extend(line for warning in service.warnings for line in (f"⚠️ {_inline(warning)}", ""))
+    release: typing.Final = service.release
+    if release and release.pending_merge_requests:
+        waiting: typing.Final = ", ".join(
+            _reference(f"!{item.iid}", item.url, item.title, f"@{item.author}" if item.author else None)
+            for item in release.pending_merge_requests
+        )
+        lines.extend([f"⏳ Not merged: {waiting}", ""])
+    if release and release.state == "not_found":
+        lines.extend(["⚠️ No linked change was found between production and the head of the default branch.", ""])
     if service.rows:
         lines.extend(_rows_section(service, production, jira))
     return lines
 
 
+def _scope_issue(key: str, jira: JiraState | None) -> str:
+    issue: typing.Final = jira.issues.get(key) if jira else None
+    if issue is None:
+        return f"- {_inline(key)} · not found in Jira"
+    return f"- {_link(_inline(key), issue.url)} {_cell(issue.summary)} · {_cell(issue.status)}"
+
+
 def render_markdown(report: Report) -> str:
     production: typing.Final = report.production_environment
     collected: typing.Final = report.collected_at.astimezone(datetime.UTC).strftime("%Y-%m-%d %H:%M")
+    jira: typing.Final = report.jira
+    scope: typing.Final = report.jira_scope
     lines: typing.Final = [
-        "# Release scope",
+        f"# Release scope: {', '.join(_inline(key) for key in scope)}" if scope else "# Release scope",
         "",
         (
             f"Collected {collected} UTC. Changes run from the commit on `{_inline(production)}` "
-            "to the head of the default branch."
+            + ("to the latest change linked to the issues." if scope else "to the head of the default branch.")
         ),
         "",
-        _LEGEND,
-        "",
     ]
-    jira: typing.Final = report.jira
+    if scope:
+        lines.extend([*(_scope_issue(key, jira) for key in scope), ""])
+    lines.extend([f"{_LEGEND} · {_LINKED} linked to the issues" if scope else _LEGEND, ""])
     if jira and jira.error:
         lines.extend([f"❌ {_inline(jira.error)}", ""])
     if not report.services:
 
@@ -61,6 +61,7 @@ class Row(pydantic.BaseModel):
     jira_keys: list[JiraKeyRef]
     environments: list[str]
     main_pipeline: PipelineState | None
+    linked: bool = False
 
 
 class EnvironmentState(pydantic.BaseModel):
@@ -71,6 +72,12 @@ class EnvironmentState(pydantic.BaseModel):
     deployment_url: str | None
 
 
+class Release(pydantic.BaseModel):
+    state: typing.Literal["pending", "in_production", "not_merged", "not_found"]
+    tag: TagRef | None = None
+    pending_merge_requests: list[MergeRequestRef] = pydantic.Field(default_factory=list)
+
+
 class Service(pydantic.BaseModel):
     project: str
     project_url: str
@@ -79,6 +86,7 @@ class Service(pydantic.BaseModel):
     rows: list[Row] = pydantic.Field(default_factory=list)
     warnings: list[str] = pydantic.Field(default_factory=list)
     error: str | None = None
+    release: Release | None = None
 
 
 class LinkedChange(pydantic.BaseModel):
@@ -96,6 +104,7 @@ class JiraIssue(pydantic.BaseModel):
     status: str
     status_category: str | None
     issue_type: str | None
+    url: str | None = None
     links: list[LinkedChange] = pydantic.Field(default_factory=list)
 
 
@@ -111,3 +120,4 @@ class Report(pydantic.BaseModel):
     production_environment: str
     services: list[Service]
     jira: JiraState | None = None
+    jira_scope: list[str] = pydantic.Field(default_factory=list)