cleveragents/cleveragents-core
4
0
Fork 3
Code Issues 6.0k Pull Requests 115 Actions Packages Projects Releases Wiki Activity

fix(subplan): propagate invariant_enforced decisions to child plans on spawn #10881

Merged
HAL9000 merged 1 commits from bugfix/m3-invariant-propagation into master 2026-05-12 17:13:36 +00:00
Conversation 8 Commits 1 Files Changed 5
+456 -1
HAL9000 commented 2026-04-28 06:48:29 +00:00
Owner
Copy Link
Copy Source

Summary

  • Fixed SubplanService.spawn() to propagate all invariant_enforced decisions from the parent plan's decision tree to each child plan's decision tree
  • Added _propagate_invariant_decisions() helper method to SubplanService
  • Added BDD regression coverage in features/tdd_invariant_propagation_subplan.feature with 4 scenarios
  • Updated CHANGELOG.md with fix entry

Problem

SubplanService.spawn() created child Plan objects with no invariants and no invariant_enforced decisions. The child plan started Strategize with a completely empty invariant set, violating the spec's propagation requirement:

Glossary → Invariant: "recorded as invariant_enforced decisions that propagate to child plans."

non_overridable global invariants enforced on the parent were not guaranteed to be enforced on child plans.

Solution

The fix adds _propagate_invariant_decisions() to SubplanService which:

  1. Queries the parent plan's invariant_enforced decisions from DecisionService
  2. Re-records each one on the child plan using DecisionService.record_decision()

The DecisionService is already injected into SubplanService, so no new dependencies are required.

Testing

BDD regression coverage added in features/tdd_invariant_propagation_subplan.feature with 4 scenarios:

  • Single invariant propagation
  • Multiple invariant propagation (3 invariants)
  • Non-overridable invariant propagation
  • Clean spawn with no parent invariants

Manual verification script confirms the fix works correctly.

Closes #9131

This PR blocks issue #9131

Automated by CleverAgents Bot
Supervisor: Implementation | Agent: task-implementor

## Summary - Fixed `SubplanService.spawn()` to propagate all `invariant_enforced` decisions from the parent plan's decision tree to each child plan's decision tree - Added `_propagate_invariant_decisions()` helper method to `SubplanService` - Added BDD regression coverage in `features/tdd_invariant_propagation_subplan.feature` with 4 scenarios - Updated `CHANGELOG.md` with fix entry ## Problem `SubplanService.spawn()` created child `Plan` objects with no invariants and no `invariant_enforced` decisions. The child plan started Strategize with a completely empty invariant set, violating the spec's propagation requirement: > Glossary → Invariant: "recorded as `invariant_enforced` decisions that propagate to child plans." `non_overridable` global invariants enforced on the parent were not guaranteed to be enforced on child plans. ## Solution The fix adds `_propagate_invariant_decisions()` to `SubplanService` which: 1. Queries the parent plan's `invariant_enforced` decisions from `DecisionService` 2. Re-records each one on the child plan using `DecisionService.record_decision()` The `DecisionService` is already injected into `SubplanService`, so no new dependencies are required. ## Testing BDD regression coverage added in `features/tdd_invariant_propagation_subplan.feature` with 4 scenarios: - Single invariant propagation - Multiple invariant propagation (3 invariants) - Non-overridable invariant propagation - Clean spawn with no parent invariants Manual verification script confirms the fix works correctly. Closes #9131 This PR blocks issue #9131 --- Automated by CleverAgents Bot Supervisor: Implementation | Agent: task-implementor
HAL9000 added this to the v3.2.0 milestone 2026-04-28 06:48:29 +00:00
HAL9000 added 1 commit 2026-04-28 06:48:29 +00:00
fix(subplan): propagate invariant_enforced decisions to child plans on spawn
CI / benchmark-publish (pull_request) Has been skipped
Details
CI / lint (pull_request) Failing after 52s
Details
CI / quality (pull_request) Successful in 57s
Details
CI / push-validation (pull_request) Successful in 26s
Details
CI / helm (pull_request) Successful in 32s
Details
CI / typecheck (pull_request) Successful in 1m35s
Details
CI / security (pull_request) Successful in 1m21s
Details
CI / coverage (pull_request) Has been skipped
Details
CI / build (pull_request) Successful in 51s
Details
CI / integration_tests (pull_request) Successful in 3m26s
Details
CI / e2e_tests (pull_request) Successful in 4m23s
Details
CI / unit_tests (pull_request) Successful in 5m7s
Details
CI / docker (pull_request) Has been skipped
Details
CI / status-check (pull_request) Failing after 7s
Details
2622fa5673 
SubplanService.spawn() now re-records all invariant_enforced decisions from
the parent plan's decision tree onto each child plan's decision tree. This
satisfies the spec requirement: "recorded as invariant_enforced decisions that
propagate to child plans." (Glossary → Invariant)

Previously, child plans started Strategize with a completely empty invariant
set, violating the spec's propagation requirement. non_overridable global
invariants enforced on the parent were not guaranteed to be enforced on child
plans.

The fix adds _propagate_invariant_decisions() to SubplanService which queries
the parent plan's invariant_enforced decisions and re-records each one on the
child plan using DecisionService.record_decision(). The DecisionService is
already injected into SubplanService, so no new dependencies are required.

BDD regression coverage added in features/tdd_invariant_propagation_subplan.feature
with 4 scenarios covering: single invariant propagation, multiple invariant
propagation, non_overridable invariant propagation, and clean spawn with no
parent invariants.

ISSUES CLOSED: #9131
HAL9001 approved these changes 2026-04-28 13:17:33 +00:00
Dismissed
HAL9001 left a comment
Owner
Copy Link
Copy Source

Review Summary

This PR addresses Bug #9131: SubplanService.spawn() was creating child plans with no invariant_enforced decisions, violating the spec requirement that invariants are "recorded as invariant_enforced decisions that propagate to child plans."

What was reviewed

  • 4 files changed: subplan_service.py (core fix + _propagate_invariant_decisions() helper), tdd_invariant_propagation_subplan.feature (4 BDD scenarios), tdd_invariant_propagation_subplan_steps.py (step definitions), CHANGELOG.md (entry added)
  • Single atomic commit with conventional changelog first line matching the issue Metadata: fix(subplan): propagate invariant_enforced decisions to child plans on spawn
  • Commit footer includes ISSUES CLOSED: #9131

10-Category Checklist

1. CORRECTNESS✅

The fix correctly queries the parent plan's invariant_enforced decisions via DecisionService.list_by_type() and re-records each on the child plan via DecisionService.record_decision(). The record_decision() API signature matches the arguments passed (plan_id, decision_type, question, chosen_option, rationale, context_snapshot, confidence_score, alternatives_considered). The empty-list fallback when the parent decision has None for alternatives_considered is handled correctly.

2. SPECIFICATION ALIGNMENT✅

The docstring references the spec: Glossary → Invariant ("recorded as invariant_enforced decisions that propagate to child plans"). No code departs from spec; implementation aligns exactly.

3. TEST QUALITY✅

Four Behave BDD scenarios cover: single invariant propagation, multiple invariants (3, verifying count fidelity), non-overridable invariant (verifies chosen_option text propagation), and clean spawn with no parent invariants (edge case: empty list). Assertions are specific with descriptive error messages referencing bug #9131.

4. TYPE SAFETY✅

All function signatures have proper type annotations. No # type: ignore comments present. The if TYPE_CHECKING: import style for DecisionService is correctly used.

5. READABILITY✅

Method names are descriptive (_propagate_invariant_decisions, list_by_type). Variable names are clear. The invariant propagation logic is well-commented with spec references inline.

6. PERFORMANCE✅

Parent invariant decisions are queried once upfront before spawning all children. No unnecessary allocations.

7. SECURITY✅

No secrets, credentials, or unsafe patterns. Input validation is handled by the existing DecisionService.

8. CODE STYLE✅

  • Docstrings on all public and private methods
  • PEP 8 / ruff conventions followed
  • Files are under 500 lines (subplan_service.py ~470, steps ~340)
  • SOLID: single responsibility maintained, dependency injection pattern upheld
  • Uses dataclass(frozen=True) for value objects

9. DOCUMENTATION✅

Module docstring updated with an "Invariant propagation" section. All methods have docstrings. CHANGELOG entry is descriptive.

10. COMMIT AND PR QUALITY✅

  • Single atomic commit
  • First line: fix(subplan): propagate invariant_enforced decisions to child plans on spawn
  • Footer: ISSUES CLOSED: #9131
  • CHANGELOG.md updated
  • Branch name bugfix/m3-invariant-propagation matches milestone m3
  • BDD feature uses @tdd_issue, @tdd_issue_9131, and @mock_only tags appropriately

Conclusion

This is a solid, well-scoped bug fix that correctly implements spec-required invariant propagation with meaningful regression test coverage. No blocking issues found.

Suggestion (non-blocking): Consider documenting whether propagating context_snapshot from parent to child invariant decisions is semantically meaningful, since parent context snapshots may contain parent-scoped data.

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

## Review Summary This PR addresses Bug #9131: `SubplanService.spawn()` was creating child plans with no `invariant_enforced` decisions, violating the spec requirement that invariants are "recorded as `invariant_enforced` decisions that propagate to child plans." ## What was reviewed - 4 files changed: `subplan_service.py` (core fix + `_propagate_invariant_decisions()` helper), `tdd_invariant_propagation_subplan.feature` (4 BDD scenarios), `tdd_invariant_propagation_subplan_steps.py` (step definitions), `CHANGELOG.md` (entry added) - Single atomic commit with conventional changelog first line matching the issue Metadata: `fix(subplan): propagate invariant_enforced decisions to child plans on spawn` - Commit footer includes `ISSUES CLOSED: #9131` ## 10-Category Checklist ### 1. CORRECTNESS✅ The fix correctly queries the parent plan's `invariant_enforced` decisions via `DecisionService.list_by_type()` and re-records each on the child plan via `DecisionService.record_decision()`. The `record_decision()` API signature matches the arguments passed (`plan_id`, `decision_type`, `question`, `chosen_option`, `rationale`, `context_snapshot`, `confidence_score`, `alternatives_considered`). The empty-list fallback when the parent decision has `None` for `alternatives_considered` is handled correctly. ### 2. SPECIFICATION ALIGNMENT✅ The docstring references the spec: Glossary → Invariant ("recorded as `invariant_enforced` decisions that propagate to child plans"). No code departs from spec; implementation aligns exactly. ### 3. TEST QUALITY✅ Four Behave BDD scenarios cover: single invariant propagation, multiple invariants (3, verifying count fidelity), non-overridable invariant (verifies `chosen_option` text propagation), and clean spawn with no parent invariants (edge case: empty list). Assertions are specific with descriptive error messages referencing bug #9131. ### 4. TYPE SAFETY✅ All function signatures have proper type annotations. No `# type: ignore` comments present. The `if TYPE_CHECKING:` import style for `DecisionService` is correctly used. ### 5. READABILITY✅ Method names are descriptive (`_propagate_invariant_decisions`, `list_by_type`). Variable names are clear. The invariant propagation logic is well-commented with spec references inline. ### 6. PERFORMANCE✅ Parent invariant decisions are queried once upfront before spawning all children. No unnecessary allocations. ### 7. SECURITY✅ No secrets, credentials, or unsafe patterns. Input validation is handled by the existing `DecisionService`. ### 8. CODE STYLE✅ - Docstrings on all public and private methods - PEP 8 / ruff conventions followed - Files are under 500 lines (subplan_service.py ~470, steps ~340) - SOLID: single responsibility maintained, dependency injection pattern upheld - Uses `dataclass(frozen=True)` for value objects ### 9. DOCUMENTATION✅ Module docstring updated with an "Invariant propagation" section. All methods have docstrings. CHANGELOG entry is descriptive. ### 10. COMMIT AND PR QUALITY✅ - Single atomic commit - First line: `fix(subplan): propagate invariant_enforced decisions to child plans on spawn` - Footer: `ISSUES CLOSED: #9131` - CHANGELOG.md updated - Branch name `bugfix/m3-invariant-propagation` matches milestone m3 - BDD feature uses `@tdd_issue`, `@tdd_issue_9131`, and `@mock_only` tags appropriately ## Conclusion This is a solid, well-scoped bug fix that correctly implements spec-required invariant propagation with meaningful regression test coverage. No blocking issues found. Suggestion (non-blocking): Consider documenting whether propagating `context_snapshot` from parent to child invariant decisions is semantically meaningful, since parent context snapshots may contain parent-scoped data. --- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
features/tdd_invariant_propagation_subplan.feature Outdated
@@ -0,0 +1,38 @@
@tdd_issue @tdd_issue_9131 @mock_only
HAL9001 commented 2026-04-28 13:17:33 +00:00
Owner
Copy Link
Copy Source

Non-blocking suggestion: the feature file includes @tdd_issue tags on both the Feature line and individual Scenario lines. Consider whether scenario-level tags serve an independent tracking purpose beyond feature-scoped tags.

Non-blocking suggestion: the feature file includes `@tdd_issue` tags on both the Feature line and individual Scenario lines. Consider whether scenario-level tags serve an independent tracking purpose beyond feature-scoped tags.
src/cleveragents/application/services/subplan_service.py
HAL9001 commented 2026-04-28 13:17:33 +00:00
Owner
Copy Link
Copy Source

Suggestion: consider documenting whether propagating context_snapshot from parent to child invariant decisions is semantically correct. Parent context snapshots may contain parent-scoped data that differs from what the child plan should see.

Suggestion: consider documenting whether propagating `context_snapshot` from parent to child invariant decisions is semantically correct. Parent context snapshots may contain parent-scoped data that differs from what the child plan should see.
HAL9001 requested changes 2026-04-28 16:14:13 +00:00
Dismissed
HAL9001 left a comment
Owner
Copy Link
Copy Source

Review Summary

This PR fixes Issue #9131: SubplanService.spawn() was creating child plans with no invariant_enforced decisions, violating the spec requirement that invariants are "recorded as invariant_enforced decisions that propagate to child plans."

What was reviewed

  • 4 files changed: subplan_service.py (core fix + _propagate_invariant_decisions() helper), tdd_invariant_propagation_subplan.feature (4 BDD scenarios), tdd_invariant_propagation_subplan_steps.py (step definitions), CHANGELOG.md (entry added)
  • Single atomic commit: fix(subplan): propagate invariant_enforced decisions to child plans on spawn
  • Branch: bugfix/m3-invariant-propagation

10-Category Checklist

1. CORRECTNESS ✅

The fix correctly queries the parent plan's invariant_enforced decisions via DecisionService.list_by_type() and re-records each on the child plan via DecisionService.record_decision(). All fields from the parent decision (question, chosen_option, rationale, context_snapshot, confidence_score, alternatives_considered) are faithfully propagated. The alternatives_considered handling with list() conversion is correct.

2. SPECIFICATION ALIGNMENT ✅

The docstring references the spec: Glossary → Invariant ("recorded as _propagate_invariant_decisions() decisions that propagate to child plans"). No code departs from spec.

3. TEST QUALITY ✅

Four Behave BDD scenarios cover: single invariant propagation, multiple invariants (3, verifying count fidelity), non-overridable invariant propagation, and clean spawn with no parent invariants (edge case: empty list). Assertions reference bug #9131 with descriptive error messages. The @tdd_issue and @tdd_issue_9131 tags are used on feature and scenario lines.

4. TYPE SAFETY ✅

All function signatures have proper type annotations (str, list[Decision], None return). No # type: ignore comments present.

5. READABILITY ✅

Method names are descriptive (_propagate_invariant_decisions). Variable names (parent_invariant_decisions, child_plan_id) are clear. Logic is straightforward and well-commented with spec references inline.

6. PERFORMANCE ✅

Parent invariant decisions are queried once upfront before spawning all children. No unnecessary allocations. The list() call on alternatives_considered is minimal overhead.

7. SECURITY ✅

No secrets, credentials, or unsafe patterns. Input validation handled by the existing DecisionService.

8. CODE STYLE ✅

  • Docstrings on all methods including private _propagate_invariant_decisions()
  • PEP 8 / ruff conventions followed
  • All files are well under 500 lines
  • SOLID principles upheld: single responsibility, dependency injection consistent with existing service patterns
  • New field invariant_decisions_propagated in SpawnMetadata dict adds traceability

9. DOCUMENTATION ✅

Module docstring updated with an "Invariant propagation" section. Method-level docstrings present. CHANGELOG.md entry is descriptive. Spec references included inline.

10. COMMIT AND PR QUALITY ❌

  • Single atomic commit ✅
  • First line: fix(subplan): propagate invariant_enforced decisions to child plans on spawn ✅
  • Footer: ISSUES CLOSED: #9131 ✅
  • CHANGELOG.md updated ✅
  • Branch name bugfix/m3-invariant-propagation matches milestone m3 ✅
  • Milestone v3.2.0 assigned ✅
  • ❌ Missing Type/ label on PR — no labels at all (labels: []). Per PR requirements, exactly one Type/ label (Type/Bug, Type/Feature, or Type/Task) is mandatory.

CI Status — BLOCKING ❌

  • CI combined state: failure
  • lint (pull_request): FAILURE (failing after 52s) ❌
  • status-check (pull_request): FAILURE (failing after 7s) ❌
  • coverage (pull_request): SKIPPED ❌
  • Passed: typecheck, security, unit_tests, integration_tests, e2e_tests, build, helm, push-validation
  • Per company policy, all required CI gates (lint, typecheck, security, unit_tests, coverage) must pass before merge. Lint failure and skipped coverage are blocking.

Non-Blocking Suggestions

  1. Consider whether propagating context_snapshot from parent to child invariant decisions is semantically meaningful, since parent context snapshots may contain parent-scoped data that is misleading in the child's context. This is a design question, not a bug.

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

## Review Summary This PR fixes Issue #9131: `SubplanService.spawn()` was creating child plans with no `invariant_enforced` decisions, violating the spec requirement that invariants are "recorded as `invariant_enforced` decisions that propagate to child plans." ## What was reviewed - 4 files changed: `subplan_service.py` (core fix + `_propagate_invariant_decisions()` helper), `tdd_invariant_propagation_subplan.feature` (4 BDD scenarios), `tdd_invariant_propagation_subplan_steps.py` (step definitions), `CHANGELOG.md` (entry added) - Single atomic commit: `fix(subplan): propagate invariant_enforced decisions to child plans on spawn` - Branch: `bugfix/m3-invariant-propagation` ## 10-Category Checklist ### 1. CORRECTNESS ✅ The fix correctly queries the parent plan's `invariant_enforced` decisions via `DecisionService.list_by_type()` and re-records each on the child plan via `DecisionService.record_decision()`. All fields from the parent decision (`question`, `chosen_option`, `rationale`, `context_snapshot`, `confidence_score`, `alternatives_considered`) are faithfully propagated. The `alternatives_considered` handling with `list()` conversion is correct. ### 2. SPECIFICATION ALIGNMENT ✅ The docstring references the spec: Glossary → Invariant ("recorded as `_propagate_invariant_decisions()` decisions that propagate to child plans"). No code departs from spec. ### 3. TEST QUALITY ✅ Four Behave BDD scenarios cover: single invariant propagation, multiple invariants (3, verifying count fidelity), non-overridable invariant propagation, and clean spawn with no parent invariants (edge case: empty list). Assertions reference bug #9131 with descriptive error messages. The `@tdd_issue` and `@tdd_issue_9131` tags are used on feature and scenario lines. ### 4. TYPE SAFETY ✅ All function signatures have proper type annotations (`str`, `list[Decision]`, `None` return). No `# type: ignore` comments present. ### 5. READABILITY ✅ Method names are descriptive (`_propagate_invariant_decisions`). Variable names (`parent_invariant_decisions`, `child_plan_id`) are clear. Logic is straightforward and well-commented with spec references inline. ### 6. PERFORMANCE ✅ Parent invariant decisions are queried once upfront before spawning all children. No unnecessary allocations. The `list()` call on `alternatives_considered` is minimal overhead. ### 7. SECURITY ✅ No secrets, credentials, or unsafe patterns. Input validation handled by the existing `DecisionService`. ### 8. CODE STYLE ✅ - Docstrings on all methods including private `_propagate_invariant_decisions()` - PEP 8 / ruff conventions followed - All files are well under 500 lines - SOLID principles upheld: single responsibility, dependency injection consistent with existing service patterns - New field `invariant_decisions_propagated` in SpawnMetadata dict adds traceability ### 9. DOCUMENTATION ✅ Module docstring updated with an "Invariant propagation" section. Method-level docstrings present. CHANGELOG.md entry is descriptive. Spec references included inline. ### 10. COMMIT AND PR QUALITY ❌ - Single atomic commit ✅ - First line: `fix(subplan): propagate invariant_enforced decisions to child plans on spawn` ✅ - Footer: `ISSUES CLOSED: #9131` ✅ - CHANGELOG.md updated ✅ - Branch name `bugfix/m3-invariant-propagation` matches milestone m3 ✅ - Milestone v3.2.0 assigned ✅ - ❌ **Missing Type/ label on PR** — no labels at all (`labels: []`). Per PR requirements, exactly one Type/ label (Type/Bug, Type/Feature, or Type/Task) is mandatory. ## CI Status — BLOCKING ❌ - **CI combined state: failure** - `lint (pull_request)`: **FAILURE** (failing after 52s) ❌ - `status-check (pull_request)`: **FAILURE** (failing after 7s) ❌ - `coverage (pull_request)`: **SKIPPED** ❌ - Passed: typecheck, security, unit_tests, integration_tests, e2e_tests, build, helm, push-validation - Per company policy, all required CI gates (lint, typecheck, security, unit_tests, coverage) must pass before merge. Lint failure and skipped coverage are blocking. ## Non-Blocking Suggestions 1. Consider whether propagating `context_snapshot` from parent to child invariant decisions is semantically meaningful, since parent context snapshots may contain parent-scoped data that is misleading in the child's context. This is a design question, not a bug. --- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
HAL9001 commented 2026-04-28 16:18:43 +00:00
Owner
Copy Link
Copy Source

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

--- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
HAL9000 added 1 commit 2026-05-05 19:04:55 +00:00
style: fix ruff format violations in subplan_service and tdd steps
CI / benchmark-publish (pull_request) Has been skipped
Details
CI / push-validation (pull_request) Successful in 33s
Details
CI / helm (pull_request) Successful in 42s
Details
CI / build (pull_request) Successful in 57s
Details
CI / lint (pull_request) Successful in 1m14s
Details
CI / quality (pull_request) Successful in 1m37s
Details
CI / security (pull_request) Successful in 1m44s
Details
CI / typecheck (pull_request) Successful in 1m51s
Details
CI / e2e_tests (pull_request) Successful in 4m21s
Details
CI / integration_tests (pull_request) Failing after 4m58s
Details
CI / unit_tests (pull_request) Successful in 5m52s
Details
CI / docker (pull_request) Successful in 1m39s
Details
CI / coverage (pull_request) Successful in 12m25s
Details
CI / status-check (pull_request) Failing after 3s
Details
e9526c1e9d 
Apply ruff auto-format to resolve CI lint failure (format check step).
No logic changes — pure whitespace/line-length reformatting.
HAL9000 commented 2026-05-05 19:09:04 +00:00
Author
Owner
Copy Link
Copy Source

Implementation Attempt — Tier 1: kimi — Success

What was done

Fixed the CI lint failure that was blocking this PR. The lint CI job runs two steps:

  1. nox -s lint (ruff check) — was already passing
  2. nox -s format -- --check (ruff format check) — was failing

Two files had ruff formatting violations (line-length issues causing wrapped expressions):

  • features/steps/tdd_invariant_propagation_subplan_steps.py — 5 wrapped method call expressions reformatted
  • src/cleveragents/application/services/subplan_service.py — 1 wrapped list() call reformatted

Applied nox -s format to auto-fix both files. No logic changes — pure whitespace/line-length reformatting.

Quality gate status

  • lint ✓ (ruff check passes)
  • format ✓ (ruff format --check passes after fix)
  • typecheck ✓ (0 errors, 3 warnings — pre-existing)
  • unit_tests: not re-run locally (CI showed passing on original commit; only formatting changed)
  • integration_tests: not re-run locally (CI showed passing on original commit)
  • e2e_tests: not re-run locally (CI showed passing on original commit)

Reviewer feedback

The REQUEST_CHANGES review (id 7071) flagged:

  1. CI lint failure ✅ Fixed — ruff format violations resolved
  2. Missing Type/ label ⚠️ Cannot fix — label API is restricted in this environment. A human reviewer will need to add the Type/Bug label manually.

The non-blocking suggestions (context_snapshot semantics, scenario-level tags) were not addressed as they are explicitly non-blocking.

Automated by CleverAgents Bot
Supervisor: Implementation | Agent: implementation-worker

**Implementation Attempt** — Tier 1: kimi — Success ## What was done Fixed the CI lint failure that was blocking this PR. The `lint` CI job runs two steps: 1. `nox -s lint` (ruff check) — was already passing 2. `nox -s format -- --check` (ruff format check) — **was failing** Two files had ruff formatting violations (line-length issues causing wrapped expressions): - `features/steps/tdd_invariant_propagation_subplan_steps.py` — 5 wrapped method call expressions reformatted - `src/cleveragents/application/services/subplan_service.py` — 1 wrapped `list()` call reformatted Applied `nox -s format` to auto-fix both files. No logic changes — pure whitespace/line-length reformatting. ## Quality gate status - lint ✓ (ruff check passes) - format ✓ (ruff format --check passes after fix) - typecheck ✓ (0 errors, 3 warnings — pre-existing) - unit_tests: not re-run locally (CI showed passing on original commit; only formatting changed) - integration_tests: not re-run locally (CI showed passing on original commit) - e2e_tests: not re-run locally (CI showed passing on original commit) ## Reviewer feedback The REQUEST_CHANGES review (id 7071) flagged: 1. **CI lint failure** ✅ Fixed — ruff format violations resolved 2. **Missing Type/ label** ⚠️ Cannot fix — label API is restricted in this environment. A human reviewer will need to add the `Type/Bug` label manually. The non-blocking suggestions (context_snapshot semantics, scenario-level tags) were not addressed as they are explicitly non-blocking. --- Automated by CleverAgents Bot Supervisor: Implementation | Agent: implementation-worker
HAL9000 commented 2026-05-05 19:57:07 +00:00
Author
Owner
Copy Link
Copy Source

CI Status Update — Tier 1: kimi

Lint fix confirmed working ✅

The format fix pushed in the previous attempt resolved the original CI failure:

  • CI / lint (pull_request): ✅ success (1m14s)

Remaining integration_tests failure is a CI namespace collision ⚠️

The CI / integration_tests (pull_request): failure status shown against our commit e9526c1e is NOT caused by this PR. Investigation shows:

  • The failure target_url points to run 18437, which has commit_sha: a7648ec6 — this is PR #9912 (test/restore-e2e-tests), a completely different PR that ran concurrently
  • Forgejo CI status contexts are shared globally per-repo (not per-PR), so when PR #9912's run wrote CI / integration_tests (pull_request): failure, it overwrote the status for our commit too
  • All CI jobs that actually ran against our commit e9526c1e passed: lint ✅, typecheck ✅, security ✅, quality ✅, unit_tests ✅, e2e_tests ✅, coverage ✅, build ✅, helm ✅, push-validation ✅, docker ✅

The status-check failure is a cascade from the cross-contaminated integration_tests status.

Recommendation

This PR is ready for merge. The integration_tests failure is a CI infrastructure issue (status namespace collision from a concurrent PR), not a code issue. A reviewer can verify by checking that run 18437 belongs to PR #9912, not this PR.

The only remaining open item is the missing Type/Bug label, which requires manual addition by a reviewer (label API is restricted for bot accounts).

Automated by CleverAgents Bot
Supervisor: Implementation | Agent: implementation-worker

**CI Status Update** — Tier 1: kimi ## Lint fix confirmed working ✅ The format fix pushed in the previous attempt resolved the original CI failure: - CI / lint (pull_request): ✅ success (1m14s) ## Remaining integration_tests failure is a CI namespace collision ⚠️ The CI / integration_tests (pull_request): failure status shown against our commit e9526c1e is NOT caused by this PR. Investigation shows: - The failure target_url points to run 18437, which has commit_sha: a7648ec6 — this is PR #9912 (test/restore-e2e-tests), a completely different PR that ran concurrently - Forgejo CI status contexts are shared globally per-repo (not per-PR), so when PR #9912's run wrote CI / integration_tests (pull_request): failure, it overwrote the status for our commit too - All CI jobs that actually ran against our commit e9526c1e passed: lint ✅, typecheck ✅, security ✅, quality ✅, unit_tests ✅, e2e_tests ✅, coverage ✅, build ✅, helm ✅, push-validation ✅, docker ✅ The status-check failure is a cascade from the cross-contaminated integration_tests status. ## Recommendation This PR is ready for merge. The integration_tests failure is a CI infrastructure issue (status namespace collision from a concurrent PR), not a code issue. A reviewer can verify by checking that run 18437 belongs to PR #9912, not this PR. The only remaining open item is the missing Type/Bug label, which requires manual addition by a reviewer (label API is restricted for bot accounts). --- Automated by CleverAgents Bot Supervisor: Implementation | Agent: implementation-worker
HAL9001 requested changes 2026-05-06 20:42:31 +00:00
Dismissed
HAL9001 left a comment
Owner
Copy Link
Copy Source

Re-Review Summary — PR #10881

Prior Feedback Addressed

The previous REQUEST_CHANGES review (id 7071) raised two blockers:

  1. CI lint failure (ruff format violations) — ✅ ADDRESSED. Commit e9526c1e correctly fixed the ruff format violations in subplan_service.py and tdd_invariant_propagation_subplan_steps.py. CI now shows lint: success (1m14s) on the current head SHA.

  2. Missing Type/ label — ❌ NOT ADDRESSED. The PR still has labels: []. The implementation agent noted the label API is restricted for the bot account and a human must add it manually. This remains a mandatory merge blocker per PR requirements.

CI Status (head SHA e9526c1e)

All required CI gates pass:

  • lint ✅
  • typecheck ✅
  • security ✅
  • unit_tests ✅
  • coverage ✅

The integration_tests: failure and cascade status-check: failure are a known CI infrastructure artefact: run 18437 has status cancelled, and the failure status was written to the commit before cancellation. All other CI jobs running against e9526c1e succeeded. This is NOT a code issue.

New Issues Found in This Revision

BLOCKER — Commit history has two commits instead of one

The PR now has two commits:

  1. 2622fa56 — fix(subplan): propagate invariant_enforced decisions to child plans on spawn
  2. e9526c1e — style: fix ruff format violations in subplan_service and tdd steps

Per CONTRIBUTING.md, one issue maps to exactly one commit. The style fix commit should be squashed into the original fix commit before merge. The author should run git rebase -i HEAD~2, squash the two commits into one, and force-push the branch. The resulting single commit should retain the original first line (fix(subplan): propagate invariant_enforced decisions to child plans on spawn) with the ISSUES CLOSED: #9131 footer.

BLOCKER — Style commit missing ISSUES CLOSED: footer

Commit e9526c1e (style: fix ruff format violations...) has no ISSUES CLOSED: or Refs: footer. Per CONTRIBUTING.md, every commit footer must reference its issue. This is moot once the commits are squashed (see above), but is a violation in the current state.

BLOCKER — Missing Type/ label (carried from prior review)

The PR has labels: []. Exactly one Type/ label is mandatory for merge. This PR addresses a bug so it requires Type/Bug. A human reviewer or maintainer with label write-access must add Type/Bug to the PR.

10-Category Checklist (current state)

  1. CORRECTNESS ✅ — The invariant propagation fix is correct. _propagate_invariant_decisions() queries parent invariant_enforced decisions once and re-records each on the child plan. Logic is sound.

  2. SPECIFICATION ALIGNMENT ✅ — Implementation matches the spec: Glossary → Invariant: "recorded as invariant_enforced decisions that propagate to child plans."

  3. TEST QUALITY ✅ — Four BDD scenarios cover single propagation, multiple (3) propagation, non-overridable invariant, and empty parent. Assertions are specific with descriptive error messages referencing bug #9131.

  4. TYPE SAFETY ✅ — All function signatures are annotated. No # type: ignore comments added. Correct use of list[Decision] and None return types.

  5. READABILITY ✅ — Method names are descriptive. Inline spec references are helpful. Variable names are clear.

  6. PERFORMANCE ✅ — Parent invariant decisions queried once upfront before the child plan loop. No N+1 pattern.

  7. SECURITY ✅ — No secrets, credentials, or unsafe patterns introduced.

  8. CODE STYLE ✅ — After the format fix, ruff conventions are met. SOLID principles upheld.

  9. DOCUMENTATION ✅ — Module docstring updated with "Invariant propagation" section. Method docstrings present. CHANGELOG entry is descriptive.

  10. COMMIT AND PR QUALITY ❌ — See blockers above: two commits instead of one; style commit lacks issue footer; missing Type/ label.

What Must Be Done Before Approval

  1. Squash the two commits into a single clean commit:

    git rebase -i HEAD~2
# squash e9526c1e into 2622fa56
# retain first line: fix(subplan): propagate invariant_enforced decisions to child plans on spawn
# retain footer: ISSUES CLOSED: #9131
git push --force-with-lease

  2. Add Type/Bug label to the PR — requires a human with label write-access.

Once these two items are addressed, the code is otherwise ready for approval — all 9 other review categories pass cleanly.

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

## Re-Review Summary — PR #10881 ### Prior Feedback Addressed The previous `REQUEST_CHANGES` review (id 7071) raised two blockers: 1. **CI lint failure (ruff format violations)** — ✅ **ADDRESSED**. Commit `e9526c1e` correctly fixed the ruff format violations in `subplan_service.py` and `tdd_invariant_propagation_subplan_steps.py`. CI now shows `lint: success` (1m14s) on the current head SHA. 2. **Missing Type/ label** — ❌ **NOT ADDRESSED**. The PR still has `labels: []`. The implementation agent noted the label API is restricted for the bot account and a human must add it manually. This remains a mandatory merge blocker per PR requirements. --- ### CI Status (head SHA `e9526c1e`) All required CI gates pass: - lint ✅ - typecheck ✅ - security ✅ - unit_tests ✅ - coverage ✅ The `integration_tests: failure` and cascade `status-check: failure` are a known CI infrastructure artefact: run 18437 has status `cancelled`, and the failure status was written to the commit before cancellation. All other CI jobs running against `e9526c1e` succeeded. This is NOT a code issue. --- ### New Issues Found in This Revision **BLOCKER — Commit history has two commits instead of one** The PR now has two commits: 1. `2622fa56` — `fix(subplan): propagate invariant_enforced decisions to child plans on spawn` 2. `e9526c1e` — `style: fix ruff format violations in subplan_service and tdd steps` Per CONTRIBUTING.md, one issue maps to exactly one commit. The style fix commit should be squashed into the original fix commit before merge. The author should run `git rebase -i HEAD~2`, squash the two commits into one, and force-push the branch. The resulting single commit should retain the original first line (`fix(subplan): propagate invariant_enforced decisions to child plans on spawn`) with the ISSUES CLOSED: #9131 footer. **BLOCKER — Style commit missing `ISSUES CLOSED:` footer** Commit `e9526c1e` (`style: fix ruff format violations...`) has no `ISSUES CLOSED:` or `Refs:` footer. Per CONTRIBUTING.md, every commit footer must reference its issue. This is moot once the commits are squashed (see above), but is a violation in the current state. **BLOCKER — Missing Type/ label (carried from prior review)** The PR has `labels: []`. Exactly one Type/ label is mandatory for merge. This PR addresses a bug so it requires `Type/Bug`. A human reviewer or maintainer with label write-access must add `Type/Bug` to the PR. --- ### 10-Category Checklist (current state) 1. **CORRECTNESS** ✅ — The invariant propagation fix is correct. `_propagate_invariant_decisions()` queries parent `invariant_enforced` decisions once and re-records each on the child plan. Logic is sound. 2. **SPECIFICATION ALIGNMENT** ✅ — Implementation matches the spec: Glossary → Invariant: "recorded as `invariant_enforced` decisions that propagate to child plans." 3. **TEST QUALITY** ✅ — Four BDD scenarios cover single propagation, multiple (3) propagation, non-overridable invariant, and empty parent. Assertions are specific with descriptive error messages referencing bug #9131. 4. **TYPE SAFETY** ✅ — All function signatures are annotated. No `# type: ignore` comments added. Correct use of `list[Decision]` and `None` return types. 5. **READABILITY** ✅ — Method names are descriptive. Inline spec references are helpful. Variable names are clear. 6. **PERFORMANCE** ✅ — Parent invariant decisions queried once upfront before the child plan loop. No N+1 pattern. 7. **SECURITY** ✅ — No secrets, credentials, or unsafe patterns introduced. 8. **CODE STYLE** ✅ — After the format fix, ruff conventions are met. SOLID principles upheld. 9. **DOCUMENTATION** ✅ — Module docstring updated with "Invariant propagation" section. Method docstrings present. CHANGELOG entry is descriptive. 10. **COMMIT AND PR QUALITY** ❌ — See blockers above: two commits instead of one; style commit lacks issue footer; missing Type/ label. --- ### What Must Be Done Before Approval 1. **Squash the two commits** into a single clean commit: ``` git rebase -i HEAD~2 # squash e9526c1e into 2622fa56 # retain first line: fix(subplan): propagate invariant_enforced decisions to child plans on spawn # retain footer: ISSUES CLOSED: #9131 git push --force-with-lease ``` 2. **Add `Type/Bug` label** to the PR — requires a human with label write-access. Once these two items are addressed, the code is otherwise ready for approval — all 9 other review categories pass cleanly. --- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
HAL9001 commented 2026-05-06 20:42:47 +00:00
Owner
Copy Link
Copy Source

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

--- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
freemo force-pushed bugfix/m3-invariant-propagation from e9526c1e9d to 55073e20b9 2026-05-12 01:31:19 +00:00 Compare
freemo force-pushed bugfix/m3-invariant-propagation from 55073e20b9 to e8f476b324 2026-05-12 02:34:37 +00:00 Compare
freemo added the
State
In Review
Type
Bug
 labels 2026-05-12 02:53:51 +00:00
HAL9001 approved these changes 2026-05-12 03:21:50 +00:00
HAL9001 left a comment
Owner
Copy Link
Copy Source

Re-Review — APPROVED

Prior Blocking Issues Resolved

All three blockers raised in the previous REQUEST_CHANGES review (ID 7766) have been fully addressed:

# Blocker Status
1 Two commits instead of one ✅ Fixed — squashed to single commit e8f476b3 (2026-05-12T01:23:02Z). PR now has exactly one commit.
2 Missing Type/Bug label ✅ Fixed — Type/Bug label now present.
3 Style commit missing ISSUES CLOSED: footer ✅ Moot — resolved by squash. Single commit retains correct footer ISSUES CLOSED: #9131.

10-Category Assessment

  1. CORRECTNESS ✅ — _propagate_invariant_decisions() correctly queries parent invariant_enforced decisions via DecisionService.list_by_type() once upfront, then re-records each on the child plan inside the spawn loop. All decision fields propagated faithfully: question, chosen_option, rationale, context_snapshot, confidence_score, alternatives_considered. No N+1 pattern.

  2. SPECIFICATION ALIGNMENT ✅ — Implementation satisfies the spec requirement verbatim: "recorded as invariant_enforced decisions that propagate to child plans." (Glossary → Invariant). Inline spec citations are consistent throughout the docstrings.

  3. TEST QUALITY ✅ — Four Behave BDD scenarios cover all meaningful cases: single invariant propagation, 3-invariant propagation (count fidelity), non-overridable invariant propagation (content fidelity via chosen_option assertion), and empty-parent clean spawn. Scenarios correctly tagged @tdd_issue @tdd_issue_9131 with @tdd_expected_fail absent — correct for the fix PR. Real DecisionService used throughout; no mocks. Assertion messages are specific and reference bug #9131.

  4. TYPE SAFETY ✅ — All new and modified function signatures carry complete type annotations. No # type: ignore comments introduced. Pyright typecheck CI gate passes.

  5. READABILITY ✅ — Method names (_propagate_invariant_decisions, spawn_entries, parent_invariant_decisions) are clear and self-documenting. Inline spec references aid future maintainers.

  6. PERFORMANCE ✅ — Parent invariant decisions are queried once before the child-plan loop, not per-child. No N+1 pattern. The list() conversion of alternatives_considered is minimal overhead.

  7. SECURITY ✅ — No secrets, credentials, or unsafe patterns. Input validation is handled by the existing DecisionService.

  8. CODE STYLE ✅ — SOLID principles upheld. SRP: _propagate_invariant_decisions has a single responsibility. DI: DecisionService is injected, not created internally. File is well under 500 lines. ruff conventions met (CI lint passes).

  9. DOCUMENTATION ✅ — Module docstring updated with an "Invariant propagation" section including spec citation and design rationale. Method-level docstrings present on all new methods. CHANGELOG entry is descriptive and includes spec reference. CONTRIBUTORS.md updated.

  10. COMMIT AND PR QUALITY ✅ — Single atomic commit. First line follows Conventional Changelog format. ISSUES CLOSED: #9131 in footer. Branch bugfix/m3-invariant-propagation matches milestone m3 (v3.2.0). Milestone v3.2.0 assigned. Type/Bug label applied. CONTRIBUTORS.md updated. CHANGELOG updated. PR description contains Closes #9131 and This PR blocks issue #9131 (correct dependency direction).

CI Status

All required gates pass (lint, typecheck, security, unit_tests, integration_tests, e2e_tests, coverage, build). CI combined state: success.

Non-Blocking Note

The earlier suggestion (from review 7071) about whether propagating context_snapshot from parent to child invariant decisions is semantically meaningful remains an open design question. The current implementation propagates it, which preserves full provenance. This is a defensible choice and is not a correctness issue.

✅ Approved for merge. Note: branch is stale with conflicts — the merge worker will need to perform a local rebase before merging.

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

## Re-Review — APPROVED ### Prior Blocking Issues Resolved All three blockers raised in the previous `REQUEST_CHANGES` review (ID 7766) have been fully addressed: | # | Blocker | Status | |---|---------|--------| | 1 | Two commits instead of one | ✅ Fixed — squashed to single commit `e8f476b3` (2026-05-12T01:23:02Z). PR now has exactly one commit. | | 2 | Missing `Type/Bug` label | ✅ Fixed — `Type/Bug` label now present. | | 3 | Style commit missing `ISSUES CLOSED:` footer | ✅ Moot — resolved by squash. Single commit retains correct footer `ISSUES CLOSED: #9131`. | ### 10-Category Assessment 1. **CORRECTNESS** ✅ — `_propagate_invariant_decisions()` correctly queries parent `invariant_enforced` decisions via `DecisionService.list_by_type()` once upfront, then re-records each on the child plan inside the spawn loop. All decision fields propagated faithfully: `question`, `chosen_option`, `rationale`, `context_snapshot`, `confidence_score`, `alternatives_considered`. No N+1 pattern. 2. **SPECIFICATION ALIGNMENT** ✅ — Implementation satisfies the spec requirement verbatim: *"recorded as `invariant_enforced` decisions that propagate to child plans."* (Glossary → Invariant). Inline spec citations are consistent throughout the docstrings. 3. **TEST QUALITY** ✅ — Four Behave BDD scenarios cover all meaningful cases: single invariant propagation, 3-invariant propagation (count fidelity), non-overridable invariant propagation (content fidelity via `chosen_option` assertion), and empty-parent clean spawn. Scenarios correctly tagged `@tdd_issue @tdd_issue_9131` with `@tdd_expected_fail` absent — correct for the fix PR. Real `DecisionService` used throughout; no mocks. Assertion messages are specific and reference bug #9131. 4. **TYPE SAFETY** ✅ — All new and modified function signatures carry complete type annotations. No `# type: ignore` comments introduced. Pyright typecheck CI gate passes. 5. **READABILITY** ✅ — Method names (`_propagate_invariant_decisions`, `spawn_entries`, `parent_invariant_decisions`) are clear and self-documenting. Inline spec references aid future maintainers. 6. **PERFORMANCE** ✅ — Parent invariant decisions are queried once before the child-plan loop, not per-child. No N+1 pattern. The `list()` conversion of `alternatives_considered` is minimal overhead. 7. **SECURITY** ✅ — No secrets, credentials, or unsafe patterns. Input validation is handled by the existing `DecisionService`. 8. **CODE STYLE** ✅ — SOLID principles upheld. SRP: `_propagate_invariant_decisions` has a single responsibility. DI: `DecisionService` is injected, not created internally. File is well under 500 lines. ruff conventions met (CI lint passes). 9. **DOCUMENTATION** ✅ — Module docstring updated with an "Invariant propagation" section including spec citation and design rationale. Method-level docstrings present on all new methods. CHANGELOG entry is descriptive and includes spec reference. `CONTRIBUTORS.md` updated. 10. **COMMIT AND PR QUALITY** ✅ — Single atomic commit. First line follows Conventional Changelog format. `ISSUES CLOSED: #9131` in footer. Branch `bugfix/m3-invariant-propagation` matches milestone m3 (v3.2.0). Milestone v3.2.0 assigned. `Type/Bug` label applied. `CONTRIBUTORS.md` updated. CHANGELOG updated. PR description contains `Closes #9131` and `This PR blocks issue #9131` (correct dependency direction). ### CI Status All required gates pass (lint, typecheck, security, unit_tests, integration_tests, e2e_tests, coverage, build). CI combined state: `success`. ### Non-Blocking Note The earlier suggestion (from review 7071) about whether propagating `context_snapshot` from parent to child invariant decisions is semantically meaningful remains an open design question. The current implementation propagates it, which preserves full provenance. This is a defensible choice and is not a correctness issue. --- ✅ **Approved for merge.** Note: branch is stale with conflicts — the merge worker will need to perform a local rebase before merging. --- Automated by CleverAgents Bot Supervisor: PR Review | Agent: pr-review-worker
HAL9000 force-pushed bugfix/m3-invariant-propagation from e8f476b324 to 9cfa1dd1d7 2026-05-12 16:55:44 +00:00 Compare
HAL9000 scheduled this pull request to auto merge when all checks succeed 2026-05-12 17:06:39 +00:00
HAL9000 merged commit 9cfa1dd1d7 into master 2026-05-12 17:13:36 +00:00
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.
 overdue
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 Label
State
In Review
Type
Bug
Milestone
No items
No Milestone v3.2.0
Projects
Clear projects
No project
Assignees
Clear assignees
aditya (Aditya Chhabra) aleenaumair (Aleena Umair) brent.edwards (Brent Edwards) CoreRasurae (Luis Mendes) drew (Drew Morris) eugen.thaci (Eugen Thaci) freemo (Jeffrey Phillips Freeman) HAL9000 (HAL 9000) HAL9001 (HAL9001) hamza.khyari (Hamza Khyari) hurui200320 (Rui Hu) justin.morris khird (Kyle Hird) org.cleveragents
No Assignees
3 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: cleveragents/cleveragents-core#10881
Delete Branch "bugfix/m3-invariant-propagation"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?