cleveragents/cleveragents-core
cleveragents/cleveragents-core
4
0
Fork 3
Code Issues 6.1k Pull requests 489 Projects Releases Packages Wiki Activity Actions

fix(events): add unsubscribe() to EventBus protocol and implementations (#10356) #11195

Closed
freemo wants to merge 1 commit from feature/eventbus-unsubscribe into master
pull from: feature/eventbus-unsubscribe
merge into: cleveragents:master
Conversation 3 Commits 1 Files changed 8 +415 -18
freemo commented 2026-05-13 08:08:04 +00:00
Owner
Copy link

Summary

Adds unsubscribe(event_type, handler) -> bool method to the EventBus protocol and both concrete implementations (ReactiveEventBus, LoggingEventBus) to resolve memory leaks in long-running processes.

Problem

The EventBus protocol only defined emit() and subscribe(), with no way to remove individual handlers. Handler references stored as strong references were retained indefinitely inside the bus internal _subscriptions dict, causing memory leaks especially since:

  • The ReactiveEventBus is registered as a Singleton in DI (lives for app lifetime)
  • AuditEventSubscriber registers 10 security event type subscriptions that are never cleaned up
  • EventBusBridge.stop() was broken — it tried to call .dispose() on the return value of subscribe(), which returned None

Changes

Protocol (protocol.py)

  • Added unsubscribe(event_type: EventType, handler: Optional[Callable]) -> bool method signature
  • Updated docstring to note memory management concerns (references issue #10356)

ReactiveEventBus (reactive.py)

  • Implemented unsubscribe() — removes the specific (event_type, handler) pair from per-event-type lists
  • Returns True if a match was found and removed, False otherwise
  • Auto-cleans empty list entries from _subscriptions dict
  • Added validation: TypeError for invalid event_type or non-callable handler

LoggingEventBus (logging_bus.py)

  • Same unsubscribe() implementation as ReactiveEventBus

AuditEventSubscriber (audit_event_subscriber.py)

  • Added stop() method that calls EventBus.unsubscribe() for all event types originally subscribed to
  • Stored subscribed event types in _subscribed_types frozenset for cleanup
  • Method is idempotent — safe to call multiple times

EventBusBridge (a2a/events.py)

  • Fixed stop() to use the new unsubscribe() mechanism instead of trying .dispose() on None
  • Now iterates over all EventType values and calls unsubscribe(event_type, handler) for each
  • Added _subscription boolean flag to track whether bridge is actually started

Tests (BDD)

  • 10 new scenarios for ReactiveEventBus unsubscribe: removal, False return, selective unsubscription, type validation
  • 5 new scenarios for LoggingEventBus unsubscribe: same coverage
  • Updated protocol conformance checks to verify unsubscribe method exists
  • Added step definitions for I unsubscribe the handler..., unsubcribing should return True/False, and TypeError validations

Documentation (docs/reference/event_bus.md)

  • Updated EventBus Protocol section to include unsubscribe() in the interface table
  • Added memory management guidance section explaining when/how to call unsubscribe()
  • Added section about AuditEventSubscriber.stop() for lifecycle-aware consumers
# Summary Adds `unsubscribe(event_type, handler) -> bool` method to the EventBus protocol and both concrete implementations (ReactiveEventBus, LoggingEventBus) to resolve memory leaks in long-running processes. ## Problem The EventBus protocol only defined emit() and subscribe(), with no way to remove individual handlers. Handler references stored as strong references were retained indefinitely inside the bus internal _subscriptions dict, causing memory leaks especially since: - The ReactiveEventBus is registered as a Singleton in DI (lives for app lifetime) - AuditEventSubscriber registers 10 security event type subscriptions that are never cleaned up - EventBusBridge.stop() was broken — it tried to call .dispose() on the return value of subscribe(), which returned None ## Changes ### Protocol (protocol.py) - Added unsubscribe(event_type: EventType, handler: Optional[Callable]) -> bool method signature - Updated docstring to note memory management concerns (references issue #10356) ### ReactiveEventBus (reactive.py) - Implemented unsubscribe() — removes the specific (event_type, handler) pair from per-event-type lists - Returns True if a match was found and removed, False otherwise - Auto-cleans empty list entries from _subscriptions dict - Added validation: TypeError for invalid event_type or non-callable handler ### LoggingEventBus (logging_bus.py) - Same unsubscribe() implementation as ReactiveEventBus ### AuditEventSubscriber (audit_event_subscriber.py) - Added stop() method that calls EventBus.unsubscribe() for all event types originally subscribed to - Stored subscribed event types in _subscribed_types frozenset for cleanup - Method is idempotent — safe to call multiple times ### EventBusBridge (a2a/events.py) - Fixed stop() to use the new unsubscribe() mechanism instead of trying .dispose() on None - Now iterates over all EventType values and calls unsubscribe(event_type, handler) for each - Added _subscription boolean flag to track whether bridge is actually started ### Tests (BDD) - 10 new scenarios for ReactiveEventBus unsubscribe: removal, False return, selective unsubscription, type validation - 5 new scenarios for LoggingEventBus unsubscribe: same coverage - Updated protocol conformance checks to verify unsubscribe method exists - Added step definitions for I unsubscribe the handler..., unsubcribing should return True/False, and TypeError validations ### Documentation (docs/reference/event_bus.md) - Updated EventBus Protocol section to include unsubscribe() in the interface table - Added memory management guidance section explaining when/how to call unsubscribe() - Added section about AuditEventSubscriber.stop() for lifecycle-aware consumers
fix(events): add unsubscribe() to EventBus protocol and implementations (#10356)
Some checks failed
CI / lint (pull_request) Failing after 1m15s
Details
CI / typecheck (pull_request) Successful in 1m37s
Details
CI / security (pull_request) Successful in 1m36s
Details
CI / push-validation (pull_request) Successful in 39s
Details
CI / helm (pull_request) Successful in 42s
Details
CI / build (pull_request) Successful in 51s
Details
CI / quality (pull_request) Successful in 1m15s
Details
CI / integration_tests (pull_request) Successful in 5m19s
Details
CI / unit_tests (pull_request) Failing after 7m14s
Details
CI / docker (pull_request) Has been skipped
Details
CI / coverage (pull_request) Has been skipped
Details
CI / status-check (pull_request) Failing after 3s
Details
4dc3300577 
Added unsubscribe(event_type, handler) -> bool method to the EventBus protocol for both ReactiveEventBus and LoggingEventBus implementations. This resolves memory leaks caused by handler references persisting indefinitely in long-running processes.
HAL9001 requested changes 2026-05-13 16:22:38 +00:00
HAL9001 left a comment
Copy link

Review Summary

The core idea here is solid — adding unsubscribe() to the EventBus protocol and both implementations is the right fix for the memory leak described in #10356. The ReactiveEventBus and LoggingEventBus implementations are clean and correct, the docstrings are thorough, and the documentation update is a welcome addition.

However, there are 4 blocking issues that need to be fixed before this can be approved, plus several CI failures that confirm two of them.

CI Failures

  • CI / lint — FAILING: Likely caused by the # type: ignore suppressions added in features/steps/event_bus_steps.py (project policy: zero tolerance, all # type: ignore are prohibited) or formatting issues.
  • CI / unit_tests — FAILING: Almost certainly caused by the broken step_subscribe_two step — ctx.subscribed_handlers is always empty, so the "selective unsubscribe" scenario silently skips the actual unsubscribe call and likely fails on assertion.
  • CI / coverage — SKIPPED: Depends on unit_tests passing.

Blocking Issues Found

  1. BLOCKER — EventBusBridge.start() calls subscribe() with wrong arity (src/cleveragents/a2a/events.py): The call self._event_bus.subscribe(self._on_domain_event) passes only the handler, but EventBus.subscribe(event_type, handler) requires two arguments. This will raise TypeError at runtime whenever EventBusBridge.start() is called. While this bug existed before this PR, this PR explicitly claims to fix EventBusBridge.stop() — yet start() remains broken. The PR description says "Fixed stop() to use the new unsubscribe() mechanism" but does not acknowledge that start() also needs fixing.

  2. BLOCKER — step_subscribe_two builds empty ctx.subscribed_handlers (features/steps/event_bus_steps.py): The step initialises ctx.subscribed_handlers = [] but never populates it. The two collectors are placed in ctx.collectors but are not also appended to ctx.subscribed_handlers. Consequently the selective-unsubscribe step can never reach the branch that removes the first handler, causing the "other handlers preserved" scenario to pass vacuously or fail.

  3. BLOCKER — New # type: ignore suppressions added (features/steps/event_bus_steps.py): Several new # type: ignore[arg-type] comments were added in the unsubscribe test step definitions. Project policy is zero tolerance for # type: ignore — this is a hard rejection criterion.

  4. BLOCKER — Commit footer missing ISSUES CLOSED: #10356: The commit body does not contain the required ISSUES CLOSED: #N footer. Per CONTRIBUTING.md every commit footer must reference the closed issue. The PR body contains the closing keyword but the commit itself does not.

Non-blocking Observations

  • CHANGELOG.md was not updated. CONTRIBUTING.md requires a changelog entry per commit.
  • PR has no milestone assigned and no Type/ label — both are required per CONTRIBUTING.md checklist items 11 and 12.
  • The Gherkin step name unsubcribing (missing second s) is a typo — should be unsubscribing. Not blocking, but worth fixing.
  • The AuditEventSubscriber.stop() implementation is well-structured and idempotent — good work.
  • The test coverage for ReactiveEventBus.unsubscribe() and LoggingEventBus.unsubscribe() is thorough in concept; once the bugs are fixed, the scenarios will provide solid regression protection.
## Review Summary The core idea here is solid — adding `unsubscribe()` to the `EventBus` protocol and both implementations is the right fix for the memory leak described in #10356. The `ReactiveEventBus` and `LoggingEventBus` implementations are clean and correct, the docstrings are thorough, and the documentation update is a welcome addition. However, there are **4 blocking issues** that need to be fixed before this can be approved, plus several CI failures that confirm two of them. ### CI Failures - **`CI / lint` — FAILING**: Likely caused by the `# type: ignore` suppressions added in `features/steps/event_bus_steps.py` (project policy: zero tolerance, all `# type: ignore` are prohibited) or formatting issues. - **`CI / unit_tests` — FAILING**: Almost certainly caused by the broken `step_subscribe_two` step — `ctx.subscribed_handlers` is always empty, so the "selective unsubscribe" scenario silently skips the actual unsubscribe call and likely fails on assertion. - **`CI / coverage` — SKIPPED**: Depends on `unit_tests` passing. ### Blocking Issues Found 1. **BLOCKER — `EventBusBridge.start()` calls `subscribe()` with wrong arity** (`src/cleveragents/a2a/events.py`): The call `self._event_bus.subscribe(self._on_domain_event)` passes only the handler, but `EventBus.subscribe(event_type, handler)` requires two arguments. This will raise `TypeError` at runtime whenever `EventBusBridge.start()` is called. While this bug existed before this PR, this PR explicitly claims to fix `EventBusBridge.stop()` — yet `start()` remains broken. The PR description says "Fixed stop() to use the new unsubscribe() mechanism" but does not acknowledge that `start()` also needs fixing. 2. **BLOCKER — `step_subscribe_two` builds empty `ctx.subscribed_handlers`** (`features/steps/event_bus_steps.py`): The step initialises `ctx.subscribed_handlers = []` but never populates it. The two collectors are placed in `ctx.collectors` but are not also appended to `ctx.subscribed_handlers`. Consequently the selective-unsubscribe step can never reach the branch that removes the first handler, causing the "other handlers preserved" scenario to pass vacuously or fail. 3. **BLOCKER — New `# type: ignore` suppressions added** (`features/steps/event_bus_steps.py`): Several new `# type: ignore[arg-type]` comments were added in the unsubscribe test step definitions. Project policy is **zero tolerance** for `# type: ignore` — this is a hard rejection criterion. 4. **BLOCKER — Commit footer missing `ISSUES CLOSED: #10356`**: The commit body does not contain the required `ISSUES CLOSED: #N` footer. Per CONTRIBUTING.md every commit footer must reference the closed issue. The PR body contains the closing keyword but the commit itself does not. ### Non-blocking Observations - CHANGELOG.md was not updated. CONTRIBUTING.md requires a changelog entry per commit. - PR has no milestone assigned and no `Type/` label — both are required per CONTRIBUTING.md checklist items 11 and 12. - The Gherkin step name `unsubcribing` (missing second `s`) is a typo — should be `unsubscribing`. Not blocking, but worth fixing. - The `AuditEventSubscriber.stop()` implementation is well-structured and idempotent — good work. - The test coverage for `ReactiveEventBus.unsubscribe()` and `LoggingEventBus.unsubscribe()` is thorough in concept; once the bugs are fixed, the scenarios will provide solid regression protection.
features/steps/event_bus_steps.py
HAL9001 commented 2026-05-13 16:22:38 +00:00
Owner
Copy link

BLOCKER — ctx.subscribed_handlers is always empty

ctx.subscribed_handlers is initialised as [] here but is never populated. The two collectors created in the loop are appended to ctx.collectors, but none are appended to ctx.subscribed_handlers. This means step_unsubscribe_handler can never satisfy len(ctx.subscribed_handlers) >= 2, so the selective unsubscribe branch is never executed and the scenario silently skips the actual unsubscribe call.

How to fix:

@when('I subscribe two handlers to "{et}" events')
def step_subscribe_two(ctx: Context, et: str) -> None:
    ctx.subscribed_handlers: list[_EventCollector] = []
    for _ in range(2):
        collector = _EventCollector()
        ctx.collectors.append(collector)
        ctx.subscribed_handlers.append(collector)  # <- missing
        ctx.bus.subscribe(EventType(et), collector)
**BLOCKER — `ctx.subscribed_handlers` is always empty** `ctx.subscribed_handlers` is initialised as `[]` here but is never populated. The two collectors created in the loop are appended to `ctx.collectors`, but none are appended to `ctx.subscribed_handlers`. This means `step_unsubscribe_handler` can never satisfy `len(ctx.subscribed_handlers) >= 2`, so the selective unsubscribe branch is never executed and the scenario silently skips the actual unsubscribe call. **How to fix:** ```python @when('I subscribe two handlers to "{et}" events') def step_subscribe_two(ctx: Context, et: str) -> None: ctx.subscribed_handlers: list[_EventCollector] = [] for _ in range(2): collector = _EventCollector() ctx.collectors.append(collector) ctx.subscribed_handlers.append(collector) # <- missing ctx.bus.subscribe(EventType(et), collector) ```
features/steps/event_bus_steps.py
HAL9001 commented 2026-05-13 16:22:38 +00:00
Owner
Copy link

BLOCKER — # type: ignore suppressions are prohibited

This project has a zero-tolerance policy for # type: ignore — this is listed as a hard rejection criterion in the review checklist and in CONTRIBUTING.md. Several new # type: ignore[arg-type] comments have been added in the unsubscribe test step definitions (lines ~313, ~325, ~335, ~348 in the file).

The suppressions exist because the test steps intentionally pass wrong types to verify TypeError is raised. The correct approach is to use explicit cast() with the wrong type, or to restructure the test so the type system understands that intentionally-wrong arguments are being passed without needing # type: ignore.

For example:

# Instead of:
ctx.bus.unsubscribe(
    "plan.created",  # type: ignore[arg-type]
    _EventCollector(),  # type: ignore[arg-type]
)

# Use a typed variable to avoid the suppression:
bad_event_type: Any = "plan.created"
bad_handler: Any = _EventCollector()
ctx.bus.unsubscribe(bad_event_type, bad_handler)

All # type: ignore additions in this diff must be removed before this PR can be approved.

**BLOCKER — `# type: ignore` suppressions are prohibited** This project has a **zero-tolerance policy** for `# type: ignore` — this is listed as a hard rejection criterion in the review checklist and in CONTRIBUTING.md. Several new `# type: ignore[arg-type]` comments have been added in the unsubscribe test step definitions (lines ~313, ~325, ~335, ~348 in the file). The suppressions exist because the test steps intentionally pass wrong types to verify `TypeError` is raised. The correct approach is to use explicit `cast()` with the wrong type, or to restructure the test so the type system understands that intentionally-wrong arguments are being passed without needing `# type: ignore`. For example: ```python # Instead of: ctx.bus.unsubscribe( "plan.created", # type: ignore[arg-type] _EventCollector(), # type: ignore[arg-type] ) # Use a typed variable to avoid the suppression: bad_event_type: Any = "plan.created" bad_handler: Any = _EventCollector() ctx.bus.unsubscribe(bad_event_type, bad_handler) ``` All `# type: ignore` additions in this diff must be removed before this PR can be approved.
src/cleveragents/a2a/events.py
HAL9001 commented 2026-05-13 16:22:38 +00:00
Owner
Copy link

BLOCKER — Wrong arity in subscribe() call

This calls subscribe() with only one argument (the handler), but EventBus.subscribe(event_type, handler) requires two arguments. At runtime, this will raise TypeError: subscribe() missing 1 required positional argument: 'handler' whenever EventBusBridge.start() is called.

This was pre-existing broken code, but this PR explicitly touches start() and stop() — it should fix this too. The PR description says stop() was "broken" because it tried to call .dispose() on None, but the same issue with start() receiving the wrong number of arguments is equally broken.

How to fix: The bridge needs to subscribe to every EventType (as stop() already iterates), or alternatively the EventBus protocol should be extended to support a wildcard/all-events subscription. The simplest fix consistent with the existing stop() implementation:

def start(self) -> None:
    """Subscribe to the event bus and begin forwarding."""
    if hasattr(self._event_bus, "subscribe"):
        from cleveragents.infrastructure.events.types import EventType
        for event_type in EventType:
            self._event_bus.subscribe(event_type, self._on_domain_event)
        self._subscription = True
        logger.info("a2a.event_bridge.started")
**BLOCKER — Wrong arity in `subscribe()` call** This calls `subscribe()` with only one argument (the handler), but `EventBus.subscribe(event_type, handler)` requires two arguments. At runtime, this will raise `TypeError: subscribe() missing 1 required positional argument: 'handler'` whenever `EventBusBridge.start()` is called. This was pre-existing broken code, but this PR explicitly touches `start()` and `stop()` — it should fix this too. The PR description says `stop()` was "broken" because it tried to call `.dispose()` on `None`, but the same issue with `start()` receiving the wrong number of arguments is equally broken. **How to fix:** The bridge needs to subscribe to every `EventType` (as `stop()` already iterates), or alternatively the `EventBus` protocol should be extended to support a wildcard/all-events subscription. The simplest fix consistent with the existing `stop()` implementation: ```python def start(self) -> None: """Subscribe to the event bus and begin forwarding.""" if hasattr(self._event_bus, "subscribe"): from cleveragents.infrastructure.events.types import EventType for event_type in EventType: self._event_bus.subscribe(event_type, self._on_domain_event) self._subscription = True logger.info("a2a.event_bridge.started") ```
HAL9001 commented 2026-05-13 16:22:44 +00:00
Owner
Copy link

Automated by CleverAgents Bot
Supervisor: PR Review | Agent: pr-review-worker

--- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
hurui200320 commented 2026-05-15 09:08:25 +00:00
Member
Copy link

close since dup with !11197

close since dup with !11197
hurui200320 closed this pull request 2026-05-15 09:08:25 +00:00
Some checks failed
CI / lint (pull_request) Failing after 1m15s
Required
Details
CI / typecheck (pull_request) Successful in 1m37s
Required
Details
CI / security (pull_request) Successful in 1m36s
Required
Details
CI / push-validation (pull_request) Successful in 39s
Details
CI / helm (pull_request) Successful in 42s
Details
CI / build (pull_request) Successful in 51s
Required
Details
CI / quality (pull_request) Successful in 1m15s
Required
Details
CI / integration_tests (pull_request) Successful in 5m19s
Required
Details
CI / unit_tests (pull_request) Failing after 7m14s
Required
Details
CI / docker (pull_request) Has been skipped
Required
Details
CI / coverage (pull_request) Has been skipped
Required
Details
CI / status-check (pull_request) Failing after 3s
Details

Pull request closed

Please reopen this pull request to perform a merge.
Sign in to join this conversation.
Reviewers
No reviewers
HAL9001
Labels
Clear labels   
auto/needs-reevaluation
Controller deferred this PR; awaiting Phase 6+ scope-evaluator or operator re-enablement.

  
controller-managed
Auto-agents controller manages this PR/issue (see tools/controller/deploy/RUNBOOK.md). Remove this label to abandon controller management.

  
auto/blocked-by-deps
PR blocked by an open issue dependency. Operator must close the dep (or remove the dependency link) before the merge driver can act. Auto-cleared by merge_drive when no open deps remain.

  
auto/ci-timeout
Most recent merge cycle hit CI timeout. Driver excludes this PR while last merge_cycle row is < 30 min old; label persists thereafter as visible history.

  
auto/claimed-implementer
Currently being processed by an implementer worker.

  
auto/claimed-merge
Currently being processed by the merge driver.

  
auto/claimed-reviewer
Currently being processed by a reviewer worker.

  
auto/driver-down
Merge driver heartbeat stale; pipeline halted. Closed automatically on next clean tick.

  
auto/invariant-violation
Detected master commit violating the strict merge invariant. Tracked as an issue (not a PR label); kept here for label completeness.

  
auto/last-attempt-tier-0
In-cycle escalation: most recent attempt ran at the Tier 0 slot (`tier-0`). Slot's model defined in .opencode/models/tiers.yaml.

  
auto/last-attempt-tier-1
In-cycle escalation: most recent attempt ran at the Tier 1 slot (`tier-1`). Slot's model defined in .opencode/models/tiers.yaml.

  
auto/last-attempt-tier-2
In-cycle escalation: most recent attempt ran at the Tier 2 slot (`tier-2`). Slot's model defined in .opencode/models/tiers.yaml. Gated behind IMPLEMENTER_ESCALATION_TIER2_ENABLED.

  
auto/last-attempt-tier-min
In-cycle escalation: most recent attempt ran at the Tier -1 slot (`tier-min`). Slot's model defined in .opencode/models/tiers.yaml. Suffix is ``-min`` (not ``--1``) so the Forgejo UI reads naturally.

  
Automation Tracking
Tracking issues used by the AI Automation system for agents to communicate and report.

  
auto/needs-conflict-resolution
Rebase conflict needs LLM conflict-resolver.

  
auto/needs-implementer
Failing CI needs implementer attention.

  
auto/postmortem
Documenting a driver incident or rollback.

  
auto/ready-to-merge
Reviewer has APPROVED this PR and no later REQUEST_CHANGES is outstanding. The merge driver requires this label to even consider a PR for merging. Set by the reviewer worker on APPROVE; cleared on REQUEST_CHANGES.

  
auto/restart-throttled
Train repeatedly lost master-tempo races. Driver excludes via merge_cycle until cooldown elapses; label persists as visible history.

  
auto/revert
Revert PR backing out an invariant violation. Fast-tracked through the merge driver.

  
auto/sentinel
Sentinel PR duplicated from upstream into a personal fork by tools/duplicate_prs_to_fork.py for pipeline testing. Lives only in the fork; the canonical pipeline never sees it.

  
auto/stale-inactivity
No implementer activity for N days. Flagged for human review. Auto-cleared on next push to head branch.

  
auto/unstable
Repeatedly fails on current master (>= 3 ci-fail-on-rebased-sha releases in 12 h). Excluded from driver until human triage.

  
Blocked
A ticket in a blocked state and unable to complete until some other task is completed first.

  
Bounty
$100
 A bounty of $100 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$1000
 A bounty of $1000 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$10000
 A bounty of $10000 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$20
 A bounty of $20 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$2000
 A bounty of $2000 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$250
 A bounty of $250 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$50
 A bounty of $50 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$500
 A bounty of $500 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$5000
 A bounty of $5000 for any open-source contributor who provides a MR that solves this issue

  
Bounty
$750
 A bounty of $750 for any open-source contributor who provides a MR that solves this issue

  
MoSCoW
Could have
 Could have feature in order to satisfy the epic/legendary.

  
MoSCoW
Must have
 Must have feature in order to satisfy the epic/legendary.

  
MoSCoW
Should have
 Should have feature in order to satisfy the epic/legendary.

  
Needs Feedback
There are questions in the ticket that can not be completed until the project owner provides clarity.

  
Points
1
 1 man-hours worth of work for an expert with no learning curve.

  
Points
13
 13 man-hours worth of work for an expert with no learning curve.

  
Points
2
 2 man-hours worth of work for an expert with no learning curve.

  
Points
21
 21 man-hours worth of work for an expert with no learning curve.

  
Points
3
 3 man-hours worth of work for an expert with no learning curve.

  
Points
34
 34 man-hours worth of work for an expert with no learning curve.

  
Points
5
 5 man-hours worth of work for an expert with no learning curve.

  
Points
55
 55 man-hours worth of work for an expert with no learning curve.

  
Points
8
 8 man-hours worth of work for an expert with no learning curve.

  
Points
88
 88 man-hours worth of work for an expert with no learning curve.

  
Priority
Backlog
 This ticket has backlogged priority and is not to be worked on yet

  
Priority
CI Blocker
 Critical priority issue that blocks CI/CD pipeline and prevents PR merges

  
Priority
Critical
 The priority is critical

  
Priority
High
 The priority is high

  
Priority
Low
 The priority is low

  
Priority
Medium
 The priority is medium

  
Signed-off: Owner
When an epic or legendary is in review it must be signed off by owner, tech lead, and scrum master before being marked as completed.

  
Signed-off: Scrum Master
When an epic or legendary is in review it must be signed off by owner, tech lead, and scrum master before being marked as completed.

  
Signed-off: Tech Lead
When an epic or legendary is in review it must be signed off by owner, tech lead, and scrum master before being marked as completed.

  
Spike
A ticket for learning a tool or technology that is needed to be able to do future planning and design.

  
State
Completed
 The ticket has been fully implemented, completed, and merged with the source code. This label should only be applied once a ticket is closed.

  
State
Duplicate
 A ticket that represents the same content as an existing ticket.

  
State
In Progress
 A ticket that is actively being developed.

  
State
In Review
 A ticket that has had some code completed to implement but is waiting to pass peer review and is not yet merged in.

  
State
Paused
 This ticket's work started but wasn't finished. It's on hold (likely in a feature branch) and will be resumed later, either due to a blocker or a delay.

  
State
Unverified
 All new tickets start in this state. A developer may set it to show the ticket is unverified. This means we haven't agreed to work on it. It will either move to a verified state or be closed as wontdo.

  
State
Verified
 The issue has been verified by a developer as legitimate. It will be worked on and verified tickets are now considered part of the backlog.

  
State
Wont Do
 This ticket has been decided it wont be done. This may mean the bug has been determined to not be real (cant verify) or the feature is one we have decided we dont want to adopt.

  
Type
Automation
 Any edits or discussion about the AI automated coding system.

  
Type
Bug
 Something that doesnt work as intended.

  
Type
Discussion
 Anytime a ticket represents a discussion about a subject and doesnt fall into one of the other categories.

  
Type
Documentation
 An error or improvement needed in the documentation.

  
Type
Epic
 Any first tier epic. That is, an epic which contains only issues as children and will not have sub-epics.

  
Type
Feature
 Some new functionality not present.

  
Type
Legendary
 A type of Epic which will contain other Epics.

  
Type
Refactor
 A code change that restructures existing code without changing its external behavior.

  
Type
Support
 Someone needs help using the project.

  
Type
Task
 A generic task that doesnt fit into the other type categories.

  
Type
Testing
 Work exclusively focusing on fixing or expanding testing.

No labels
auto/needs-reevaluation
controller-managed
auto/blocked-by-deps
auto/ci-timeout
auto/claimed-implementer
auto/claimed-merge
auto/claimed-reviewer
auto/driver-down
auto/invariant-violation
auto/last-attempt-tier-0
auto/last-attempt-tier-1
auto/last-attempt-tier-2
auto/last-attempt-tier-min
Automation Tracking
auto/needs-conflict-resolution
auto/needs-implementer
auto/postmortem
auto/ready-to-merge
auto/restart-throttled
auto/revert
auto/sentinel
auto/stale-inactivity
auto/unstable
Blocked
Bounty
$100
Bounty
$1000
Bounty
$10000
Bounty
$20
Bounty
$2000
Bounty
$250
Bounty
$50
Bounty
$500
Bounty
$5000
Bounty
$750
MoSCoW
Could have
MoSCoW
Must have
MoSCoW
Should have
Needs Feedback
Points
1
Points
13
Points
2
Points
21
Points
3
Points
34
Points
5
Points
55
Points
8
Points
88
Priority
Backlog
Priority
CI Blocker
Priority
Critical
Priority
High
Priority
Low
Priority
Medium
Signed-off: Owner
Signed-off: Scrum Master
Signed-off: Tech Lead
Spike
State
Completed
State
Duplicate
State
In Progress
State
In Review
State
Paused
State
Unverified
State
Verified
State
Wont Do
Type
Automation
Type
Bug
Type
Discussion
Type
Documentation
Type
Epic
Type
Feature
Type
Legendary
Type
Refactor
Type
Support
Type
Task
Type
Testing
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
3 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
cleveragents/cleveragents-core!11195
No description provided.