Phase 1# of postponed issues reprocessing

[jpodivin]

Implementing design from research by @majamassarini .

Postponed issues are now split into several categories, depending on the reason for postponement. In each of these cases, a comment, in a well defined format, is posted under the given JIRA item. This comment is later processed by the comment_parser and used to determine if the postponement label can be removed, and processing resumed.

Sweep is executed using one of 4 strategies:

• Y-stream checks if dependencies have been shipped in Z stream, using references in the comment and check_build_in_buildroot.
• PR Pending uses ymir.supervisor.gitlab_utils.gitlab_api_get to check state of MRs. If they are merged, the issue is pushed back into triage queue.
• No Patch simply sends all issues marked with ymir_postponed_no_patch back into triage queue, subject to limit of 20 per run.
• Dependency checks if the build is in the Y-stream, again using check_build_in_buildroot

All with their own cronjobs.

Notes:

• Sweep jobs make use of code already developed for supervisor.
• Unit tests, as well as minimal integration tests were implemented.
• Minor modification was made to gitlab_api_get function, so it can be used by sweep jobs.
• The ymir_abandoned label has been implemented as part of this PR, although it is going to be used only in phase 2#.
• Container image is very similar to that for supervisor, we can discuss building of a base image for both perhaps. But I would rather leave that for a follow up.

[qodo-for-packit]

PR Summary by Qodo

Add categorized postponed resolutions and sweep jobs to reprocess blocked issues

✨ Enhancement 🧪 Tests ⚙️ Configuration changes 🕐 40+ Minutes

AI Description

• Split postponed triage into reason-specific resolutions and Jira labels.
• Add sweep runner + strategies to unblock/transition postponed issues via Jira comments.
• Deploy four OpenShift CronJobs and a dedicated sweep container image, with tests.

Diagram

graph TD
  A["OpenShift CronJob(s)"] --> B["Sweep container image"] --> C["ymir.sweep runner"] --> D["Sweep strategies"]
  D --> E{{"Jira API"}} --> H["Jira issues (labels/comments)"]
  D --> F{{"GitLab API"}}
  D --> G{{"Koji/buildroot"}}
  D --> I[("Redis triage queue")]
  J["Triage agent"] --> H --> D
  I --> J
  subgraph Legend
    direction LR
    _job["Scheduler/Job"] ~~~ _db[("Queue/DB")] ~~~ _ext{{"External API"}}
  end

Loading

High-Level Assessment

The following are alternative approaches to this PR:

1. Store blocker metadata in Jira custom fields (not comments)

• ➕ Eliminates regex coupling between comment format and sweeps
• ➕ Enables validation at write-time and stronger typing/reporting
• ➖ Requires Jira schema/admin changes and migrations
• ➖ Higher operational overhead than comment-based approach for Phase 1

2. Unify buildroot-based sweeps into a single generic strategy

• ➕ Less duplicated logic between dependency and y-stream checks
• ➕ Easier to add new buildroot-driven postponement categories
• ➖ May obscure category-specific behaviors/wording and future divergence
• ➖ Refactor cost may not pay off until more categories are added

Recommendation: The PR’s approach (reason-specific labels + machine-readable comment fields parsed by sweeps) is a pragmatic Phase 1 implementation aligned with the linked research and avoids Jira admin dependencies. Keep the comment contract stable (ideally version it in the comment marker) and consider migrating blocker_reference to structured Jira fields later if regex coupling becomes a maintenance burden.

Files changed (40) +3485 / -54 · 4 not counted

Enhancement (13) +1011 / -39

cve_applicability_agent.pyTreat all postponed resolutions like rebuild for applicability context +2/-2

Treat all postponed resolutions like rebuild for applicability context

• Replaces checks against the old single 'POSTPONED' resolution with membership in 'POSTPONED_RESOLUTIONS' so postponed rebuilds still include dependency rebuild context.

ymir/agents/cve_applicability_agent.py

triage_agent.pyIntroduce reason-specific postponement labels and safer label updates +82/-33

Introduce reason-specific postponement labels and safer label updates

• Adds mappings from new postponed resolutions to new Jira labels and updates postponed checks to use 'POSTPONED_RESOLUTIONS'. Extends PostponedData creation to set 'blocker_reference', and adds a helper to atomically swap postponement labels (remove old postponement labels + triage-in-progress) for user-triggered runs.

ymir/agents/triage_agent.py

constants.pyAdd new Jira labels for postponement reasons and abandoned state +22/-0

Add new Jira labels for postponement reasons and abandoned state

• Deprecates the old general 'TRIAGED_POSTPONED' as the category signal and adds 'ymir_postponed_*' reason labels. Introduces 'ymir_abandoned' and a helper to enumerate postponement labels for cleanup/label swap operations.

ymir/common/constants.py

models.pySplit postponed Resolution into reason-specific values and add blocker_reference +33/-2

Split postponed Resolution into reason-specific values and add blocker_reference

• Replaces the single 'POSTPONED' resolution with four reason-specific resolutions and defines 'POSTPONED_RESOLUTIONS' for membership checks. Extends 'PostponedData' with 'blocker_reference' and updates comment formatting to optionally render a '*Blocker*:' line (noted as a sweep regex contract).

ymir/common/models.py

gitlab_utils.pyParametrize GitLab base URL in gitlab_api_get +2/-2

Parametrize GitLab base URL in gitlab_api_get

• Adds a 'gitlab_url' parameter to support calling GitLab APIs on different hosts (e.g., gitlab.com vs internal instances) while preserving existing behavior via a default.

ymir/supervisor/gitlab_utils.py

__init__.pyInitialize sweep package _{not counted}

Initialize sweep package

• Adds the 'ymir.sweep' package marker for the new sweep subsystem.

ymir/sweep/init.py

__main__.pyAdd sweep CLI runner with per-strategy and all-strategies modes +79/-0

Add sweep CLI runner with per-strategy and all-strategies modes

• Implements 'python -m ymir.sweep' entrypoint supporting '--strategy' and '--all'. Sets up shared requests session and Redis client and runs strategies sequentially to limit Jira API pressure.

ymir/sweep/main.py

base.pyAdd SweepStrategy base class with orchestration and safety invariants +199/-0

Add SweepStrategy base class with orchestration and safety invariants

• Introduces an abstract base strategy that fetches labeled Jira issues, parses the latest Ymir comment, and dispatches to per-strategy unblock checks. Enforces ordering guarantees (Redis push before label removal; add new label before removing old on transition) and provides per-run summaries.

ymir/sweep/base.py

comment_parser.pyParse blocker_reference and pending issues from Ymir triage comments +77/-0

Parse blocker_reference and pending issues from Ymir triage comments

• Adds a regex-based parser that finds the latest Ymir triage comment and extracts '*Blocker*', '*Summary*', and '* <JIRAKEY>' entries. Returns structured 'CommentData' used by sweep strategies.

ymir/sweep/comment_parser.py

dependency.pyImplement dependency sweep using Jira blocker + buildroot check +155/-0

Implement dependency sweep using Jira blocker + buildroot check

• Adds the dependency sweep strategy: reads a Jira blocker key, fetches its 'fixed_in_build' and component, derives target branch, and unblocks when the build is present in the buildroot.

ymir/sweep/dependency.py

no_patch.pyImplement capped no-patch requeue sweep +113/-0

Implement capped no-patch requeue sweep

• Adds a sweep strategy that re-queues 'ymir_postponed_no_patch' issues for fresh triage up to 'MAX_ISSUES_PER_RUN', skipping issues already in triage-in-progress and posting a recheck comment when removing the label.

ymir/sweep/no_patch.py

pr_pending.pyImplement PR-pending sweep using GitLab MR state +108/-0

Implement PR-pending sweep using GitLab MR state

• Adds a strategy that parses a GitLab MR URL from 'blocker_reference', queries the MR state, unblocks on merge, and transitions to 'no_patch' on close. Uses the new 'gitlab_url' parameter to support multiple GitLab hosts.

ymir/sweep/pr_pending.py

y_stream.pyImplement Y-stream sweep for Z-stream dependency shipping via buildroot checks +139/-0

Implement Y-stream sweep for Z-stream dependency shipping via buildroot checks

• Adds a sweep strategy for Y-stream postponements: validates blocker Jira keys from comment data, ensures each has 'fixed_in_build' and a component, and unblocks only when all builds are present in the Y-stream buildroot.

ymir/sweep/y_stream.py

Tests (16) +2101 / -11

Makefile.testsWire sweep unit and integration tests into test matrix +14/-3

Wire sweep unit and integration tests into test matrix

• Adds 'check-sweep' and 'check-sweep-integration' targets and their in-container variants. Includes sweep checks in the top-level 'check' and 'check-in-container' aggregations.

Makefile.tests

test_triage_agent.pyUpdate triage agent tests for new postponed resolution +2/-2

Update triage agent tests for new postponed resolution

• Replaces references to the deprecated 'Resolution.POSTPONED' with 'Resolution.POSTPONED_DEPENDENCY' in resolution lists/parametrization.

ymir/agents/tests/unit/test_triage_agent.py

test_models.pyUpdate postponed formatting tests and add blocker_reference coverage +109/-6

Update postponed formatting tests and add blocker_reference coverage

• Updates existing postponed formatting tests to use reason-specific resolutions and adds new tests for blocker rendering, omission behavior, and JSON roundtrip validation for 'PostponedData'.

ymir/common/tests/unit/test_models.py

__init__.pyInitialize sweep tests package _{not counted}

Initialize sweep tests package

• Adds package marker for sweep test modules.

ymir/sweep/tests/init.py

__init__.pyInitialize sweep integration tests package _{not counted}

Initialize sweep integration tests package

• Adds package marker for integration tests under the sweep subsystem.

ymir/sweep/tests/integration/init.py

conftest.pyAdd integration fixtures for environment, Redis, and label ops capture +52/-0

Add integration fixtures for environment, Redis, and label ops capture

• Provides fixtures to set minimal env vars, capture label add/remove calls via monkeypatching, and create a Redis mock that records 'lpush' side effects.

ymir/sweep/tests/integration/conftest.py

test_sweep_runner.pyAdd end-to-end strategy.run() integration tests with monkeypatched I/O +330/-0

Add end-to-end strategy.run() integration tests with monkeypatched I/O

• Adds integration tests that exercise the full sweep pipeline (fetch → parse → check → queue/label ops) for dependency, y-stream, pr-pending, and no-patch strategies, including transition behavior.

ymir/sweep/tests/integration/test_sweep_runner.py

__init__.pyInitialize sweep unit tests package _{not counted}

Initialize sweep unit tests package

• Adds package marker for sweep unit tests.

ymir/sweep/tests/unit/init.py

conftest.pyAdd shared builders for FullIssue and Ymir comment fixtures +75/-0

Add shared builders for FullIssue and Ymir comment fixtures

• Provides helpers to create minimal Jira issue objects and generate Ymir comment bodies matching the structured format used by sweeps and the triage agent.

ymir/sweep/tests/unit/conftest.py

test_base.pyAdd unit tests for SweepStrategy orchestration and safety ordering +287/-0

Add unit tests for SweepStrategy orchestration and safety ordering

• Covers JQL construction, redis-before-jira ordering, label transition ordering, per-action counting, and exception handling (including Redis error re-raise) in the base sweep loop.

ymir/sweep/tests/unit/test_base.py

test_comment_parser.pyAdd unit tests for parsing latest Ymir comment fields +178/-0

Add unit tests for parsing latest Ymir comment fields

• Verifies parsing of blocker references, pending issues, and summaries across postponement categories, plus behavior with missing or multiple comments and selection of the latest Ymir comment.

ymir/sweep/tests/unit/test_comment_parser.py

test_dependency.pyAdd unit tests for dependency sweep branch derivation and unblock logic +289/-0

Add unit tests for dependency sweep branch derivation and unblock logic

• Covers target branch derivation from summary/fix_versions and all main dependency-sweep paths: missing blocker, Jira fetch failures, missing components, buildroot check outcomes, and exception propagation.

ymir/sweep/tests/unit/test_dependency.py

test_main.pyAdd unit tests for sweep CLI runner orchestration +121/-0

Add unit tests for sweep CLI runner orchestration

• Verifies the STRATEGIES mapping and that 'run_sweep()' executes selected strategies in order using patched async context managers for requests/Redis.

ymir/sweep/tests/unit/test_main.py

test_no_patch.pyAdd unit tests for capped no-patch requeue behavior +209/-0

Add unit tests for capped no-patch requeue behavior

• Tests cap enforcement, skipping in-progress issues, comment posting on label removal, redis-before-jira ordering, per-issue error handling, and Redis error propagation.

ymir/sweep/tests/unit/test_no_patch.py

test_pr_pending.pyAdd unit tests for PR-pending MR parsing and state handling +219/-0

Add unit tests for PR-pending MR parsing and state handling

• Covers MR URL regex matching, GitLab API host/path construction, and action selection for merged/open/closed/unknown states, including API failure handling.

ymir/sweep/tests/unit/test_pr_pending.py

test_y_stream.pyAdd unit tests for y-stream sweep multi-blocker logic +216/-0

Add unit tests for y-stream sweep multi-blocker logic

• Covers unblock when all blockers are shipped, still-blocked paths (missing fixed-in-build or build not in buildroot), error paths (no blockers, missing branch, missing components), and deduping blocker keys.

ymir/sweep/tests/unit/test_y_stream.py

Documentation (2) +4 / -2

output_format.j2Update postponed output example to reason-specific resolution and blocker_reference +2/-1

Update postponed output example to reason-specific resolution and blocker_reference

• Adjusts the documented JSON example to use 'postponed_dependency' and adds 'blocker_reference' to match the new machine-readable comment/sweep contract.

ymir/agents/prompts/triage/output_format.j2

prompt.j2Update triage guidance for dependency postponement resolution +2/-1

Update triage guidance for dependency postponement resolution

• Updates prompt logic to emit 'postponed_dependency' instead of the old generic postponed resolution and requires setting 'blocker_reference'.

ymir/agents/prompts/triage/prompt.j2

Other (9) +369 / -2

Containerfile.sweepAdd dedicated sweep container image +55/-0

Add dedicated sweep container image

• Introduces a CentOS Stream 10-based image that installs Python runtime deps and copies only the modules required to run sweeps. Sets up an unprivileged user and uses 'python -m ymir.sweep' as the container entrypoint.

Containerfile.sweep

MakefileAdd build/run targets and containerized checks for sweep +17/-1

Add build/run targets and containerized checks for sweep

• Adds 'build-sweep' and 'run-sweep' targets for local development. Extends container test phony targets to include sweep unit and integration test entrypoints.

Makefile

MakefileAdd manual run and suspend controls for sweep CronJobs +31/-1

Add manual run and suspend controls for sweep CronJobs

• Adds 'run-sweep-*' targets to create one-off Jobs from each sweep CronJob. Adds 'suspend-sweeps'/'unsuspend-sweeps' helpers to toggle all sweep schedulers.

openshift/Makefile

cronjob-sweep-dependency.ymlAdd CronJob for dependency postponement sweep +59/-0

Add CronJob for dependency postponement sweep

• Defines a scheduled job (every 6 hours) running 'ymir.sweep --strategy dependency' with Jira/endpoint env injection and tight runtime/resource limits.

openshift/cronjob-sweep-dependency.yml

cronjob-sweep-no-patch.ymlAdd CronJob for no-patch postponement sweep +64/-0

Add CronJob for no-patch postponement sweep

• Defines a daily job running 'ymir.sweep --strategy no_patch' with 'MAX_ISSUES_PER_RUN=20' and a shorter deadline since it only re-queues work.

openshift/cronjob-sweep-no-patch.yml

cronjob-sweep-pr-pending.ymlAdd CronJob for PR-pending postponement sweep +61/-0

Add CronJob for PR-pending postponement sweep

• Defines an every-8-hours job running 'ymir.sweep --strategy pr_pending', including GitLab credentials via 'gitlab-env' secret for MR state checks.

openshift/cronjob-sweep-pr-pending.yml

cronjob-sweep-y-stream.ymlAdd CronJob for Y-stream postponement sweep +59/-0

Add CronJob for Y-stream postponement sweep

• Defines an every-12-hours job running 'ymir.sweep --strategy y_stream' with Jira/endpoint env injection and buildroot-check-appropriate resources.

openshift/cronjob-sweep-y-stream.yml

deploy.shDeploy imagestream and CronJobs for sweeps +8/-0

Deploy imagestream and CronJobs for sweeps

• Extends deployment script to apply the sweep imagestream and all four sweep CronJobs, and import the sweep image.

openshift/deploy.sh

imagestream-sweep.ymlAdd ImageStream for sweep image import +15/-0

Add ImageStream for sweep image import

• Introduces an OpenShift ImageStream that tracks 'quay.io/jotnar/sweep:latest' as the 'prod' tag with scheduled imports.

openshift/imagestream-sweep.yml

[qodo-for-packit]

Code Review by Qodo

🐞 Bugs (1) 📘 Rule violations (1) 📜 Skill insights (0)

1. GitLab token host leak ✗ Dismissed 🐞 Bug ⛨ Security

Description

PRPendingSweep derives gitlab_url from the MR URL in the Jira comment and calls gitlab_api_get(),
which always attaches the Bearer GITLAB_TOKEN header. Because the MR host is not allowlisted (regex
accepts any gitlab.* domain), a crafted blocker URL can exfiltrate the GitLab token to an
attacker-controlled host.

Code

ymir/sweep/pr_pending.py[R66-69]

+        path = f"projects/{urlquote(project_path, safe='')}/merge_requests/{mr_iid}"
+
+        try:
+            mr_data = gitlab_api_get(path, gitlab_url=f"https://{host}")

Relevance

●●● Strong

Strong security precedent: host-aware GitLab URL parsing/token scoping accepted to prevent
credential leakage.

PR-#706

ⓘ Recommendations generated based on similar findings in past PRs

Evidence

PRPendingSweep passes a host extracted from the MR URL into gitlab_api_get() as the base URL.
gitlab_api_get() always uses gitlab_headers(), which always includes the Bearer token, so the
token is sent to whatever host is in the comment URL (within the regex constraints).

ymir/sweep/pr_pending.py[56-70]
ymir/supervisor/gitlab_utils.py[15-29]
PR-#706

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`PRPendingSweep` uses the host from the blocker MR URL to build `gitlab_url` and then calls `gitlab_api_get()`, which always sends `Authorization: Bearer $GITLAB_TOKEN`. The current regex permits arbitrary `gitlab.*` hosts (e.g., `gitlab.evil.com`), so the service may send its token to a hostile endpoint.

## Issue Context
The sweep reads MR URLs from Jira comments (mutable/user-influenced). Even if only trusted users usually edit these, this is still a credential-exfiltration footgun.

## Fix Focus Areas
- ymir/sweep/pr_pending.py[26-70]
- ymir/supervisor/gitlab_utils.py[15-29]

### Implementation direction
- Parse MR URLs with `urllib.parse.urlparse()`.
- Enforce an explicit allowlist of GitLab hosts (e.g., `gitlab.com`, `gitlab.cee.redhat.com`) sourced from config/env.
- Ensure auth headers are only attached for allowlisted hosts; otherwise refuse the check (and keep issue postponed) or perform unauthenticated GET only if explicitly safe.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

2. Unawaited Redis writes ✗ Dismissed 🐞 Bug ≡ Correctness

Description

Sweep code calls redis_conn.lpush() without awaiting it, but the sweep runner uses the async Redis
client from ymir.common.base_utils.redis_client. This can remove postponement labels while never
enqueuing the issue back to TRIAGE_QUEUE, silently dropping work.

Code

ymir/sweep/base.py[R107-109]

+        task = Task.from_issue(issue_key)
+        redis_conn.lpush(RedisQueues.TRIAGE_QUEUE.value, task.to_json())
+        remove_issue_label(issue_key, self.label.value, comment=comment)

Relevance

●●● Strong

Team has precedent fixing Redis async usage; unawaited write risks dropped work.

PR-#675

ⓘ Recommendations generated based on similar findings in past PRs

Evidence

The sweep runner passes the connection produced by redis_client() into strategies; that context
manager yields a redis.asyncio.Redis instance. The sweep strategies call lpush() without
await, so the enqueue operation may never execute while Jira label removal still proceeds.

ymir/sweep/main.py[41-54]
ymir/common/base_utils.py[44-66]
ymir/sweep/base.py[94-110]
ymir/sweep/no_patch.py[82-88]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`ymir.sweep` uses `ymir.common.base_utils.redis_client()` (async Redis client) but calls `lpush()` synchronously (without `await`) in `SweepStrategy.on_unblock()` and `NoPatchSweep.run()`. With `redis.asyncio.Redis`, `lpush()` returns a coroutine and won’t execute, so issues can lose postponement labels without being re-queued.

## Issue Context
You can fix this by either:
1) Making Redis interactions in sweeps async (`await redis_conn.lpush(...)`), or
2) Switching the sweep runner to a synchronous Redis client consistently.

Option (1) is generally safer given the code already runs under `asyncio.run()`.

## Fix Focus Areas
- ymir/sweep/__main__.py[41-54]
- ymir/sweep/base.py[94-110]
- ymir/sweep/no_patch.py[82-88]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

3. FROM image not quay.io/jotnar 📘 Rule violation § Compliance

Description

The new sweep container build and OpenShift CronJobs reference images not under the required
quay.io/jotnar/ namespace. This can pull unapproved images and violates the repository’s container
image sourcing policy.

Code

Containerfile.sweep[1]

+FROM quay.io/centos/centos:stream10

Relevance

●●● Strong

Repo historically moves OpenShift/container images to quay.io/jotnar; policy violations typically
fixed.

PR-#471

ⓘ Recommendations generated based on similar findings in past PRs

Evidence

PR Compliance ID 1591 requires all container image references (including FROM and manifests) to
use the quay.io/jotnar/ namespace unless an approved exception is documented. The new
Containerfile.sweep uses quay.io/centos/centos:stream10, and the new CronJobs use `image:
'sweep:prod', neither of which starts with quay.io/jotnar/`.

Rule 1591: Enforce quay.io/jotnar namespace for container images
Containerfile.sweep[1-1]
openshift/cronjob-sweep-dependency.yml[30-33]
openshift/cronjob-sweep-y-stream.yml[30-33]
openshift/cronjob-sweep-pr-pending.yml[30-33]
openshift/cronjob-sweep-no-patch.yml[32-35]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Container image references introduced in this PR are not consistently using the mandated `quay.io/jotnar/` namespace (base image and CronJob `image:` fields).

## Issue Context
Policy requires all `FROM` images and manifest image references to start with `quay.io/jotnar/`, unless an explicit, documented exception is added directly above the reference.

## Fix Focus Areas
- Containerfile.sweep[1-1]
- openshift/cronjob-sweep-dependency.yml[30-33]
- openshift/cronjob-sweep-y-stream.yml[30-33]
- openshift/cronjob-sweep-pr-pending.yml[30-33]
- openshift/cronjob-sweep-no-patch.yml[32-35]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

4. Wrong Ymir comment parsed 🐞 Bug ≡ Correctness

Description

parse_ymir_comment() selects the newest comment containing the generic marker "Output from Ymir",
but all Ymir agents use that same prefix. If a non-triage agent posts a newer comment on a
still-postponed issue, sweeps can parse the wrong comment and extract missing/stale blocker fields,
causing skips or incorrect checks.

Code

ymir/sweep/comment_parser.py[R54-57]

+    for comment in reversed(issue.comments):
+        if _YMIR_COMMENT_MARKER in comment.body:
+            ymir_comment = comment
+            break

Relevance

●● Moderate

Correctness concern plausible, but no clear precedent on tightening Ymir comment selection across
agents.

ⓘ Recommendations generated based on similar findings in past PRs

Evidence

The parser uses a broad substring match to pick the latest “Ymir” comment, while the shared Jira
comment template used by all agents begins with the same “Output from Ymir $AGENT_TYPE Agent”
header. This makes it possible for sweeps to select a newer, unrelated agent comment instead of the
triage postponement comment.

ymir/sweep/comment_parser.py[17-57]
ymir/agents/constants.py[19-21]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The sweep comment parser matches any Jira comment containing `"Output from Ymir"`. Since all agents use the same prefix, the sweeps can accidentally parse a newer non-triage agent comment and extract incorrect or incomplete blocker data.

## Issue Context
Sweeps depend on the triage output format (Blocker / Waiting for / Summary). Non-triage agent comments may not include these lines or may refer to different artifacts.

## Fix Focus Areas
- ymir/sweep/comment_parser.py[17-57]
- ymir/agents/constants.py[19-21]

### Implementation direction
- Narrow the marker to triage-specific text (e.g., `"Output from Ymir Triage Agent"`).
- Or parse out `$AGENT_TYPE` from the header line and require `AGENT_TYPE == 'Triage'`.
- Consider additionally sorting comments by `created` timestamp defensively before selecting the latest matching one.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

Context used

✅ Compliance rules (platform): 7 rules

Tip of the day

💡 Did you know, you can group findings by type and pick your Finding display, from Minimal to Full

More tips ↗ | Customize Qodo ↗ | Qodo docs ↗

[lbarcziova]

thanks for working on this, this will be great once deployed in production. I like that for most of the re-checks it's just code, so won't cost us too much.

I have few initial questions regarding some implementation details.

[lbarcziova]

I see some great improvements here, I really like the prompt changes; just few (hopefully last) notes, and something raised by Claude:

  1. GitLab Bearer token sent to any gitlab.* host (security, low-severity)

  _GITLAB_MR_RE = re.compile(r"https://(gitlab\.[^/]+)/...") still accepts any gitlab.* domain. The extracted host is passed to gitlab_api_get(gitlab_url=f"https://{host}"), which appends the Bearer token to
  the request. A crafted blocker_reference pointing to a rogue gitlab.attacker.com host would exfiltrate the token. jpodivin deflected to the supervisor layer but the risk sits in pr_pending.py — the regex
  is where the host is extracted and trusted. Since blocker_reference values come from Jira comments written by the LLM (not from a curated allowlist), this is exploitable if a Jira comment is compromised or
  the LLM hallucinates a hostile URL.

[jpodivin]

I see some great improvements here, I really like the prompt changes; just few (hopefully last) notes, and something raised by Claude:

  1. GitLab Bearer token sent to any gitlab.* host (security, low-severity)

  _GITLAB_MR_RE = re.compile(r"https://(gitlab\.[^/]+)/...") still accepts any gitlab.* domain. The extracted host is passed to gitlab_api_get(gitlab_url=f"https://{host}"), which appends the Bearer token to
  the request. A crafted blocker_reference pointing to a rogue gitlab.attacker.com host would exfiltrate the token. jpodivin deflected to the supervisor layer but the risk sits in pr_pending.py — the regex
  is where the host is extracted and trusted. Since blocker_reference values come from Jira comments written by the LLM (not from a curated allowlist), this is exploitable if a Jira comment is compromised or
  the LLM hallucinates a hostile URL.

We could have a whitelist for this. But it will add to the maintenance burden.

[majamassarini]

Beside the comment below and this small finding from Claude, this LGTM.

PostponedData.blocker_references semantically required but schema-optional (ymir/common/models.py:1167)

  Field is list[str] | None with default=None, but PRPendingSweep returns an error if None for postponed_pr_pending issues. The schema doesn't enforce the semantic requirement.

  Fix: Either make the field required in the schema or handle None gracefully in PRPendingSweep.

[majamassarini]

I am wondering if, instead of creating this new secret file, we should reuse the jira-issue-fetcher.env and potentially rename it - if clearer. This would limit the places that need to be updated.

[jpodivin]

But some of the vars in that file, like QUERY, have nothing to do in sweep jobs.

Using a single file for both, would lead to confusion regarding what the cronjobs need. Not just for people, agents too.

Having a single file for two services, would also mean that variables for issue fetcher, would get in sweep containers. Finally, while there is already divergence today, there is no guarantee that it won't be even greater in the future. And then we would have to create a new file anyway.

[jpodivin]

Beside the comment below and this small finding from Claude, this LGTM.

PostponedData.blocker_references semantically required but schema-optional (ymir/common/models.py:1167)

  Field is list[str] | None with default=None, but PRPendingSweep returns an error if None for postponed_pr_pending issues. The schema doesn't enforce the semantic requirement.

  Fix: Either make the field required in the schema or handle None gracefully in PRPendingSweep.

That is not entirely correct. The PostponedData is used for all cases of postponement, and not all of them need references for blockers. So we can't make it mandatory. It is true, that model can hypothetically forget to fill it, if it sets resolution to POSTPONED_PR_PENDING. Even though that would mean ignoring the prompt. I can put a validator in, but turning this into a mandatory field wouldn't work.