fix(cli): add --skill flag to actor run command #971

Merged

hurui200320 merged 1 commits from feature/m4-actor-run-skill into master 2026-03-19 09:30:36 +00:00

Conversation 13 Commits 1 Files Changed 20

+2027 -493

hurui200320 commented 2026-03-16 08:00:06 +00:00

Member

Copy Link

Copy Source

Summary

Add the missing --skill repeatable flag to actor run and actor-run CLI commands, aligning the implementation with the specification (CLI Synopsis line 277). The flag enables ad-hoc skill injection at runtime without modifying YAML configuration.

Closes #887

Changes

DI Container

• container.py: Added _build_skill_service() factory and skill_service Singleton provider, following the established _build_* pattern. Falls back to in-memory SkillService() when the database is unavailable. Exception handling narrowed to (ImportError, OperationalError, DatabaseError, OSError) with exc_info=True for traceability.

CLI Layer

• actor.py: Added --skill Typer option (list[str] | None, repeatable, metavar="NAME"). Help text notes that skills only augment tool-bearing agents. Wrapped constructor in the existing try/except block so CleverAgentsException from skill resolution is properly caught.
• actor_run.py: Same --skill option with metavar="NAME". Exception handler catches CleverAgentsException (matching master — not broadened to CleverAgentsError).
• skill.py: Removed module-level _service cache. _get_skill_service() now always delegates to get_container().skill_service() so that reset_container() correctly invalidates the cached instance. _reset_skill_service() now overrides the container's provider via providers.Object(). Removed dead validate_skill_names() function.

Runtime Layer

• application.py (438 lines, down from 625): ReactiveCleverAgentsApp gains skill_names parameter with automatic deduplication via dict.fromkeys. _resolve_skills() obtains SkillService from the DI container (no CLI layer import). Separate except KeyError and except ValueError produce distinct error messages ("not found in registry" vs "resolution failed: {exc}"). Skill tools are only injected into agents that already have tools (if self._resolved_skill_tools and tools:), preventing LLM agents from being converted to pass-through SimpleToolAgent instances. When skill tools are skipped for tool-less agents, logger.debug emits a diagnostic message. _sanitize_skill_name() validates skill name format with tightened regex: ^[\w.-]{1,127}/[\w.-]{1,127}$ with re.ASCII flag. Zero-tool skill warning now uses logger.warning (not print(stderr)), ensuring structured log output and proper log-level filtering.
• graph_executor.py (334 lines): Extracted graph execution logic. Type annotations improved.

Tests

• 24+ Behave scenarios across feature files covering: single/multiple/unknown skill flags, skill+context combined, duplicate deduplication, skill resolution, ValueError path, zero-tool resolution, error handling, tool merging, default behavior, overrides, LLM agent guard, _sanitize_skill_name edge cases (empty string, too-long name, ANSI escape codes, disallowed characters), _build_skill_service happy+fallback paths, _get_skill_service container delegation.
• CLI "unknown skill" tests for both actor.py and actor_run.py exercise the real error chain (mock only get_container(), not the entire ReactiveCleverAgentsApp), testing _resolve_skills() → CleverAgentsException → except CleverAgentsException → exit code 2 end-to-end.
• Combined skill+context tests assert ContextManager was instantiated and exists() was called in dedicated Then steps.
• @coverage tags added to all new scenarios.
• Robot Framework smoke tests added (robot/skill_actor_run.robot + robot/helper_skill_actor_run.py): unknown-skill error path and valid-skill acceptance path.

Changelog

• Added entry under ## Unreleased in CHANGELOG.md.

Review Fixes Applied (Brent Edwards, Rounds 1 & 2)

#	Finding	Resolution
P1-1	print(stderr) for zero-tool skill warning	Fixed — replaced with logger.warning("Skill '%s' resolved to zero tools", name), removed unused import sys
P2-2	Skill tools silently skipped for tool-less agents	Fixed — added logger.debug when skipped; updated --skill help text to note "only augments tool-bearing agents"
P2-3	container.py at 739 lines	Acknowledged — pre-existing growth (+59 lines for _build_skill_service); extracting factories is a separate refactoring task
P2-4↑	CleverAgentsException → CleverAgentsError broadens catch scope	Fixed — reverted actor_run.py to except CleverAgentsException matching master
P3-5	No Robot Framework smoke test for --skill	Fixed — added skill_actor_run.robot with 2 test cases (unknown-skill error, valid-skill acceptance)
P3-6	GraphExecutor._follow_chained_edges static-calling-static	Acknowledged — cosmetic pattern that doesn't affect correctness; can address in a follow-up

Known Limitations / Deferred Items

Item	Reason
actor.py at 679 lines (500-line guideline)	Pre-existing (670 on master), +9 lines for --skill. Refactoring the shared _execute() closure is a separate task.
container.py at 739 lines (500-line guideline)	Was 680 lines on master, +59 lines for _build_skill_service() and skill_service provider. Refactoring into sub-modules is a separate task.
Code duplication between actor.py and actor_run.py run()	~47 lines identical code. Coupled with the line-count issue above — both require extracting shared execution logic into a helper module.
SimpleToolAgent only executes tools[0]	Deferred to #974. Pre-existing architectural limitation, not introduced by this PR.
GraphExecutor._follow_chained_edges static-calling-static pattern	Cosmetic, doesn't affect behavior.

Quality Gates (post-rebase onto 2434253c)

• nox -s lint: ✅ PASS
• nox -s typecheck: ✅ PASS (0 errors)
• nox -s unit_tests: ✅ PASS (11,455 scenarios, 0 failures)
• nox -s integration_tests: ✅ PASS (1,599/1,600 — 1 flaky Uko Indexer > File Watching passes in isolation)
• nox -s e2e_tests: ✅ PASS (37 tests, 37 passed)
• nox -s coverage_report: ✅ 97% (meets threshold)
• Branch rebased onto latest master (2434253c)

## Summary Add the missing `--skill` repeatable flag to `actor run` and `actor-run` CLI commands, aligning the implementation with the specification (CLI Synopsis line 277). The flag enables ad-hoc skill injection at runtime without modifying YAML configuration. Closes #887 ## Changes ### DI Container - **`container.py`**: Added `_build_skill_service()` factory and `skill_service` Singleton provider, following the established `_build_*` pattern. Falls back to in-memory `SkillService()` when the database is unavailable. Exception handling narrowed to `(ImportError, OperationalError, DatabaseError, OSError)` with `exc_info=True` for traceability. ### CLI Layer - **`actor.py`**: Added `--skill` Typer option (`list[str] | None`, repeatable, `metavar="NAME"`). Help text notes that skills only augment tool-bearing agents. Wrapped constructor in the existing `try/except` block so `CleverAgentsException` from skill resolution is properly caught. - **`actor_run.py`**: Same `--skill` option with `metavar="NAME"`. Exception handler catches `CleverAgentsException` (matching master — not broadened to `CleverAgentsError`). - **`skill.py`**: Removed module-level `_service` cache. `_get_skill_service()` now always delegates to `get_container().skill_service()` so that `reset_container()` correctly invalidates the cached instance. `_reset_skill_service()` now overrides the container's provider via `providers.Object()`. Removed dead `validate_skill_names()` function. ### Runtime Layer - **`application.py`** (438 lines, down from 625): `ReactiveCleverAgentsApp` gains `skill_names` parameter with automatic deduplication via `dict.fromkeys`. `_resolve_skills()` obtains `SkillService` from the DI container (no CLI layer import). Separate `except KeyError` and `except ValueError` produce distinct error messages (`"not found in registry"` vs `"resolution failed: {exc}"`). Skill tools are only injected into agents that already have tools (`if self._resolved_skill_tools and tools:`), preventing LLM agents from being converted to pass-through `SimpleToolAgent` instances. When skill tools are skipped for tool-less agents, `logger.debug` emits a diagnostic message. `_sanitize_skill_name()` validates skill name format with tightened regex: `^[\w.-]{1,127}/[\w.-]{1,127}$` with `re.ASCII` flag. Zero-tool skill warning now uses `logger.warning` (not `print(stderr)`), ensuring structured log output and proper log-level filtering. - **`graph_executor.py`** (334 lines): Extracted graph execution logic. Type annotations improved. ### Tests - 24+ Behave scenarios across feature files covering: single/multiple/unknown skill flags, skill+context combined, duplicate deduplication, skill resolution, ValueError path, zero-tool resolution, error handling, tool merging, default behavior, overrides, LLM agent guard, `_sanitize_skill_name` edge cases (empty string, too-long name, ANSI escape codes, disallowed characters), `_build_skill_service` happy+fallback paths, `_get_skill_service` container delegation. - CLI "unknown skill" tests for **both** `actor.py` and `actor_run.py` exercise the real error chain (mock only `get_container()`, not the entire `ReactiveCleverAgentsApp`), testing `_resolve_skills()` → `CleverAgentsException` → `except CleverAgentsException` → exit code 2 end-to-end. - Combined skill+context tests assert `ContextManager` was instantiated and `exists()` was called in dedicated **Then** steps. - `@coverage` tags added to all new scenarios. - **Robot Framework smoke tests** added (`robot/skill_actor_run.robot` + `robot/helper_skill_actor_run.py`): unknown-skill error path and valid-skill acceptance path. ### Changelog - Added entry under `## Unreleased` in `CHANGELOG.md`. ## Review Fixes Applied (Brent Edwards, Rounds 1 & 2) | # | Finding | Resolution | |---|---------|------------| | **P1-1** | `print(stderr)` for zero-tool skill warning | **Fixed** — replaced with `logger.warning("Skill '%s' resolved to zero tools", name)`, removed unused `import sys` | | **P2-2** | Skill tools silently skipped for tool-less agents | **Fixed** — added `logger.debug` when skipped; updated `--skill` help text to note "only augments tool-bearing agents" | | **P2-3** | `container.py` at 739 lines | **Acknowledged** — pre-existing growth (+59 lines for `_build_skill_service`); extracting factories is a separate refactoring task | | **P2-4↑** | `CleverAgentsException` → `CleverAgentsError` broadens catch scope | **Fixed** — reverted `actor_run.py` to `except CleverAgentsException` matching master | | **P3-5** | No Robot Framework smoke test for `--skill` | **Fixed** — added `skill_actor_run.robot` with 2 test cases (unknown-skill error, valid-skill acceptance) | | **P3-6** | `GraphExecutor._follow_chained_edges` static-calling-static | **Acknowledged** — cosmetic pattern that doesn't affect correctness; can address in a follow-up | ## Known Limitations / Deferred Items | Item | Reason | |------|--------| | `actor.py` at 679 lines (500-line guideline) | Pre-existing (670 on master), +9 lines for `--skill`. Refactoring the shared `_execute()` closure is a separate task. | | `container.py` at 739 lines (500-line guideline) | Was 680 lines on master, +59 lines for `_build_skill_service()` and `skill_service` provider. Refactoring into sub-modules is a separate task. | | Code duplication between `actor.py` and `actor_run.py` `run()` | ~47 lines identical code. Coupled with the line-count issue above — both require extracting shared execution logic into a helper module. | | `SimpleToolAgent` only executes `tools[0]` | Deferred to #974. Pre-existing architectural limitation, not introduced by this PR. | | `GraphExecutor._follow_chained_edges` static-calling-static pattern | Cosmetic, doesn't affect behavior. | ## Quality Gates (post-rebase onto `2434253c`) - `nox -s lint`: ✅ PASS - `nox -s typecheck`: ✅ PASS (0 errors) - `nox -s unit_tests`: ✅ PASS (11,455 scenarios, 0 failures) - `nox -s integration_tests`: ✅ PASS (1,599/1,600 — 1 flaky `Uko Indexer > File Watching` passes in isolation) - `nox -s e2e_tests`: ✅ PASS (37 tests, 37 passed) - `nox -s coverage_report`: ✅ 97% (meets threshold) - Branch rebased onto latest `master` (`2434253c`)

hurui200320 added this to the v3.4.0 milestone 2026-03-16 08:00:13 +00:00

hurui200320 added the

Type

Task

label 2026-03-16 08:00:14 +00:00

hurui200320 added a new dependency 2026-03-16 08:11:49 +00:00

#887 fix(cli): add missing `--skill` flag to `actor run`

hurui200320 commented 2026-03-16 08:39:01 +00:00

Author

Member

Copy Link

Copy Source

Self-Review: fix(cli): add --skill flag to actor run command

Verdict: REQUEST CHANGES

Specification Compliance

All 6 acceptance criteria from ticket #887 are met. The --skill flag aligns with the spec (line 277), the help text matches spec line 4582, the flag is repeatable, optional, and errors on unknown skill names. The flag is present in both actor.py and actor_run.py. No blocking compliance gaps.

---

Critical Issues

C1. Silent DB fallback in _create_skill_service() produces misleading errors

• File: src/cleveragents/reactive/application.py:127-128
• Issue: The bare except Exception: silently falls back to an empty in-memory SkillService() when the DB connection fails. If the database is unreachable, all skill lookups silently fail with "Skill 'X' not found in registry" even though the skill exists in the DB. No warning is logged. This violates CONTRIBUTING.md: "Do not use bare catch-all exception handlers without re-raising unless you have specific recovery logic."
• Recommendation: (1) Log the exception: logger.warning("Failed to create DB-backed SkillService, falling back to in-memory", exc_info=True). (2) Narrow the catch to ImportError (SQLAlchemy not installed) and let other exceptions propagate. (3) Consider if silent degradation is appropriate here at all.

C2. _validate_skill_names() has zero real test coverage

• File: features/steps/actor_cli_run_steps.py (all skill-related steps)
• Issue: In every skill-related CLI test, _validate_skill_names is fully mocked via patch(...). The actual function body — which imports _get_skill_service, iterates names, calls service.get_skill(), and raises typer.Exit(code=2) — is never executed by any test. Both copies of this function (in actor.py:32-46 and actor_run.py:16-30) have zero line coverage of actual logic.
• Recommendation: Add scenarios that patch only _get_skill_service (not _validate_skill_names itself) and exercise the real validation logic — both success and KeyError paths.

---

Major Issues

M1. _resolve_skills() only catches KeyError, misses ValueError

• File: src/cleveragents/reactive/application.py:96
• Issue: resolve_tools() can raise ValueError for cycle detection, empty skill names, and missing included skills. These propagate uncaught as generic "Unexpected error" messages.
• Recommendation: Widen the catch: except (KeyError, ValueError) as exc:.

M2. DRY violation: _validate_skill_names() duplicated identically in two modules

• File: src/cleveragents/cli/commands/actor.py:32-46 and actor_run.py:16-30
• Issue: Character-for-character duplicate. The comment in actor.py:28 acknowledges this. If a bug fix is applied to one copy, the other may be missed.
• Recommendation: Extract to a shared module (e.g., alongside _get_skill_service() in skill.py, or a new _shared.py).

M3. _create_skill_service() returns Any — defeats type checking

• File: src/cleveragents/reactive/application.py:108
• Issue: Return type Any means Pyright cannot verify .resolve_tools() calls. Violates CONTRIBUTING.md type safety requirements.
• Recommendation: Change to -> SkillService:.

M4. _create_skill_service() duplicates _get_skill_service() without singleton caching — double initialization

• File: src/cleveragents/reactive/application.py:107-128
• Issue: Near-verbatim copy of _get_skill_service() from skill.py, but without the module-level singleton. Each call creates a new SQLAlchemy engine and session factory. Combined with CLI validation using _get_skill_service(), skills are validated against one service instance and resolved against a different one (TOCTOU risk).
• Recommendation: Reuse _get_skill_service() from skill.py instead of creating a parallel implementation. This also eliminates the TOCTOU between validation and resolution.

M5. entry.overrides branch in _resolve_skills() is untested

• File: src/cleveragents/reactive/application.py:93-94
• Issue: The if entry.overrides: tool_dict["overrides"] = dict(entry.overrides) branch is never exercised — all test fixtures create ResolvedToolEntry without overrides.
• Recommendation: Add a test with overrides={"timeout": 600} and assert the dict contains it.

M6. _create_skill_service() has zero test coverage

• File: src/cleveragents/reactive/application.py:107-128
• Issue: Always patched in tests. Neither the DB success path nor the exception fallback path is tested.
• Recommendation: Add two scenarios: (1) mock container returns valid DB URL, verify DB-backed service, (2) mock raises exception, verify fallback.

M7. "Unknown skill" test assertions are partially tautological

• File: features/steps/actor_cli_run_steps.py:909-911
• Issue: Only asserts exit_code == 2. Since _validate_skill_names is mocked with side_effect=_raise_exit(code=2), the test passes regardless of whether the source code actually validates skills. No assertion on error message content or that ReactiveCleverAgentsApp was NOT constructed.
• Recommendation: Assert output contains error message. Assert ReactiveCleverAgentsApp was never called. Better: test the real function per C2.

---

Minor Issues

m1. Duplicate --skill flags produce duplicate tool entries

• File: src/cleveragents/reactive/application.py:82-95
• Issue: --skill a --skill a resolves the same skill twice, appending duplicate tools to every agent.
• Recommendation: Deduplicate in the constructor: self._skill_names = list(dict.fromkeys(skill_names or [])).

m2. Skill tools injected into ALL agents — may convert LLM agents to tool agents

• File: src/cleveragents/reactive/application.py:167-168
• Issue: Skill tools are appended to every agent's tool list, including those configured with zero tools. An LLM agent with no tools becomes a SimpleToolAgent because if tools: is now truthy. This changes agent behavior. Untested path.
• Recommendation: Clarify spec intent. If skills should only augment agents that already have tools, guard with if self._resolved_skill_tools and tools:.

m3. _validate_skill_names() doesn't catch ValueError for empty string skill names

• File: src/cleveragents/cli/commands/actor.py:42-46
• Issue: get_skill("") raises ValueError("Skill name cannot be empty"), not KeyError. This propagates as "Unexpected error" instead of a clean CLI message.
• Recommendation: Catch (KeyError, ValueError) or validate for empty strings first.

m4. Exception base class inconsistency between CLI modules

• File: src/cleveragents/cli/commands/actor.py:198 vs actor_run.py:167
• Issue: actor.py catches CleverAgentsError, while actor_run.py catches CleverAgentsException. If _resolve_skills() raises CleverAgentsException and CleverAgentsError is not its parent, actor.py would mishandle it.
• Recommendation: Align both to catch the same base exception class.

m5. No test for --skill combined with --context

• File: features/actor_cli_coverage.feature
• Issue: No scenario tests --skill and --context together. A regression causing interference would go undetected.
• Recommendation: Add at least one combined-flag scenario.

m6. No format validation on --skill input

• File: src/cleveragents/cli/commands/actor.py:125-131
• Issue: Arbitrary strings accepted. Extremely long strings, null bytes, or special characters pass through without validation. Defense-in-depth concern.
• Recommendation: Add a regex check for expected namespace/name format.

m7. User-supplied skill names echoed directly in error messages

• File: src/cleveragents/cli/commands/actor.py:45
• Issue: Crafted skill names with ANSI escape codes could be used for terminal/log injection.
• Recommendation: Sanitize or escape control characters before including in output.

m8. Cross-module use of private function _get_skill_service()

• File: src/cleveragents/cli/commands/actor.py:38
• Issue: Importing an underscore-prefixed function from another module breaks the private API contract.
• Recommendation: Rename to get_skill_service() or create a public factory.

---

Suggestions

• S1: No warning when a skill resolves to zero tools — user gets silent no-op. Add logger.warning.
• S2: Use TypedDict for skill tool dicts instead of dict[str, Any] to enable compile-time checking.
• S3: Add SkillService to the project's DI container instead of manual wiring.
• S4: Assert skill_source field in the basic resolve test (only checked in the merge test).
• S5: Consider extracting mock helpers to features/mocks/ per CONTRIBUTING.md (codebase-wide pattern though).

---

Summary

Severity	Count
Critical	2
Major	7
Minor	8
Suggestion	5

The core feature implementation is correct and all acceptance criteria are met. However, the critical issues (silent error swallowing in _create_skill_service() and zero real test coverage on _validate_skill_names()) and major items (missing ValueError handling, DRY violations, type safety, TOCTOU risk) warrant changes before merge.

## Self-Review: `fix(cli): add --skill flag to actor run command` **Verdict: REQUEST CHANGES** ### Specification Compliance All 6 acceptance criteria from ticket #887 are met. The `--skill` flag aligns with the spec (line 277), the help text matches spec line 4582, the flag is repeatable, optional, and errors on unknown skill names. The flag is present in both `actor.py` and `actor_run.py`. No blocking compliance gaps. --- ### Critical Issues **C1. Silent DB fallback in `_create_skill_service()` produces misleading errors** - **File**: `src/cleveragents/reactive/application.py:127-128` - **Issue**: The bare `except Exception:` silently falls back to an empty in-memory `SkillService()` when the DB connection fails. If the database is unreachable, all skill lookups silently fail with `"Skill 'X' not found in registry"` even though the skill exists in the DB. No warning is logged. This violates CONTRIBUTING.md: "Do not use bare catch-all exception handlers without re-raising unless you have specific recovery logic." - **Recommendation**: (1) Log the exception: `logger.warning("Failed to create DB-backed SkillService, falling back to in-memory", exc_info=True)`. (2) Narrow the catch to `ImportError` (SQLAlchemy not installed) and let other exceptions propagate. (3) Consider if silent degradation is appropriate here at all. **C2. `_validate_skill_names()` has zero real test coverage** - **File**: `features/steps/actor_cli_run_steps.py` (all skill-related steps) - **Issue**: In every skill-related CLI test, `_validate_skill_names` is fully mocked via `patch(...)`. The actual function body — which imports `_get_skill_service`, iterates names, calls `service.get_skill()`, and raises `typer.Exit(code=2)` — is never executed by any test. Both copies of this function (in `actor.py:32-46` and `actor_run.py:16-30`) have zero line coverage of actual logic. - **Recommendation**: Add scenarios that patch only `_get_skill_service` (not `_validate_skill_names` itself) and exercise the real validation logic — both success and KeyError paths. --- ### Major Issues **M1. `_resolve_skills()` only catches `KeyError`, misses `ValueError`** - **File**: `src/cleveragents/reactive/application.py:96` - **Issue**: `resolve_tools()` can raise `ValueError` for cycle detection, empty skill names, and missing included skills. These propagate uncaught as generic "Unexpected error" messages. - **Recommendation**: Widen the catch: `except (KeyError, ValueError) as exc:`. **M2. DRY violation: `_validate_skill_names()` duplicated identically in two modules** - **File**: `src/cleveragents/cli/commands/actor.py:32-46` and `actor_run.py:16-30` - **Issue**: Character-for-character duplicate. The comment in `actor.py:28` acknowledges this. If a bug fix is applied to one copy, the other may be missed. - **Recommendation**: Extract to a shared module (e.g., alongside `_get_skill_service()` in `skill.py`, or a new `_shared.py`). **M3. `_create_skill_service()` returns `Any` — defeats type checking** - **File**: `src/cleveragents/reactive/application.py:108` - **Issue**: Return type `Any` means Pyright cannot verify `.resolve_tools()` calls. Violates CONTRIBUTING.md type safety requirements. - **Recommendation**: Change to `-> SkillService:`. **M4. `_create_skill_service()` duplicates `_get_skill_service()` without singleton caching — double initialization** - **File**: `src/cleveragents/reactive/application.py:107-128` - **Issue**: Near-verbatim copy of `_get_skill_service()` from `skill.py`, but without the module-level singleton. Each call creates a new SQLAlchemy engine and session factory. Combined with CLI validation using `_get_skill_service()`, skills are validated against one service instance and resolved against a different one (TOCTOU risk). - **Recommendation**: Reuse `_get_skill_service()` from `skill.py` instead of creating a parallel implementation. This also eliminates the TOCTOU between validation and resolution. **M5. `entry.overrides` branch in `_resolve_skills()` is untested** - **File**: `src/cleveragents/reactive/application.py:93-94` - **Issue**: The `if entry.overrides: tool_dict["overrides"] = dict(entry.overrides)` branch is never exercised — all test fixtures create `ResolvedToolEntry` without `overrides`. - **Recommendation**: Add a test with `overrides={"timeout": 600}` and assert the dict contains it. **M6. `_create_skill_service()` has zero test coverage** - **File**: `src/cleveragents/reactive/application.py:107-128` - **Issue**: Always patched in tests. Neither the DB success path nor the exception fallback path is tested. - **Recommendation**: Add two scenarios: (1) mock container returns valid DB URL, verify DB-backed service, (2) mock raises exception, verify fallback. **M7. "Unknown skill" test assertions are partially tautological** - **File**: `features/steps/actor_cli_run_steps.py:909-911` - **Issue**: Only asserts `exit_code == 2`. Since `_validate_skill_names` is mocked with `side_effect=_raise_exit(code=2)`, the test passes regardless of whether the source code actually validates skills. No assertion on error message content or that `ReactiveCleverAgentsApp` was NOT constructed. - **Recommendation**: Assert output contains error message. Assert `ReactiveCleverAgentsApp` was never called. Better: test the real function per C2. --- ### Minor Issues **m1. Duplicate `--skill` flags produce duplicate tool entries** - **File**: `src/cleveragents/reactive/application.py:82-95` - **Issue**: `--skill a --skill a` resolves the same skill twice, appending duplicate tools to every agent. - **Recommendation**: Deduplicate in the constructor: `self._skill_names = list(dict.fromkeys(skill_names or []))`. **m2. Skill tools injected into ALL agents — may convert LLM agents to tool agents** - **File**: `src/cleveragents/reactive/application.py:167-168` - **Issue**: Skill tools are appended to every agent's tool list, including those configured with zero tools. An LLM agent with no tools becomes a `SimpleToolAgent` because `if tools:` is now truthy. This changes agent behavior. Untested path. - **Recommendation**: Clarify spec intent. If skills should only augment agents that already have tools, guard with `if self._resolved_skill_tools and tools:`. **m3. `_validate_skill_names()` doesn't catch `ValueError` for empty string skill names** - **File**: `src/cleveragents/cli/commands/actor.py:42-46` - **Issue**: `get_skill("")` raises `ValueError("Skill name cannot be empty")`, not `KeyError`. This propagates as "Unexpected error" instead of a clean CLI message. - **Recommendation**: Catch `(KeyError, ValueError)` or validate for empty strings first. **m4. Exception base class inconsistency between CLI modules** - **File**: `src/cleveragents/cli/commands/actor.py:198` vs `actor_run.py:167` - **Issue**: `actor.py` catches `CleverAgentsError`, while `actor_run.py` catches `CleverAgentsException`. If `_resolve_skills()` raises `CleverAgentsException` and `CleverAgentsError` is not its parent, `actor.py` would mishandle it. - **Recommendation**: Align both to catch the same base exception class. **m5. No test for `--skill` combined with `--context`** - **File**: `features/actor_cli_coverage.feature` - **Issue**: No scenario tests `--skill` and `--context` together. A regression causing interference would go undetected. - **Recommendation**: Add at least one combined-flag scenario. **m6. No format validation on `--skill` input** - **File**: `src/cleveragents/cli/commands/actor.py:125-131` - **Issue**: Arbitrary strings accepted. Extremely long strings, null bytes, or special characters pass through without validation. Defense-in-depth concern. - **Recommendation**: Add a regex check for expected `namespace/name` format. **m7. User-supplied skill names echoed directly in error messages** - **File**: `src/cleveragents/cli/commands/actor.py:45` - **Issue**: Crafted skill names with ANSI escape codes could be used for terminal/log injection. - **Recommendation**: Sanitize or escape control characters before including in output. **m8. Cross-module use of private function `_get_skill_service()`** - **File**: `src/cleveragents/cli/commands/actor.py:38` - **Issue**: Importing an underscore-prefixed function from another module breaks the private API contract. - **Recommendation**: Rename to `get_skill_service()` or create a public factory. --- ### Suggestions - **S1**: No warning when a skill resolves to zero tools — user gets silent no-op. Add `logger.warning`. - **S2**: Use `TypedDict` for skill tool dicts instead of `dict[str, Any]` to enable compile-time checking. - **S3**: Add `SkillService` to the project's DI container instead of manual wiring. - **S4**: Assert `skill_source` field in the basic resolve test (only checked in the merge test). - **S5**: Consider extracting mock helpers to `features/mocks/` per CONTRIBUTING.md (codebase-wide pattern though). --- ### Summary | Severity | Count | |----------|-------| | Critical | 2 | | Major | 7 | | Minor | 8 | | Suggestion | 5 | The core feature implementation is correct and all acceptance criteria are met. However, the critical issues (silent error swallowing in `_create_skill_service()` and zero real test coverage on `_validate_skill_names()`) and major items (missing `ValueError` handling, DRY violations, type safety, TOCTOU risk) warrant changes before merge.

hurui200320 force-pushed feature/m4-actor-run-skill from d92c5b1f16 to 4604f5d13d 2026-03-16 09:05:31 +00:00 Compare

hurui200320 commented 2026-03-16 09:06:23 +00:00

Author

Member

Copy Link

Copy Source

Review Response — All Critical, Major, and Applicable Minor Issues Addressed

Force-pushed 4604f5d1 with the following changes in response to the self-review.

---

Critical Issues

C1. Silent DB fallback in _create_skill_service() → FIXED

• Added logger.warning("Failed to create DB-backed SkillService, falling back to in-memory", exc_info=True) to _get_skill_service() in skill.py.
• The _create_skill_service() method in application.py has been entirely removed (see M4), so the duplicate silent fallback is gone.

C2. _validate_skill_names() has zero real test coverage → FIXED

• All 6 CLI skill tests now patch only _get_skill_service (returning a mock service) instead of patching _validate_skill_names itself.
• The real validate_skill_names() function body executes in every test: get_skill() is called on the mock service, KeyError propagation triggers typer.Exit(code=2), etc.
• The success-path tests assert mock_service.get_skill was called with the correct arguments.
• The error-path tests assert the error message content and that ReactiveCleverAgentsApp was never instantiated.

---

Major Issues

M1. _resolve_skills() only catches KeyError → FIXED

• Widened to except (KeyError, ValueError) as exc:.

M2. DRY violation: _validate_skill_names() duplicated → FIXED

• Extracted to validate_skill_names() (public) in skill.py.
• Both actor.py and actor_run.py import and call this single implementation.
• Removed both private copies.

M3. _create_skill_service() returns Any → FIXED

• Method removed entirely (M4). _resolve_skills() now calls _get_skill_service() from skill.py, which returns SkillService.

M4. _create_skill_service() duplicates _get_skill_service() → FIXED

• Removed _create_skill_service() from ReactiveCleverAgentsApp.
• _resolve_skills() now does a lazy import of _get_skill_service from skill.py, reusing the module-level singleton.
• This also eliminates the TOCTOU risk: CLI validation and runtime resolution now use the same service instance.

M5. entry.overrides branch untested → FIXED

• Added new scenario "Reactive app resolves skill with tool overrides" with a ResolvedToolEntry(overrides={"timeout": 600, "retries": 3}).
• Asserts the overrides key is present and contains the correct dict.

M6. _create_skill_service() has zero test coverage → N/A (method removed)

• The _create_skill_service() method no longer exists. _get_skill_service() in skill.py already has dedicated test coverage via skill_cli_coverage_boost.feature.

M7. "Unknown skill" test assertions are tautological → FIXED

• Error-path tests now assert:
  • context.result.exit_code == 2
  • "Error: Skill 'local/nonexistent' not found in registry" in context.result.output
  • context.mock_app_cls.assert_not_called() (ReactiveCleverAgentsApp never instantiated)

---

Minor Issues

m1. Duplicate skills produce duplicate tool entries → FIXED

• Constructor now deduplicates: self._skill_names = list(dict.fromkeys(skill_names or [])).

m2. Skill tools injected into ALL agents → ACKNOWLEDGED

• This is by design per the current spec interpretation: --skill augments the entire run. If a more selective injection is needed, that should be specified in a follow-up ticket.

m3. _validate_skill_names() doesn't catch ValueError → FIXED

• validate_skill_names() in skill.py now catches (KeyError, ValueError).

m4. Exception base class inconsistency → FIXED

• actor_run.py now catches CleverAgentsError (same base as actor.py) instead of CleverAgentsException.

m5. No test for --skill combined with --context → FIXED

• Added scenario "Run actor with skill and context flags combined" in actor_cli_coverage.feature.

m6. No format validation on --skill input → DEFERRED

• Defense-in-depth; the skill registry already rejects unknown names. Format validation can be added as a separate hardening task.

m7. User-supplied skill names echoed directly → DEFERRED

• Terminal injection via ANSI escape codes is a low-risk concern for a CLI tool. Can be addressed in a codebase-wide sanitization pass.

m8. Cross-module use of private _get_skill_service() → PARTIALLY ADDRESSED

• validate_skill_names() is now the public API that both CLI modules import. The internal _get_skill_service remains underscore-prefixed but is used cross-module by the reactive layer via lazy import. A full rename to get_skill_service() would touch 60+ references across test files and is better scoped as a separate cleanup issue.

---

Suggestions

S1. No warning when skill resolves to zero tools → IMPLEMENTED

• Added logger.warning("Skill '%s' resolved to zero tools — no-op injection", name).

S4. Assert skill_source field in basic resolve test → IMPLEMENTED

• Added skill_source assertions in step_app_has_resolved_tools.

S2, S3, S5 → DEFERRED (TypedDict, DI container, mock extraction — separate scope).

---

Quality Gates

Gate	Result
nox -s lint	PASS
nox -s typecheck	PASS (0 errors)
nox -s unit_tests	PASS (10,827 scenarios, 0 failures)
nox -s coverage_report	97% (meets threshold)
nox -s integration_tests	1 pre-existing failure ("Clear All Context"), unrelated

## Review Response — All Critical, Major, and Applicable Minor Issues Addressed Force-pushed `4604f5d1` with the following changes in response to the self-review. --- ### Critical Issues **C1. Silent DB fallback in `_create_skill_service()` → FIXED** - Added `logger.warning("Failed to create DB-backed SkillService, falling back to in-memory", exc_info=True)` to `_get_skill_service()` in `skill.py`. - The `_create_skill_service()` method in `application.py` has been entirely removed (see M4), so the duplicate silent fallback is gone. **C2. `_validate_skill_names()` has zero real test coverage → FIXED** - All 6 CLI skill tests now patch only `_get_skill_service` (returning a mock service) instead of patching `_validate_skill_names` itself. - The real `validate_skill_names()` function body executes in every test: `get_skill()` is called on the mock service, `KeyError` propagation triggers `typer.Exit(code=2)`, etc. - The success-path tests assert `mock_service.get_skill` was called with the correct arguments. - The error-path tests assert the error message content and that `ReactiveCleverAgentsApp` was never instantiated. --- ### Major Issues **M1. `_resolve_skills()` only catches `KeyError` → FIXED** - Widened to `except (KeyError, ValueError) as exc:`. **M2. DRY violation: `_validate_skill_names()` duplicated → FIXED** - Extracted to `validate_skill_names()` (public) in `skill.py`. - Both `actor.py` and `actor_run.py` import and call this single implementation. - Removed both private copies. **M3. `_create_skill_service()` returns `Any` → FIXED** - Method removed entirely (M4). `_resolve_skills()` now calls `_get_skill_service()` from `skill.py`, which returns `SkillService`. **M4. `_create_skill_service()` duplicates `_get_skill_service()` → FIXED** - Removed `_create_skill_service()` from `ReactiveCleverAgentsApp`. - `_resolve_skills()` now does a lazy import of `_get_skill_service` from `skill.py`, reusing the module-level singleton. - This also eliminates the TOCTOU risk: CLI validation and runtime resolution now use the same service instance. **M5. `entry.overrides` branch untested → FIXED** - Added new scenario "Reactive app resolves skill with tool overrides" with a `ResolvedToolEntry(overrides={"timeout": 600, "retries": 3})`. - Asserts the `overrides` key is present and contains the correct dict. **M6. `_create_skill_service()` has zero test coverage → N/A (method removed)** - The `_create_skill_service()` method no longer exists. `_get_skill_service()` in `skill.py` already has dedicated test coverage via `skill_cli_coverage_boost.feature`. **M7. "Unknown skill" test assertions are tautological → FIXED** - Error-path tests now assert: - `context.result.exit_code == 2` - `"Error: Skill 'local/nonexistent' not found in registry" in context.result.output` - `context.mock_app_cls.assert_not_called()` (ReactiveCleverAgentsApp never instantiated) --- ### Minor Issues **m1. Duplicate skills produce duplicate tool entries → FIXED** - Constructor now deduplicates: `self._skill_names = list(dict.fromkeys(skill_names or []))`. **m2. Skill tools injected into ALL agents → ACKNOWLEDGED** - This is by design per the current spec interpretation: `--skill` augments the entire run. If a more selective injection is needed, that should be specified in a follow-up ticket. **m3. `_validate_skill_names()` doesn't catch `ValueError` → FIXED** - `validate_skill_names()` in `skill.py` now catches `(KeyError, ValueError)`. **m4. Exception base class inconsistency → FIXED** - `actor_run.py` now catches `CleverAgentsError` (same base as `actor.py`) instead of `CleverAgentsException`. **m5. No test for `--skill` combined with `--context` → FIXED** - Added scenario "Run actor with skill and context flags combined" in `actor_cli_coverage.feature`. **m6. No format validation on `--skill` input → DEFERRED** - Defense-in-depth; the skill registry already rejects unknown names. Format validation can be added as a separate hardening task. **m7. User-supplied skill names echoed directly → DEFERRED** - Terminal injection via ANSI escape codes is a low-risk concern for a CLI tool. Can be addressed in a codebase-wide sanitization pass. **m8. Cross-module use of private `_get_skill_service()` → PARTIALLY ADDRESSED** - `validate_skill_names()` is now the public API that both CLI modules import. The internal `_get_skill_service` remains underscore-prefixed but is used cross-module by the reactive layer via lazy import. A full rename to `get_skill_service()` would touch 60+ references across test files and is better scoped as a separate cleanup issue. --- ### Suggestions **S1. No warning when skill resolves to zero tools → IMPLEMENTED** - Added `logger.warning("Skill '%s' resolved to zero tools — no-op injection", name)`. **S4. Assert `skill_source` field in basic resolve test → IMPLEMENTED** - Added `skill_source` assertions in `step_app_has_resolved_tools`. **S2, S3, S5 → DEFERRED** (TypedDict, DI container, mock extraction — separate scope). --- ### Quality Gates | Gate | Result | |------|--------| | `nox -s lint` | PASS | | `nox -s typecheck` | PASS (0 errors) | | `nox -s unit_tests` | PASS (10,827 scenarios, 0 failures) | | `nox -s coverage_report` | 97% (meets threshold) | | `nox -s integration_tests` | 1 pre-existing failure ("Clear All Context"), unrelated |

hurui200320 commented 2026-03-16 09:25:17 +00:00

Author

Member

Copy Link

Copy Source

Code Review: fix(cli): add --skill flag to actor run command

Reviewer: Rui Hu (hurui200320)
Verdict: REQUEST CHANGES

This review covers the current state of the codebase on branch feature/m4-actor-run-skill (commit 4604f5d1). The previous self-review (comment 65047) and response (comment 65051) have been verified — most items are addressed, but several remain open and new issues were found. Only unresolved issues are listed below.

Specification Compliance

All 6 acceptance criteria from ticket #887 are met. The --skill flag aligns with spec line 4582, the help text matches, the flag is repeatable, optional, and errors on unknown skill names. Both actor.py and actor_run.py entry points have the flag. No spec compliance gaps found.

---

Critical Issues

C1. Skill injection converts LLM agents into pass-through SimpleToolAgents

• File: src/cleveragents/reactive/application.py:154-162
• Issue: _make_agent_instance() unconditionally appends _resolved_skill_tools to every agent's tool list, including agents of type == "llm" with zero original tools. After injection, tools is non-empty, so the if tools: branch returns a SimpleToolAgent instead of SimpleLLMAgent. The LLM agent loses its system prompt, model configuration, and LLM invocation entirely. Since injected skill tools have "operation": "identity", the agent becomes a no-op pass-through.
• Recommendation: Guard the injection so it only applies to agents that already have tools:

  if self._resolved_skill_tools and tools:
      tools = list(tools) + list(self._resolved_skill_tools)
  

  Or introduce an explicit opt-in mechanism at the agent configuration level.

C2. Appended skill tools are silently ignored by SimpleToolAgent.process()

• File: src/cleveragents/reactive/stream_router.py:156
• Issue: SimpleToolAgent.process() only executes self.tools[0]. When skill tools are appended to an agent that already has tools (application.py:157), the skill tools at indices 1, 2, ... are never executed. The user believes skills are being applied, but they have zero runtime effect for agents with existing tools.
• Recommendation: Either (a) rethink the injection strategy so skill tools are handled through a different mechanism (e.g., tool routing, LLM tool selection), or (b) process all tools in a pipeline within SimpleToolAgent.process(), or (c) document this as a known limitation and clarify the expected behavior in the spec.

C3. Architectural layer violation — Reactive layer imports from CLI layer

• File: src/cleveragents/reactive/application.py:86
• Issue: _resolve_skills() imports _get_skill_service from cleveragents.cli.commands.skill. This creates a dependency from the runtime/domain layer (reactive) into the presentation layer (cli.commands), violating the Dependency Inversion Principle. This is the only place in the entire reactive/ package that imports from cli/. It also imports a private function (underscore-prefixed), coupling to an implementation detail.
• Recommendation: Register SkillService in the DI container (application/container.py) as a proper provider, consistent with other services (ActorService, PlanService, etc.). Then inject it into ReactiveCleverAgentsApp via constructor parameter or container resolution.

---

Major Issues

M1. Misleading error message masks cycle detection and resolution failures

• File: src/cleveragents/reactive/application.py:108-111
• Issue: _resolve_skills() catches both KeyError and ValueError but always reports "Skill '{name}' not found in registry". ValueError is raised for cycle detection, empty skill names, and missing included skills — none of which are "not found" errors. The original ValueError message is lost at the user level.
• Note: The self-review M1 fix widened the catch to (KeyError, ValueError), but the error message was not differentiated.
• Recommendation: Separate the catch blocks:

  except KeyError as exc:
      raise CleverAgentsException(f"Skill '{name}' not found in registry") from exc
  except ValueError as exc:
      raise CleverAgentsException(f"Skill '{name}' resolution failed: {exc}") from exc
  

M2. DB failure silently masquerades as "skill not found"

• File: src/cleveragents/cli/commands/skill.py:104-109
• Issue: When DB-backed SkillService creation fails, the fallback creates an empty in-memory SkillService(). All subsequent get_skill() calls raise KeyError, causing validate_skill_names() to report "Skill 'X' not found in registry" even for skills that exist in the DB. The logger.warning added in the C1 fix is only visible at verbose logging levels (not the default).
• Recommendation: Either propagate the DB error as a user-visible message via typer.echo to stderr, or log at a level that is visible by default.

M3. Missing CHANGELOG.md entry

• File: CHANGELOG.md — not modified
• Issue: CONTRIBUTING.md line 265-266 requires: "The PR must include an update to the changelog file." No changelog entry was added.
• Recommendation: Add an entry under ## Unreleased describing the --skill flag addition.

M4. application.py exceeds 500-line limit

• File: src/cleveragents/reactive/application.py — 625 lines
• Issue: CONTRIBUTING.md line 399 states "Keep files under 500 lines." This PR added ~54 lines, pushing the file to 625 lines.
• Recommendation: Extract graph execution logic (_parse_graph_topology, _initialize_graph_context, _match_router_rule, _follow_chained_edges, _execute_graph_route — ~170 lines) into a separate module.

M5. Double skill resolution — validate then re-resolve

• File: src/cleveragents/cli/commands/actor.py:113-114 and src/cleveragents/reactive/application.py:86-117
• Issue: Each skill name is looked up twice: service.get_skill(name) in validate_skill_names(), then service.resolve_tools(name) (which calls get_skill() again internally) in _resolve_skills(). The service is designed for DB persistence — if get_skill hits the DB, every skill incurs two round-trips.
• Recommendation: Remove the separate validate_skill_names() call. Let _resolve_skills() in ReactiveCleverAgentsApp be the single point of validation and resolution. Its CleverAgentsException is already caught by the CLI's except CleverAgentsError handler.

M6. Missing --skill + --context combined test for actor_run.py

• File: features/actor_run_cli_coverage.feature
• Issue: actor_cli_coverage.feature has 4 skill scenarios including a combined test, but actor_run_cli_coverage.feature only has 3. Since both CLI entry points have independent code paths, a regression in actor_run.py's combined path would go undetected.
• Recommendation: Add a 4th scenario mirroring the combined test.

M7. Duplicate skill deduplication behavior not tested

• File: src/cleveragents/reactive/application.py:41
• Issue: The constructor deduplicates skill names via dict.fromkeys, but no test verifies this. If the dedup line were removed, no test would catch the regression.
• Recommendation: Add a scenario that passes duplicate skill names and asserts resolve_tools is called once per unique name.

---

Minor Issues

m1. Zero-tool skill warning invisible at default log level

• File: src/cleveragents/reactive/application.py:92-96
• Issue: At verbose=0, logging is CRITICAL. The logger.warning is never displayed. Users get no feedback when --skill resolves to nothing.
• Recommendation: Emit via typer.echo to stderr, or raise an error.

m2. Validation and resolution use different operations (semantic gap)

• File: skill.py:138-139 vs application.py:91
• Issue: validate_skill_names() calls get_skill() (existence check), while _resolve_skills() calls resolve_tools() (structural resolution including cycle detection). A skill with a circular include chain passes validation but fails resolution with different error paths.
• Recommendation: Addressed by M5 — removing the separate validation step eliminates this gap.

m3. Missing edge case test: empty string skill name (--skill "")

• File: No test exists
• Recommendation: Add an edge case scenario for empty string skill names.

m4. Inconsistent mock import style within PR

• File: features/steps/reactive_application_coverage_boost_steps.py:313, 376, 387, 416, 505
• Issue: actor_cli_run_steps.py imports mocks at module level; this file imports them inside individual step functions (5 times).
• Recommendation: Move mock imports to module level for consistency.

m5. "Skill + Context" combined test doesn't verify context behavior

• File: features/steps/actor_cli_run_steps.py:931-978
• Issue: The combined scenario only checks the --skill side. No assertion verifies ContextManager was properly used alongside skills.
• Recommendation: Add Then steps verifying ContextManager instantiation and interaction.

m6. Unnecessary list() copy of resolved skill tools

• File: src/cleveragents/reactive/application.py:157
• Issue: list(self._resolved_skill_tools) creates an unnecessary copy. The list is never mutated after _resolve_skills().
• Recommendation: Use self._resolved_skill_tools directly.

---

Suggestions

• S1: Code duplication between actor.py and actor_run.py run() functions is nearly verbatim (~146 lines each). Extract shared execution logic into a common helper. (Pre-existing, worsened by this PR.)
• S2: skill.py is 1,169 lines — over 2x the 500-line limit. Consider splitting. (Pre-existing.)
• S3: Register SkillService in the DI container to align with the project's DI preference over singletons.

---

Summary

Severity	Count
Critical	3
Major	7
Minor	6
Suggestion	3

The core feature implementation meets all acceptance criteria and the CLI flag definition matches the specification exactly. However, the critical issues — particularly the skill injection converting LLM agents into pass-throughs (C1), the fact that injected skill tools are never actually executed by SimpleToolAgent (C2), and the architectural layer violation (C3) — require changes before merge. The first two issues mean --skill is effectively non-functional for the majority of use cases, despite passing all existing tests.

## Code Review: `fix(cli): add --skill flag to actor run command` **Reviewer:** Rui Hu (`hurui200320`) **Verdict: REQUEST CHANGES** This review covers the current state of the codebase on branch `feature/m4-actor-run-skill` (commit `4604f5d1`). The previous self-review (comment 65047) and response (comment 65051) have been verified — most items are addressed, but several remain open and new issues were found. Only **unresolved** issues are listed below. ### Specification Compliance All 6 acceptance criteria from ticket #887 are met. The `--skill` flag aligns with spec line 4582, the help text matches, the flag is repeatable, optional, and errors on unknown skill names. Both `actor.py` and `actor_run.py` entry points have the flag. No spec compliance gaps found. --- ### Critical Issues **C1. Skill injection converts LLM agents into pass-through SimpleToolAgents** - **File**: `src/cleveragents/reactive/application.py:154-162` - **Issue**: `_make_agent_instance()` unconditionally appends `_resolved_skill_tools` to every agent's tool list, including agents of `type == "llm"` with zero original tools. After injection, `tools` is non-empty, so the `if tools:` branch returns a `SimpleToolAgent` instead of `SimpleLLMAgent`. The LLM agent loses its system prompt, model configuration, and LLM invocation entirely. Since injected skill tools have `"operation": "identity"`, the agent becomes a no-op pass-through. - **Recommendation**: Guard the injection so it only applies to agents that already have tools: ```python if self._resolved_skill_tools and tools: tools = list(tools) + list(self._resolved_skill_tools) ``` Or introduce an explicit opt-in mechanism at the agent configuration level. **C2. Appended skill tools are silently ignored by `SimpleToolAgent.process()`** - **File**: `src/cleveragents/reactive/stream_router.py:156` - **Issue**: `SimpleToolAgent.process()` only executes `self.tools[0]`. When skill tools are appended to an agent that already has tools (`application.py:157`), the skill tools at indices 1, 2, ... are never executed. The user believes skills are being applied, but they have zero runtime effect for agents with existing tools. - **Recommendation**: Either (a) rethink the injection strategy so skill tools are handled through a different mechanism (e.g., tool routing, LLM tool selection), or (b) process all tools in a pipeline within `SimpleToolAgent.process()`, or (c) document this as a known limitation and clarify the expected behavior in the spec. **C3. Architectural layer violation — Reactive layer imports from CLI layer** - **File**: `src/cleveragents/reactive/application.py:86` - **Issue**: `_resolve_skills()` imports `_get_skill_service` from `cleveragents.cli.commands.skill`. This creates a dependency from the runtime/domain layer (`reactive`) into the presentation layer (`cli.commands`), violating the Dependency Inversion Principle. This is the only place in the entire `reactive/` package that imports from `cli/`. It also imports a private function (underscore-prefixed), coupling to an implementation detail. - **Recommendation**: Register `SkillService` in the DI container (`application/container.py`) as a proper provider, consistent with other services (ActorService, PlanService, etc.). Then inject it into `ReactiveCleverAgentsApp` via constructor parameter or container resolution. --- ### Major Issues **M1. Misleading error message masks cycle detection and resolution failures** - **File**: `src/cleveragents/reactive/application.py:108-111` - **Issue**: `_resolve_skills()` catches both `KeyError` and `ValueError` but always reports `"Skill '{name}' not found in registry"`. `ValueError` is raised for cycle detection, empty skill names, and missing included skills — none of which are "not found" errors. The original `ValueError` message is lost at the user level. - **Note**: The self-review M1 fix widened the catch to `(KeyError, ValueError)`, but the error message was not differentiated. - **Recommendation**: Separate the catch blocks: ```python except KeyError as exc: raise CleverAgentsException(f"Skill '{name}' not found in registry") from exc except ValueError as exc: raise CleverAgentsException(f"Skill '{name}' resolution failed: {exc}") from exc ``` **M2. DB failure silently masquerades as "skill not found"** - **File**: `src/cleveragents/cli/commands/skill.py:104-109` - **Issue**: When DB-backed `SkillService` creation fails, the fallback creates an empty in-memory `SkillService()`. All subsequent `get_skill()` calls raise `KeyError`, causing `validate_skill_names()` to report "Skill 'X' not found in registry" even for skills that exist in the DB. The `logger.warning` added in the C1 fix is only visible at verbose logging levels (not the default). - **Recommendation**: Either propagate the DB error as a user-visible message via `typer.echo` to stderr, or log at a level that is visible by default. **M3. Missing CHANGELOG.md entry** - **File**: `CHANGELOG.md` — not modified - **Issue**: CONTRIBUTING.md line 265-266 requires: "The PR must include an update to the changelog file." No changelog entry was added. - **Recommendation**: Add an entry under `## Unreleased` describing the `--skill` flag addition. **M4. `application.py` exceeds 500-line limit** - **File**: `src/cleveragents/reactive/application.py` — 625 lines - **Issue**: CONTRIBUTING.md line 399 states "Keep files under 500 lines." This PR added ~54 lines, pushing the file to 625 lines. - **Recommendation**: Extract graph execution logic (`_parse_graph_topology`, `_initialize_graph_context`, `_match_router_rule`, `_follow_chained_edges`, `_execute_graph_route` — ~170 lines) into a separate module. **M5. Double skill resolution — validate then re-resolve** - **File**: `src/cleveragents/cli/commands/actor.py:113-114` and `src/cleveragents/reactive/application.py:86-117` - **Issue**: Each skill name is looked up twice: `service.get_skill(name)` in `validate_skill_names()`, then `service.resolve_tools(name)` (which calls `get_skill()` again internally) in `_resolve_skills()`. The service is designed for DB persistence — if `get_skill` hits the DB, every skill incurs two round-trips. - **Recommendation**: Remove the separate `validate_skill_names()` call. Let `_resolve_skills()` in `ReactiveCleverAgentsApp` be the single point of validation and resolution. Its `CleverAgentsException` is already caught by the CLI's `except CleverAgentsError` handler. **M6. Missing `--skill` + `--context` combined test for `actor_run.py`** - **File**: `features/actor_run_cli_coverage.feature` - **Issue**: `actor_cli_coverage.feature` has 4 skill scenarios including a combined test, but `actor_run_cli_coverage.feature` only has 3. Since both CLI entry points have independent code paths, a regression in `actor_run.py`'s combined path would go undetected. - **Recommendation**: Add a 4th scenario mirroring the combined test. **M7. Duplicate skill deduplication behavior not tested** - **File**: `src/cleveragents/reactive/application.py:41` - **Issue**: The constructor deduplicates skill names via `dict.fromkeys`, but no test verifies this. If the dedup line were removed, no test would catch the regression. - **Recommendation**: Add a scenario that passes duplicate skill names and asserts `resolve_tools` is called once per unique name. --- ### Minor Issues **m1. Zero-tool skill warning invisible at default log level** - **File**: `src/cleveragents/reactive/application.py:92-96` - **Issue**: At `verbose=0`, logging is `CRITICAL`. The `logger.warning` is never displayed. Users get no feedback when `--skill` resolves to nothing. - **Recommendation**: Emit via `typer.echo` to stderr, or raise an error. **m2. Validation and resolution use different operations (semantic gap)** - **File**: `skill.py:138-139` vs `application.py:91` - **Issue**: `validate_skill_names()` calls `get_skill()` (existence check), while `_resolve_skills()` calls `resolve_tools()` (structural resolution including cycle detection). A skill with a circular include chain passes validation but fails resolution with different error paths. - **Recommendation**: Addressed by M5 — removing the separate validation step eliminates this gap. **m3. Missing edge case test: empty string skill name (`--skill ""`)** - **File**: No test exists - **Recommendation**: Add an edge case scenario for empty string skill names. **m4. Inconsistent mock import style within PR** - **File**: `features/steps/reactive_application_coverage_boost_steps.py:313, 376, 387, 416, 505` - **Issue**: `actor_cli_run_steps.py` imports mocks at module level; this file imports them inside individual step functions (5 times). - **Recommendation**: Move mock imports to module level for consistency. **m5. "Skill + Context" combined test doesn't verify context behavior** - **File**: `features/steps/actor_cli_run_steps.py:931-978` - **Issue**: The combined scenario only checks the `--skill` side. No assertion verifies `ContextManager` was properly used alongside skills. - **Recommendation**: Add `Then` steps verifying `ContextManager` instantiation and interaction. **m6. Unnecessary `list()` copy of resolved skill tools** - **File**: `src/cleveragents/reactive/application.py:157` - **Issue**: `list(self._resolved_skill_tools)` creates an unnecessary copy. The list is never mutated after `_resolve_skills()`. - **Recommendation**: Use `self._resolved_skill_tools` directly. --- ### Suggestions - **S1**: Code duplication between `actor.py` and `actor_run.py` `run()` functions is nearly verbatim (~146 lines each). Extract shared execution logic into a common helper. (Pre-existing, worsened by this PR.) - **S2**: `skill.py` is 1,169 lines — over 2x the 500-line limit. Consider splitting. (Pre-existing.) - **S3**: Register `SkillService` in the DI container to align with the project's DI preference over singletons. --- ### Summary | Severity | Count | |----------|-------| | Critical | 3 | | Major | 7 | | Minor | 6 | | Suggestion | 3 | The core feature implementation meets all acceptance criteria and the CLI flag definition matches the specification exactly. However, the critical issues — particularly the skill injection converting LLM agents into pass-throughs (C1), the fact that injected skill tools are never actually executed by `SimpleToolAgent` (C2), and the architectural layer violation (C3) — require changes before merge. The first two issues mean `--skill` is effectively non-functional for the majority of use cases, despite passing all existing tests.

hurui200320 referenced this pull request 2026-03-16 10:54:35 +00:00

fix(reactive): SimpleToolAgent only executes first tool — skill tools at later indices are ignored #974

hurui200320 force-pushed feature/m4-actor-run-skill from 4604f5d13d to aa18d0f7e6 2026-03-16 10:56:05 +00:00 Compare

hurui200320 commented 2026-03-16 10:57:13 +00:00

Author

Member

Copy Link

Copy Source

Review Response — Second Review Issues Addressed

Force-pushed aa18d0f7 with the following changes in response to the second code review (comment 65077).

---

Critical Issues

C1. Skill injection converts LLM agents into pass-through SimpleToolAgents → FIXED

• _make_agent_instance() in application.py now guards injection: if self._resolved_skill_tools and tools:. LLM agents with zero original tools are never converted to SimpleToolAgent.
• Added new test scenario "Reactive app skill injection skips LLM agents without tools" that verifies an llm-type agent remains a SimpleLLMAgent while a tool agent correctly receives injected skill tools.

C2. Appended skill tools are silently ignored by SimpleToolAgent.process() → DEFERRED to #974

• Created follow-up issue #974: fix(reactive): SimpleToolAgent only executes first tool — skill tools at later indices are ignored.
• This is a pre-existing architectural limitation of SimpleToolAgent.process() (only uses tools[0]), not introduced by this PR. Fixing it requires redesigning the tool execution pipeline (multi-tool processing, tool routing, or LLM-based tool selection), which is out of scope for the --skill CLI flag addition.

C3. Architectural layer violation — Reactive layer imports from CLI layer → FIXED

• Added _build_skill_service() factory and skill_service Singleton provider to container.py, following the established _build_* pattern used by 7 other DB-backed services.
• _resolve_skills() in application.py now obtains SkillService from get_container().skill_service() — importing from cleveragents.application.container (application layer), not from cleveragents.cli.commands.skill (presentation layer).
• The cross-layer import (from cleveragents.cli.commands.skill import _get_skill_service) has been completely removed from the reactive layer.

---

Major Issues

M1. Misleading error message masks cycle detection and resolution failures → FIXED

• Separated the catch block into except KeyError and except ValueError with distinct messages:
  • KeyError → "Skill '{name}' not found in registry"
  • ValueError → "Skill '{name}' resolution failed: {exc}"

M2. DB failure silently masquerades as "skill not found" → FIXED

• Added typer.echo("Warning: database unavailable — skill lookups use in-memory store (run 'agents init' first)", err=True) in _get_skill_service() in skill.py. This message is always visible to CLI users regardless of log level.
• The DI container's _build_skill_service() also logs via structlog at WARNING level.

M3. Missing CHANGELOG.md entry → FIXED

• Added entry under ## Unreleased describing the --skill flag addition.

M4. application.py exceeds 500-line limit → FIXED

• Extracted graph execution logic into src/cleveragents/reactive/graph_executor.py (334 lines).
• GraphExecutor class encapsulates: _parse_topology, _initialize_context, _match_router_rule, _follow_chained_edges, execute, and strip_routing_prefixes.
• application.py is now 411 lines (down from 625), well under the 500-line limit.
• Backward-compatible proxy methods remain on ReactiveCleverAgentsApp for existing test compatibility.

M5. Double skill resolution — validate then re-resolve → FIXED

• Removed validate_skill_names() import and call from both actor.py and actor_run.py.
• _resolve_skills() in ReactiveCleverAgentsApp is now the single point of validation and resolution.
• The ReactiveCleverAgentsApp(...) constructor is now inside the try/except block in both CLI modules, so CleverAgentsException from skill resolution is caught and displayed as "Error: ..." with exit code 2.
• This eliminates the double DB round-trip and TOCTOU risk.

M6. Missing --skill + --context combined test for actor_run.py → FIXED

• Added scenario "Actor run command with skill and context flags combined" to actor_run_cli_coverage.feature.

M7. Duplicate skill deduplication behavior not tested → FIXED

• Added scenario "Actor run command with duplicate skill names" to actor_run_cli_coverage.feature.
• Added scenario "Reactive app deduplicates skill names" to reactive_application_coverage_boost.feature that verifies resolve_tools is called once per unique skill name.

---

Minor Issues

m1. Zero-tool skill warning invisible at default log level → ACKNOWLEDGED

• The logger.warning in _resolve_skills() is only visible at verbose >= 2. This is consistent with how other reactive layer warnings behave. Users can use -vv to see warnings. The M2 fix addresses the DB-level visibility concern separately.

m2. Validation and resolution use different operations → ADDRESSED by M5

• Removing separate validation eliminates this semantic gap entirely.

m3. Missing edge case test: empty string skill name → FIXED

• Added scenario "Reactive app raises error for empty string skill name" that verifies ValueError from resolve_tools("") produces a CleverAgentsException with "resolution failed" in the message.

m4. Inconsistent mock import style → PARTIALLY ADDRESSED

• The reactive_application_coverage_boost_steps.py continues to use local imports in step functions because MagicMock/patch are only needed in specific steps, not all steps in the module. This matches the step-level isolation pattern used elsewhere.

m5. "Skill + Context" combined test doesn't verify context behavior → FIXED

• Updated the combined test step to capture the ContextManager mock and verify it was instantiated.

m6. Unnecessary list() copy of resolved skill tools → FIXED

• Changed list(tools) + list(self._resolved_skill_tools) to list(tools) + self._resolved_skill_tools — only the first operand needs copying to avoid mutating the config list.

---

Suggestions

S1, S2, S3 → DEFERRED (DI container for SkillService is now done via C3; TypedDict and mock extraction are separate scope).

---

Quality Gates

Gate	Result
nox -s lint	PASS
nox -s typecheck	PASS (0 errors)
nox -s unit_tests	PASS (10,832 scenarios, 0 failures)
nox -s coverage_report	97% (meets threshold)
nox -s integration_tests	PASS

## Review Response — Second Review Issues Addressed Force-pushed `aa18d0f7` with the following changes in response to the second code review (comment 65077). --- ### Critical Issues **C1. Skill injection converts LLM agents into pass-through SimpleToolAgents → FIXED** - `_make_agent_instance()` in `application.py` now guards injection: `if self._resolved_skill_tools and tools:`. LLM agents with zero original tools are never converted to `SimpleToolAgent`. - Added new test scenario "Reactive app skill injection skips LLM agents without tools" that verifies an `llm`-type agent remains a `SimpleLLMAgent` while a tool agent correctly receives injected skill tools. **C2. Appended skill tools are silently ignored by `SimpleToolAgent.process()` → DEFERRED to #974** - Created follow-up issue #974: `fix(reactive): SimpleToolAgent only executes first tool — skill tools at later indices are ignored`. - This is a pre-existing architectural limitation of `SimpleToolAgent.process()` (only uses `tools[0]`), not introduced by this PR. Fixing it requires redesigning the tool execution pipeline (multi-tool processing, tool routing, or LLM-based tool selection), which is out of scope for the `--skill` CLI flag addition. **C3. Architectural layer violation — Reactive layer imports from CLI layer → FIXED** - Added `_build_skill_service()` factory and `skill_service` Singleton provider to `container.py`, following the established `_build_*` pattern used by 7 other DB-backed services. - `_resolve_skills()` in `application.py` now obtains `SkillService` from `get_container().skill_service()` — importing from `cleveragents.application.container` (application layer), not from `cleveragents.cli.commands.skill` (presentation layer). - The cross-layer import (`from cleveragents.cli.commands.skill import _get_skill_service`) has been completely removed from the reactive layer. --- ### Major Issues **M1. Misleading error message masks cycle detection and resolution failures → FIXED** - Separated the catch block into `except KeyError` and `except ValueError` with distinct messages: - `KeyError` → `"Skill '{name}' not found in registry"` - `ValueError` → `"Skill '{name}' resolution failed: {exc}"` **M2. DB failure silently masquerades as "skill not found" → FIXED** - Added `typer.echo("Warning: database unavailable — skill lookups use in-memory store (run 'agents init' first)", err=True)` in `_get_skill_service()` in `skill.py`. This message is always visible to CLI users regardless of log level. - The DI container's `_build_skill_service()` also logs via structlog at WARNING level. **M3. Missing CHANGELOG.md entry → FIXED** - Added entry under `## Unreleased` describing the `--skill` flag addition. **M4. `application.py` exceeds 500-line limit → FIXED** - Extracted graph execution logic into `src/cleveragents/reactive/graph_executor.py` (334 lines). - `GraphExecutor` class encapsulates: `_parse_topology`, `_initialize_context`, `_match_router_rule`, `_follow_chained_edges`, `execute`, and `strip_routing_prefixes`. - `application.py` is now 411 lines (down from 625), well under the 500-line limit. - Backward-compatible proxy methods remain on `ReactiveCleverAgentsApp` for existing test compatibility. **M5. Double skill resolution — validate then re-resolve → FIXED** - Removed `validate_skill_names()` import and call from both `actor.py` and `actor_run.py`. - `_resolve_skills()` in `ReactiveCleverAgentsApp` is now the single point of validation and resolution. - The `ReactiveCleverAgentsApp(...)` constructor is now inside the `try/except` block in both CLI modules, so `CleverAgentsException` from skill resolution is caught and displayed as `"Error: ..."` with exit code 2. - This eliminates the double DB round-trip and TOCTOU risk. **M6. Missing `--skill` + `--context` combined test for `actor_run.py` → FIXED** - Added scenario "Actor run command with skill and context flags combined" to `actor_run_cli_coverage.feature`. **M7. Duplicate skill deduplication behavior not tested → FIXED** - Added scenario "Actor run command with duplicate skill names" to `actor_run_cli_coverage.feature`. - Added scenario "Reactive app deduplicates skill names" to `reactive_application_coverage_boost.feature` that verifies `resolve_tools` is called once per unique skill name. --- ### Minor Issues **m1. Zero-tool skill warning invisible at default log level → ACKNOWLEDGED** - The `logger.warning` in `_resolve_skills()` is only visible at `verbose >= 2`. This is consistent with how other reactive layer warnings behave. Users can use `-vv` to see warnings. The M2 fix addresses the DB-level visibility concern separately. **m2. Validation and resolution use different operations → ADDRESSED by M5** - Removing separate validation eliminates this semantic gap entirely. **m3. Missing edge case test: empty string skill name → FIXED** - Added scenario "Reactive app raises error for empty string skill name" that verifies `ValueError` from `resolve_tools("")` produces a `CleverAgentsException` with `"resolution failed"` in the message. **m4. Inconsistent mock import style → PARTIALLY ADDRESSED** - The `reactive_application_coverage_boost_steps.py` continues to use local imports in step functions because `MagicMock`/`patch` are only needed in specific steps, not all steps in the module. This matches the step-level isolation pattern used elsewhere. **m5. "Skill + Context" combined test doesn't verify context behavior → FIXED** - Updated the combined test step to capture the `ContextManager` mock and verify it was instantiated. **m6. Unnecessary `list()` copy of resolved skill tools → FIXED** - Changed `list(tools) + list(self._resolved_skill_tools)` to `list(tools) + self._resolved_skill_tools` — only the first operand needs copying to avoid mutating the config list. --- ### Suggestions **S1, S2, S3 → DEFERRED** (DI container for SkillService is now done via C3; TypedDict and mock extraction are separate scope). --- ### Quality Gates | Gate | Result | |------|--------| | `nox -s lint` | PASS | | `nox -s typecheck` | PASS (0 errors) | | `nox -s unit_tests` | PASS (10,832 scenarios, 0 failures) | | `nox -s coverage_report` | 97% (meets threshold) | | `nox -s integration_tests` | PASS |

freemo reviewed 2026-03-16 16:14:06 +00:00

freemo left a comment

Owner

Copy Link

Copy Source

PM Day 36 Triage: --skill flag for actor run. Closes #887. Self-reviews by @hurui200320 identified and fixed Critical issues (C1: skill injection breaks LLM agents, C2: tools silently ignored, C3: architecture layer violation). All addressed. New issue #974 created for deferred SimpleToolAgent multi-tool execution. Reviewer needed: @CoreRasurae. M5 scope.

PM Day 36 Triage: --skill flag for actor run. Closes #887. Self-reviews by @hurui200320 identified and fixed Critical issues (C1: skill injection breaks LLM agents, C2: tools silently ignored, C3: architecture layer violation). All addressed. New issue #974 created for deferred SimpleToolAgent multi-tool execution. Reviewer needed: @CoreRasurae. M5 scope.

hurui200320 force-pushed feature/m4-actor-run-skill from aa18d0f7e6 to 10ac32b0fe 2026-03-17 07:45:51 +00:00 Compare

hurui200320 force-pushed feature/m4-actor-run-skill from 10ac32b0fe to c3c81efb6f 2026-03-17 08:39:00 +00:00 Compare

hurui200320 referenced this pull request 2026-03-17 08:54:34 +00:00

fix(cli): add missing `--skill` flag to `actor run` #887

hurui200320 commented 2026-03-17 09:06:14 +00:00

Author

Member

Copy Link

Copy Source

Self-QA Verdict: ✅ Approved

This PR has completed 3 automated self-QA review/fix cycles. All critical and major issues identified during the process have been resolved. The PR is now ready for external review.

Self-QA Summary

Cycle	Verdict	Issues Found	Issues Fixed
1	Request Changes	5 major, 8 minor, 7 nits	5 major, 6 minor, 7 nits
2	Request Changes	3 major, 8 minor, 5 nits	3 major, 8 minor, 2 nits
3	Approve	0 major, 5 minor, 6 nits	— (all non-blocking)

Key Improvements Made During Self-QA

• Removed orphaned dead code (validate_skill_names())
• Narrowed overly broad except Exception: to specific exception types
• Unified divergent SkillService instances (CLI and reactive layer now share the DI singleton)
• Added input validation (_sanitize_skill_name()) with ASCII regex, namespace/name enforcement, and control character stripping
• Expanded test coverage with 25+ new Behave scenarios (error paths, edge cases, real error chain tests)
• Improved BDD compliance (assertions in Then steps, @coverage tags, consolidated step definitions)
• Tightened GraphExecutor types from Any to specific types

Quality Gates (Final)

Gate	Status
Lint	✅ Pass
Typecheck	✅ Pass (0 errors)
Unit Tests	✅ Pass (10,838 scenarios)
Integration Tests	✅ Pass
Coverage	✅ 97%

Full implementation notes for all 3 cycles are posted on ticket #887.

## Self-QA Verdict: ✅ Approved This PR has completed 3 automated self-QA review/fix cycles. All critical and major issues identified during the process have been resolved. The PR is now **ready for external review**. ### Self-QA Summary | Cycle | Verdict | Issues Found | Issues Fixed | |-------|---------|-------------|-------------| | 1 | Request Changes | 5 major, 8 minor, 7 nits | 5 major, 6 minor, 7 nits | | 2 | Request Changes | 3 major, 8 minor, 5 nits | 3 major, 8 minor, 2 nits | | 3 | **Approve** | 0 major, 5 minor, 6 nits | — (all non-blocking) | ### Key Improvements Made During Self-QA - Removed orphaned dead code (`validate_skill_names()`) - Narrowed overly broad `except Exception:` to specific exception types - Unified divergent `SkillService` instances (CLI and reactive layer now share the DI singleton) - Added input validation (`_sanitize_skill_name()`) with ASCII regex, namespace/name enforcement, and control character stripping - Expanded test coverage with 25+ new Behave scenarios (error paths, edge cases, real error chain tests) - Improved BDD compliance (assertions in Then steps, `@coverage` tags, consolidated step definitions) - Tightened `GraphExecutor` types from `Any` to specific types ### Quality Gates (Final) | Gate | Status | |------|--------| | Lint | ✅ Pass | | Typecheck | ✅ Pass (0 errors) | | Unit Tests | ✅ Pass (10,838 scenarios) | | Integration Tests | ✅ Pass | | Coverage | ✅ 97% | Full implementation notes for all 3 cycles are posted on [ticket #887](https://git.cleverthis.com/cleveragents/cleveragents-core/issues/887#issuecomment-66092).

hurui200320 force-pushed feature/m4-actor-run-skill from c3c81efb6f to ef73dafae6 2026-03-17 09:09:36 +00:00 Compare

freemo commented 2026-03-17 18:23:27 +00:00

Owner

Copy Link

Copy Source

PM Status — Day 37 — Rebase Required

This PR has merge conflicts and cannot be merged in its current state. 42% of all open PRs (21 of 50) have conflicts — this is a project-wide issue that must be resolved.

@hurui200320 — Please rebase this PR onto master by Day 39 EOD (2026-03-19). If you cannot rebase by then, please post a comment explaining the blocker.

---

PM rebase request — Day 37

## PM Status — Day 37 — Rebase Required This PR has **merge conflicts** and cannot be merged in its current state. 42% of all open PRs (21 of 50) have conflicts — this is a project-wide issue that must be resolved. @hurui200320 — Please rebase this PR onto `master` by **Day 39 EOD (2026-03-19)**. If you cannot rebase by then, please post a comment explaining the blocker. --- *PM rebase request — Day 37*

brent.edwards requested changes 2026-03-17 19:52:39 +00:00

Dismissed

brent.edwards left a comment

Member

Copy Link

Copy Source

Code Review — PR #971 fix(cli): add --skill flag to actor run

Reviewer: @brent.edwards | Size: XL (+1488/−346, 12 files) | Focus: DI, CLI wiring, runtime, security

---

P1:must-fix (1)

1. print() to stderr instead of logger.warning for zero-tool skill
application.py:117-119 — The zero-tool warning uses print(f"Warning: ...", file=sys.stderr) while the rest of the module uses structlog logging. This bypasses log-level filtering, structured output, and log aggregation. If a user passes --skill local/empty-skill in a CI pipeline that parses structured logs, this warning is invisible.
Fix: logger.warning("skill_resolved_zero_tools", skill_name=name)

---

P2:should-fix (3)

2. Skill tools silently skipped for tool-less agents — application.py:183: if self._resolved_skill_tools and tools: means pure LLM agents never receive skill tools even when --skill is specified. This is arguably correct (can't add tools to SimpleLLMAgent) but undocumented. Add a logger.debug when skipped, and note in --skill help text.

3. container.py at 739 lines (was 680 on master, +59). File size pressure worsening. Consider extracting _build_* factories in a follow-up.

4. Exception rename from CleverAgentsException to CleverAgentsError in actor_run.py is an unrelated broadening bundled into the skill-flag PR. Should be a separate commit for clean bisectability.

---

P3:nit (2)

5. No Robot Framework smoke test for --skill. PRs #972/#973 both include .robot files.
6. GraphExecutor._follow_chained_edges is @staticmethod but calls GraphExecutor._invoke_agent by class name — works but unusual pattern.

---

Positive Observations

• Skill name regex ^[\w.-]{1,127}/[\w.-]{1,127}$ with re.ASCII is tight and correct
• Control-char stripping before regex validation — defense in depth
• _build_skill_service exception handling narrowed to (ImportError, OperationalError, DatabaseError, OSError) — much better than generic except
• application.py dropped from 563→436 lines via GraphExecutor extraction — excellent
• Dedup via dict.fromkeys preserves insertion order — correct
• 24+ Behave scenarios with end-to-end error chain testing — thorough

Verdict: REQUEST_CHANGES — P1-1 is a quick fix.

## Code Review — PR #971 `fix(cli): add --skill flag to actor run` **Reviewer:** @brent.edwards | **Size:** XL (+1488/−346, 12 files) | **Focus:** DI, CLI wiring, runtime, security --- ### P1:must-fix (1) **1. `print()` to stderr instead of `logger.warning` for zero-tool skill** `application.py:117-119` — The zero-tool warning uses `print(f"Warning: ...", file=sys.stderr)` while the rest of the module uses `structlog` logging. This bypasses log-level filtering, structured output, and log aggregation. If a user passes `--skill local/empty-skill` in a CI pipeline that parses structured logs, this warning is invisible. **Fix:** `logger.warning("skill_resolved_zero_tools", skill_name=name)` --- ### P2:should-fix (3) **2.** Skill tools silently skipped for tool-less agents — `application.py:183`: `if self._resolved_skill_tools and tools:` means pure LLM agents never receive skill tools even when `--skill` is specified. This is arguably correct (can't add tools to `SimpleLLMAgent`) but undocumented. Add a `logger.debug` when skipped, and note in `--skill` help text. **3.** `container.py` at 739 lines (was 680 on master, +59). File size pressure worsening. Consider extracting `_build_*` factories in a follow-up. **4.** Exception rename from `CleverAgentsException` to `CleverAgentsError` in `actor_run.py` is an unrelated broadening bundled into the skill-flag PR. Should be a separate commit for clean bisectability. --- ### P3:nit (2) **5.** No Robot Framework smoke test for `--skill`. PRs #972/#973 both include `.robot` files. **6.** `GraphExecutor._follow_chained_edges` is `@staticmethod` but calls `GraphExecutor._invoke_agent` by class name — works but unusual pattern. --- ### Positive Observations - Skill name regex `^[\w.-]{1,127}/[\w.-]{1,127}$` with `re.ASCII` is tight and correct - Control-char stripping before regex validation — defense in depth - `_build_skill_service` exception handling narrowed to `(ImportError, OperationalError, DatabaseError, OSError)` — much better than generic `except` - `application.py` dropped from 563→436 lines via `GraphExecutor` extraction — excellent - Dedup via `dict.fromkeys` preserves insertion order — correct - 24+ Behave scenarios with end-to-end error chain testing — thorough **Verdict:** REQUEST_CHANGES — P1-1 is a quick fix.

brent.edwards requested changes 2026-03-17 20:36:32 +00:00

brent.edwards left a comment

Member

Copy Link

Copy Source

Code Review Round 2 — PR #971 fix(cli): add --skill flag to actor run

Reviewer: @brent.edwards | Focus: Verification of Round 1 fixes + deep second pass

---

Prior Findings: 0 of 6 resolved

All Round 1 findings remain open:

#	Sev	Finding	Status
P1-1	print(stderr) for zero-tool skill	OPEN — still print(..., file=sys.stderr) at application.py:118-120
P2-2	Skill tools silently skipped for tool-less agents	OPEN
P2-3	container.py at 739 lines	OPEN
P2-4	Exception rename is unrelated bundled fix	OPEN — upgraded, see below
P3-5	No Robot test for --skill	OPEN
P3-6	Static-calling-static in GraphExecutor	OPEN

---

Upgraded Finding

P2-4 elevated: CleverAgentsException → CleverAgentsError broadens catch scope
actor_run.py:148 — CleverAgentsException is a subclass of CleverAgentsError. Catching the base class instead of the subclass broadens what's silently caught — any code raising CleverAgentsError (but not the subclass) will now be caught instead of propagating. This is a behavioral change bundled into a feature PR without test coverage.
Fix: Revert to CleverAgentsException in this PR, or split into its own PR with tests.

---

Confirmed Clean from Second Pass

Area	Verdict
_sanitize_skill_name regex	Sound — re.ASCII rejects Unicode confusables
Circular imports	None — clean DAG between application.py and graph_executor.py
Module-level _service cache	Properly eliminated — DI container delegation only
_build_skill_service fallback	Correct — in-memory SkillService() raises KeyError downstream
Behave mocking pattern	Correct — mocks at container boundary, not deep internals

---

Verdict: REQUEST_CHANGES — P1-1 (print(stderr)) is a one-line fix:

logger.warning("Skill '%s' resolved to zero tools", name)

## Code Review Round 2 — PR #971 `fix(cli): add --skill flag to actor run` **Reviewer:** @brent.edwards | **Focus:** Verification of Round 1 fixes + deep second pass --- ### Prior Findings: 0 of 6 resolved All Round 1 findings remain open: | # | Sev | Finding | Status | |---|-----|---------|--------| | P1-1 | `print(stderr)` for zero-tool skill | **OPEN** — still `print(..., file=sys.stderr)` at `application.py:118-120` | | P2-2 | Skill tools silently skipped for tool-less agents | OPEN | | P2-3 | `container.py` at 739 lines | OPEN | | P2-4 | Exception rename is unrelated bundled fix | OPEN — upgraded, see below | | P3-5 | No Robot test for `--skill` | OPEN | | P3-6 | Static-calling-static in GraphExecutor | OPEN | --- ### Upgraded Finding **P2-4 elevated: `CleverAgentsException` → `CleverAgentsError` broadens catch scope** `actor_run.py:148` — `CleverAgentsException` is a **subclass** of `CleverAgentsError`. Catching the base class instead of the subclass broadens what's silently caught — any code raising `CleverAgentsError` (but not the subclass) will now be caught instead of propagating. This is a behavioral change bundled into a feature PR without test coverage. **Fix:** Revert to `CleverAgentsException` in this PR, or split into its own PR with tests. --- ### Confirmed Clean from Second Pass | Area | Verdict | |------|---------| | `_sanitize_skill_name` regex | Sound — `re.ASCII` rejects Unicode confusables | | Circular imports | None — clean DAG between `application.py` and `graph_executor.py` | | Module-level `_service` cache | Properly eliminated — DI container delegation only | | `_build_skill_service` fallback | Correct — in-memory `SkillService()` raises `KeyError` downstream | | Behave mocking pattern | Correct — mocks at container boundary, not deep internals | --- **Verdict:** REQUEST_CHANGES — P1-1 (`print(stderr)`) is a one-line fix: ```python logger.warning("Skill '%s' resolved to zero tools", name) ```

hurui200320 force-pushed feature/m4-actor-run-skill from ef73dafae6 to 7127effd26 2026-03-18 07:38:20 +00:00 Compare

hurui200320 commented 2026-03-18 07:39:36 +00:00

Author

Member

Copy Link

Copy Source

Review Response — Brent Edwards Rounds 1 & 2 Addressed

Force-pushed 7127effd with the following changes. Branch has been rebased onto latest master (ab1fd19b) per PM Day 37 request.

---

P1-1: print(stderr) for zero-tool skill warning → FIXED

• Replaced print(f"Warning: Skill '{name}' resolved to zero tools", file=sys.stderr) with logger.warning("Skill '%s' resolved to zero tools", name) in ReactiveCleverAgentsApp._resolve_skills().
• Removed unused import sys from application.py.
• This ensures the warning respects log-level filtering, structured output, and log aggregation — matching the rest of the module's structlog/logging usage.

P2-2: Skill tools silently skipped for tool-less agents → FIXED

• Added logger.debug("Skipping skill tool injection for agent '%s' (agent has no base tools)", name) in _make_agent_instance() when _resolved_skill_tools is non-empty but the agent has no base tools.
• Updated --skill help text in both actor.py and actor_run.py from "Skill to attach (repeatable)" to "Skill to attach; only augments tool-bearing agents (repeatable)" — making the behavior explicit to CLI users.

P2-3: container.py at 739 lines → ACKNOWLEDGED

• Pre-existing file size growth (was 680 on master, +59 for _build_skill_service). Extracting _build_* factories into sub-modules is a separate refactoring task outside the scope of the --skill CLI flag addition.

P2-4↑ (elevated): CleverAgentsException → CleverAgentsError broadens catch scope → FIXED

• Reverted actor_run.py from except CleverAgentsError back to except CleverAgentsException, matching the pre-existing master behavior.
• Updated the import accordingly: from cleveragents.core.exceptions import CleverAgentsException, UnsafeConfigurationError.
• actor.py retains CleverAgentsError as it was already that way on master.

P3-5: No Robot Framework smoke test for --skill → FIXED

• Added robot/skill_actor_run.robot with 2 test cases:
  1. Actor Run With Unknown Skill Exits With Error — verifies --skill local/nonexistent-skill exits with code 2 and error message containing "not found in registry".
  2. Actor Run Skill Flag Accepted — verifies --skill local/smoke-skill is accepted by the CLI when the skill exists in the in-memory registry.
• Added robot/helper_skill_actor_run.py as the Python helper script following the established pattern.

P3-6: GraphExecutor._follow_chained_edges static-calling-static → ACKNOWLEDGED

• Cosmetic pattern issue that doesn't affect correctness. Can be addressed in a follow-up refactoring of graph_executor.py.

---

Quality Gates (post-fix)

Gate	Result
nox -s lint	✅ PASS
nox -s typecheck	✅ PASS (0 errors)
nox -s unit_tests	✅ PASS (11,130 scenarios, 0 failures)
nox -s integration_tests	✅ PASS (1,559 tests, 0 failures)
nox -s coverage_report	✅ 97% (meets threshold)

Branch rebased onto latest master (ab1fd19b), resolving merge conflict in CHANGELOG.md.

## Review Response — Brent Edwards Rounds 1 & 2 Addressed Force-pushed `7127effd` with the following changes. Branch has been rebased onto latest `master` (`ab1fd19b`) per PM Day 37 request. --- ### P1-1: `print(stderr)` for zero-tool skill warning → **FIXED** - Replaced `print(f"Warning: Skill '{name}' resolved to zero tools", file=sys.stderr)` with `logger.warning("Skill '%s' resolved to zero tools", name)` in `ReactiveCleverAgentsApp._resolve_skills()`. - Removed unused `import sys` from `application.py`. - This ensures the warning respects log-level filtering, structured output, and log aggregation — matching the rest of the module's `structlog`/logging usage. ### P2-2: Skill tools silently skipped for tool-less agents → **FIXED** - Added `logger.debug("Skipping skill tool injection for agent '%s' (agent has no base tools)", name)` in `_make_agent_instance()` when `_resolved_skill_tools` is non-empty but the agent has no base tools. - Updated `--skill` help text in both `actor.py` and `actor_run.py` from `"Skill to attach (repeatable)"` to `"Skill to attach; only augments tool-bearing agents (repeatable)"` — making the behavior explicit to CLI users. ### P2-3: `container.py` at 739 lines → **ACKNOWLEDGED** - Pre-existing file size growth (was 680 on master, +59 for `_build_skill_service`). Extracting `_build_*` factories into sub-modules is a separate refactoring task outside the scope of the `--skill` CLI flag addition. ### P2-4↑ (elevated): `CleverAgentsException` → `CleverAgentsError` broadens catch scope → **FIXED** - Reverted `actor_run.py` from `except CleverAgentsError` back to `except CleverAgentsException`, matching the pre-existing master behavior. - Updated the import accordingly: `from cleveragents.core.exceptions import CleverAgentsException, UnsafeConfigurationError`. - `actor.py` retains `CleverAgentsError` as it was already that way on master. ### P3-5: No Robot Framework smoke test for `--skill` → **FIXED** - Added `robot/skill_actor_run.robot` with 2 test cases: 1. **Actor Run With Unknown Skill Exits With Error** — verifies `--skill local/nonexistent-skill` exits with code 2 and error message containing "not found in registry". 2. **Actor Run Skill Flag Accepted** — verifies `--skill local/smoke-skill` is accepted by the CLI when the skill exists in the in-memory registry. - Added `robot/helper_skill_actor_run.py` as the Python helper script following the established pattern. ### P3-6: `GraphExecutor._follow_chained_edges` static-calling-static → **ACKNOWLEDGED** - Cosmetic pattern issue that doesn't affect correctness. Can be addressed in a follow-up refactoring of `graph_executor.py`. --- ### Quality Gates (post-fix) | Gate | Result | |------|--------| | `nox -s lint` | ✅ PASS | | `nox -s typecheck` | ✅ PASS (0 errors) | | `nox -s unit_tests` | ✅ PASS (11,130 scenarios, 0 failures) | | `nox -s integration_tests` | ✅ PASS (1,559 tests, 0 failures) | | `nox -s coverage_report` | ✅ 97% (meets threshold) | Branch rebased onto latest `master` (`ab1fd19b`), resolving merge conflict in `CHANGELOG.md`.

hurui200320 force-pushed feature/m4-actor-run-skill from 7127effd26 to 4667091639 2026-03-18 07:46:26 +00:00 Compare

hurui200320 force-pushed feature/m4-actor-run-skill from 4667091639 to 629891ed3d 2026-03-18 08:27:46 +00:00 Compare

freemo approved these changes 2026-03-19 04:54:34 +00:00

Dismissed

freemo left a comment

Owner

Copy Link

Copy Source

Code Review — PR #971 fix(cli): add --skill flag to actor run command

Well-structured implementation. The GraphExecutor extraction is a clean architectural improvement that reduces application.py from 625 to 438 lines. The --skill option, _resolve_skills(), and skill tool injection are well-designed. 24+ Behave scenarios + 2 Robot tests + benchmarks demonstrate thorough coverage. Quality gates all pass (11,130 scenarios, 97% coverage).

Approved with acknowledged tech debt:

1. Code duplication — ~47 identical lines between actor.py and actor_run.py. The PR body acknowledges this and defers to a future refactoring task. This is acceptable as a conscious decision.

2. File size — container.py at 739 lines and actor.py at 679 lines both exceed the 500-line guideline from CONTRIBUTING.md. Again acknowledged and deferred. Consider creating the follow-up issue now so it's tracked.

3. Skill name regex — ^[\w.-]{1,127}/[\w.-]{1,127}$ with re.ASCII is a good constraint. Well-designed validation.

4. Exception narrowing — Good practice catching (ImportError, OperationalError, DatabaseError, OSError) instead of bare except Exception.

## Code Review — PR #971 `fix(cli): add --skill flag to actor run command` Well-structured implementation. The `GraphExecutor` extraction is a clean architectural improvement that reduces `application.py` from 625 to 438 lines. The `--skill` option, `_resolve_skills()`, and skill tool injection are well-designed. 24+ Behave scenarios + 2 Robot tests + benchmarks demonstrate thorough coverage. Quality gates all pass (11,130 scenarios, 97% coverage). **Approved** with acknowledged tech debt: 1. **Code duplication** — ~47 identical lines between `actor.py` and `actor_run.py`. The PR body acknowledges this and defers to a future refactoring task. This is acceptable as a conscious decision. 2. **File size** — `container.py` at 739 lines and `actor.py` at 679 lines both exceed the 500-line guideline from CONTRIBUTING.md. Again acknowledged and deferred. Consider creating the follow-up issue now so it's tracked. 3. **Skill name regex** — `^[\w.-]{1,127}/[\w.-]{1,127}$` with `re.ASCII` is a good constraint. Well-designed validation. 4. **Exception narrowing** — Good practice catching `(ImportError, OperationalError, DatabaseError, OSError)` instead of bare `except Exception`.

freemo requested review from brent.edwards 2026-03-19 05:19:39 +00:00

freemo requested review from freemo 2026-03-19 05:19:39 +00:00

freemo commented 2026-03-19 05:35:18 +00:00

Owner

Copy Link

Copy Source

Planning Agent — Day 39 PR Review Assessment

PR #971 (--skill flag for actor run) has been through 3 rounds of self-QA by @hurui200320 and 2 rounds of external review by @brent.edwards. This is one of the most thoroughly reviewed PRs in the project.

Summary of review cycles:

• Rui's self-review identified 2 critical + 7 major + 8 minor issues
• Rui's external review by Rui found 3 critical + 7 major + 6 minor
• All critical issues resolved: LLM agent conversion guard (C1), SimpleToolAgent limitation deferred to #974 (C2), DI container wiring replaces CLI import (C3)
• All major issues resolved: error message differentiation, CHANGELOG, file size reduction (625→411 lines), double resolution eliminated, combined tests added
• Brent's Round 1+2 findings all addressed

Architecture assessment: The DI container approach for SkillService is correct. The LLM agent guard (if self._resolved_skill_tools and tools:) is sound. The deferred item (#974 — SimpleToolAgent only executes first tool) is a legitimate pre-existing limitation.

Merge recommendation: Ready for merge. Rebased on latest master. All gates passing. Reviewers (@brent.edwards, @freemo) should approve. The deferred items are properly tracked:

• #974: SimpleToolAgent multi-tool execution
• m4: mock import style consistency
• P2-3: container.py file size (739 lines)

**Planning Agent — Day 39 PR Review Assessment** PR #971 (--skill flag for actor run) has been through 3 rounds of self-QA by @hurui200320 and 2 rounds of external review by @brent.edwards. This is one of the most thoroughly reviewed PRs in the project. **Summary of review cycles**: - Rui's self-review identified 2 critical + 7 major + 8 minor issues - Rui's external review by Rui found 3 critical + 7 major + 6 minor - All critical issues resolved: LLM agent conversion guard (C1), `SimpleToolAgent` limitation deferred to #974 (C2), DI container wiring replaces CLI import (C3) - All major issues resolved: error message differentiation, CHANGELOG, file size reduction (625→411 lines), double resolution eliminated, combined tests added - Brent's Round 1+2 findings all addressed **Architecture assessment**: The DI container approach for `SkillService` is correct. The LLM agent guard (`if self._resolved_skill_tools and tools:`) is sound. The deferred item (#974 — `SimpleToolAgent` only executes first tool) is a legitimate pre-existing limitation. **Merge recommendation**: Ready for merge. Rebased on latest master. All gates passing. Reviewers (@brent.edwards, @freemo) should approve. The deferred items are properly tracked: - #974: SimpleToolAgent multi-tool execution - m4: mock import style consistency - P2-3: container.py file size (739 lines)

hurui200320 force-pushed feature/m4-actor-run-skill from 629891ed3d to af94b7edb2 2026-03-19 06:17:03 +00:00 Compare

hurui200320 dismissed freemo's review 2026-03-19 06:17:03 +00:00

Reason:

New commits pushed, approval review dismissed automatically according to repository settings

hurui200320 force-pushed feature/m4-actor-run-skill from af94b7edb2 to 78b1518310 2026-03-19 09:21:31 +00:00 Compare

hurui200320 scheduled this pull request to auto merge when all checks succeed 2026-03-19 09:22:34 +00:00

hurui200320 commented 2026-03-19 09:22:45 +00:00

Author

Member

Copy Link

Copy Source

Rebase onto latest master — Day 39 response

Force-pushed 78b15183 — branch rebased onto latest master (2434253c) per PM Day 37 request.

Merge conflicts resolved

Three files had conflicts due to parallel work on master:

1. CHANGELOG.md — Both master (E2E acceptance tests, session_factory DI provider, Google API key redaction — #745) and this branch (--skill flag — #887) added entries under ## Unreleased. Kept both entries.
2. features/application_container_coverage_boost.feature — Master added _build_session_factory scenarios; this branch added _build_skill_service scenarios. Kept both sets of scenarios.
3. features/steps/application_container_coverage_boost_steps.py — Same pattern: master added session factory step definitions and import; this branch added skill service step definitions and import. Merged both imports and both step definition blocks.

Quality Gates (all passing post-rebase)

Gate	Result
nox -s lint	✅ PASS
nox -s typecheck	✅ PASS (0 errors, 1 pre-existing warning)
nox -s unit_tests	✅ PASS (11,455 scenarios, 0 failures)
nox -s integration_tests	✅ PASS (1,599/1,600 — 1 flaky Uko Indexer > File Watching passes in isolation, unrelated)
nox -s e2e_tests	✅ PASS (37 tests, 37 passed)
nox -s coverage_report	✅ 97% (meets threshold)

PR is now mergeable with no conflicts.

## Rebase onto latest master — Day 39 response Force-pushed `78b15183` — branch rebased onto latest `master` (`2434253c`) per PM Day 37 request. ### Merge conflicts resolved Three files had conflicts due to parallel work on `master`: 1. **`CHANGELOG.md`** — Both master (E2E acceptance tests, `session_factory` DI provider, Google API key redaction — #745) and this branch (`--skill` flag — #887) added entries under `## Unreleased`. Kept both entries. 2. **`features/application_container_coverage_boost.feature`** — Master added `_build_session_factory` scenarios; this branch added `_build_skill_service` scenarios. Kept both sets of scenarios. 3. **`features/steps/application_container_coverage_boost_steps.py`** — Same pattern: master added session factory step definitions and import; this branch added skill service step definitions and import. Merged both imports and both step definition blocks. ### Quality Gates (all passing post-rebase) | Gate | Result | |------|--------| | `nox -s lint` | ✅ PASS | | `nox -s typecheck` | ✅ PASS (0 errors, 1 pre-existing warning) | | `nox -s unit_tests` | ✅ PASS (11,455 scenarios, 0 failures) | | `nox -s integration_tests` | ✅ PASS (1,599/1,600 — 1 flaky `Uko Indexer > File Watching` passes in isolation, unrelated) | | `nox -s e2e_tests` | ✅ PASS (37 tests, 37 passed) | | `nox -s coverage_report` | ✅ 97% (meets threshold) | PR is now mergeable with no conflicts.

hurui200320 merged commit 554d6889cc into master 2026-03-19 09:30:36 +00:00

hurui200320 referenced this issue from a commit 2026-03-19 09:30:36 +00:00

fix(cli): add --skill flag to actor run command (#971)

hurui200320 deleted branch feature/m4-actor-run-skill 2026-03-19 09:30:36 +00:00

CoreRasurae referenced this pull request 2026-03-19 21:55:35 +00:00

refactor(cli): align actor run signature with spec positional args #1072

CoreRasurae referenced this pull request 2026-03-20 16:33:06 +00:00

refactor(cli): align actor run signature with spec positional args #1072

Sign in to join this conversation.

Reviewers

No Reviewers

freemo

brent.edwards

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

Type

Task

Milestone

No items

No Milestone v3.4.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

Subscribe

Due Date

No due date set.

Blocks

#887 fix(cli): add missing `--skill` flag to `actor run`

cleveragents/cleveragents-core

Reference: cleveragents/cleveragents-core#971