.forgejo/workflows/master.yml

@@ -3,8 +3,6 @@ name: CI
 on:
     push:
         branches: [master, develop]
-    pull_request:
-        branches: [master, develop]
 
 vars:
     docker_prefix: "http://harbor.cleverthis.com/docker/"

CHANGELOG.md

@@ -5,77 +5,9 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
-- Fixed `ReactiveEventBus.emit()` exception handler to log the full exception
-  message (`str(exc)`) and enable traceback forwarding (`exc_info=True`).
-  Previously the handler logged only the exception type name (e.g.
-  "ValueError") with no diagnostic detail, making production debugging
-  impossible. The handler now includes the error message text and full
-  traceback in the structlog warning entry. Removed `@tdd_expected_fail` tag
-  from the TDD test so both scenarios run as normal regression guards. (#988)
-
 ### Fixed
-- **Actor CLI NAME argument made optional, derived from YAML config** (#4186): The
-  `agents actor add` positional ``NAME`` argument is now optional (defaults to
-  ``None``). When omitted, the actor name is derived from the ``name`` field in
-  the config file. Raises ``BadParameter`` if neither the argument nor the config
-  ``name`` field is provided. Updated docstring signature to
-  ``agents actor add [--config|-c <FILE>] [<NAME>]`` and added config-only usage
-  examples. Added Behave scenario for the ``BadParameter`` error path
-  (``actor add without NAME and without config name field raises BadParameter``)
-  in ``features/actor_add_name_positional.feature`` with corresponding step
-  definition. Updated step definitions in
-  ``features/steps/actor_add_update_enforcement_steps.py`` and
-  ``features/steps/actor_add_name_positional_steps.py`` to pass ``context.actor_name``
-  as a positional argument for compatibility.
 
-- **Improved parallel test suite isolation** (#4186): Replaced deprecated
-  ``tempfile.mktemp`` with ``tempfile.mkstemp`` in ``features/environment.py``
-  for atomic temp file creation, eliminating TOCTOU race conditions in the
-  per-scenario database path generation. Added ``fcntl.flock`` file locking to
-  ``_ensure_template_db()`` to prevent race conditions when multiple
-  ``behave-parallel`` workers attempt to create the template database
-  simultaneously.
-
-- **Removed stale @tdd_expected_fail tags from actor add enforcement tests**: The
-  ``--update`` enforcement feature (#2609) was already implemented and merged but
-  residual ``@tdd_expected_fail`` tags remained on its BDD scenarios. These tags
-  were cleaned up in ``features/actor_add_update_enforcement.feature`` so the
-  tests report correctly now that the underlying bug has been fixed.
-
-- **Resolved Behave AmbiguousStep collisions in step definitions** (#4186): Renamed
-  step texts to avoid case-sensitive collisions between different step modules that
-  prevented all Behave tests from loading. Renamed steps in
-  ``edge_case_plan_steps.py``, ``plan_executor_coverage_boost_steps.py``,
-  ``plan_explain_steps.py``, ``plan_model_steps.py``, ``project_repository_steps.py``,
-  ``service_retry_wiring_steps.py``, and ``session_model_steps.py``.
-  Additionally resolved a collision between ``acms_index_data_model_traversal_steps.py``
-  and ``security_audit_steps.py`` for ``Then the count should be``, and fixed
-  ``pr_compliance_checklist_steps.py`` project-root resolution (``parents[3]`` →
-  ``parents[2]``). Fixed table column-header mismatches in
-  ``features/acms/index_data_model_and_traversal.feature`` and guarded
-  ``cli_init_yes_flag_steps.py`` cleanup against ``None`` temp_dir. Annotated
-  ``features/architecture.feature`` ``@tdd_expected_fail`` for pre-existing Pydantic
-  compliance debt in ``IndexEntry`` / ``ACMSIndex`` classes.
-
-- **Cross-actor subgraph cycle detection reads actor_ref field** (#1431): Fixed
-  `_detect_subgraph_cycles()`, `_map_node()`, and the `compile_actor()` main loop
-  in `src/cleveragents/actor/compiler.py` to read `actor_ref` from the top-level
-  `NodeDefinition.actor_ref` field instead of `node.config.get("actor_ref", "")`.
-  Because `actor_ref` is a typed, validated Pydantic field (not a key inside the
-  untyped `config` dict), the old code always returned an empty string, causing
-  cross-actor cycle detection to silently fail and leaving the system vulnerable to
-  infinite recursion at runtime. Added Behave regression tests
-  (`features/actor_subgraph_cycle_detection.feature`) and a Robot Framework
-  integration test (`robot/actor_compiler.robot`) to prevent regressions.
-- **Devcontainer auto-discovery wired into `git-checkout`/`fs-directory` handlers** (#4740):
-  `GitCheckoutHandler.discover_children()` and `FsDirectoryHandler.discover_children()` now
-  call `discover_devcontainers()` after scanning for `fs-directory` children. Any
-  `.devcontainer/devcontainer.json` or root-level `.devcontainer.json` found at the resource
-  location is registered as a `devcontainer-instance` child resource with
-  `provisioning_state: discovered`. Named configurations (`.devcontainer/<name>/devcontainer.json`)
-  are also discovered and carry the configuration name in the `config_name` property.
-  This wires the previously-isolated `discover_devcontainers()` function into the production
-  code path, enabling the spec's zero-configuration devcontainer experience.
+- **`agents plan use` rich output now renders six spec-required structured panels** (#1468): Replaced the single generic `_print_lifecycle_plan()` panel with dedicated panels: Plan Created (ID, Phase, Action, Project, Automation, Attempt), Inputs (argument key=value pairs), Actors (Strategy, Execution, Estimation, Invariant), Automation (Profile, Source, Read-Only), Context (Resources, Indexed Files, View, Hot Token Budget), and Next Steps (follow-up command suggestions including ``agents plan execute``). Non-rich format output is unaffected.
 
 ### Changed
 

CONTRIBUTORS.md

@@ -30,6 +30,7 @@ Below are some of the specific details of various contributions.
 * HAL 9000 has contributed the mandatory PR compliance checklist to `implementation-supervisor.md` (#9824): added an 8-item checklist to the worker prompt body with concrete items covering CHANGELOG.md, CONTRIBUTORS.md, commit footer, CI verification, BDD tests, Epic reference, labels, and milestone assignment to eliminate systemic PR merge blockers.
 * HAL 9000 has contributed the PlanResult.success derivation fix (PR #8214 / issue #7501): replaced the incorrect `error_message is None` heuristic with a dedicated `result_success` column in the plans table, ensuring plans with historical build errors are not incorrectly marked as failed after a successful apply.
 * HAL 9000 has contributed comprehensive milestone documentation for v3.6.0 (Advanced Concepts & Deferred Features) and v3.7.0 (TUI Implementation) (PR #9903): split into sub-documents covering context strategies, LLM backends, resource types, A2A rename, container tool execution, scope chain resolution, cost/safety budgets, E2E workflow tests, code review examples, plugin architecture, TUI layout, persona system, reference/command input, session management, configuration, and TuiMaterializer integration.
+* HAL 9000 has contributed the `agents plan use` structured panels fix (PR #1514 / issue #1468): replaced the single generic lifecycle panel with six spec-required structured panels — Plan Created, Inputs, Actors, Automation, Context, and Next Steps — including Behave BDD scenarios and Robot Framework integration tests.
 * HAL 9000 has contributed the LLMTraceRepository data-integrity fix (PR #8185 / issue #7505): replaced the unconditional `session.commit()` in `LLMTraceRepository.save()` with a dual-path implementation that respects the UnitOfWork pattern — flushing only when an external session is provided, and flushing + committing + closing when operating standalone. This eliminates premature transaction commits, loss of rollback capability, and a docstring/implementation mismatch.
 * HAL 9000 has contributed the ACMS Index Data Model and File Traversal Engine (PR #9664 / issue #9579): foundational data structures for indexed context entries with hot/warm/cold/archive storage tier classification, tag system, and a timeout-safe chunked file traversal engine for large projects with 10,000+ files.
 

features/steps/tdd_plan_use_structured_panels_steps.py

@@ -0,0 +1,98 @@
+"""Step definitions for TDD — agents plan use structured panels (issue #1468)."""
+from __future__ import annotations
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+from behave import given, then, when
+from behave.runner import Context
+from typer.testing import CliRunner
+from cleveragents.cli.commands.plan import app as plan_app
+from cleveragents.domain.models.core.action import Action, ActionState
+from cleveragents.domain.models.core.plan import (
+    AutomationProfileProvenance, AutomationProfileRef, NamespacedName,
+    Plan, PlanIdentity, PlanPhase, PlanTimestamps, ProcessingState, ProjectLink)
+
+_PLAN_ULID = "01JTEST1468PANEMS0000000001"
+
+def _make_action(name="local/test-action"):
+    return Action(namespaced_name=NamespacedName.parse(name), description="Test action", long_description=None,
+        definition_of_done="All panels rendered correctly", strategy_actor="local/strategist",
+        execution_actor="local/executor", reusable=True, read_only=False, state=ActionState.AVAILABLE,
+        created_by=None, created_at=datetime.now(), updated_at=datetime.now())
+
+def _make_plan(*, project_links=None, arguments=None, arguments_order=None, automation_profile=None,
+               strategy_actor="local/strategist", execution_actor="local/executor", estimation_actor=None):
+    now = datetime.now(); args = dict(arguments) if arguments else {}
+    return Plan(identity=PlanIdentity(plan_id=_PLAN_ULID), namespaced_name=NamespacedName.parse("local/test-plan"),
+        description="Test plan for structured panels", definition_of_done="All panels rendered correctly",
+        action_name="local/test-action", phase=PlanPhase.STRATEGIZE, processing_state=ProcessingState.QUEUED,
+        project_links=project_links or [ProjectLink(project_name="local/api-service")],
+        arguments=args, arguments_order=arguments_order or list(args.keys()), automation_profile=automation_profile,
+        strategy_actor=strategy_actor, execution_actor=execution_actor, estimation_actor=estimation_actor,
+        reusable=True, read_only=False, created_by=None, timestamps=PlanTimestamps(created_at=now, updated_at=now))
+
+@given("a plan use panels CLI runner")
+def step_plan_use_panels_runner(context: Context): context.runner = CliRunner()
+@given("a plan use panels mocked lifecycle service")
+def step_plan_use_panels_mock_service(context: Context): context.mock_service = MagicMock()
+@given("a plan use panels action exists")
+def step_plan_use_panels_action_exists(context: Context):
+    context.mock_service.get_action_by_name.return_value = _make_action()
+    context.mock_plan = _make_plan(automation_profile=AutomationProfileRef(profile_name="trusted", provenance=AutomationProfileProvenance.PLAN))
+    context.mock_service.use_action.return_value = context.mock_plan
+@given("a plan use panels action exists with no automation profile")
+def step_plan_use_panels_action_no_profile(context: Context):
+    context.mock_service.get_action_by_name.return_value = _make_action()
+    context.mock_plan = _make_plan(automation_profile=None)
+    context.mock_service.use_action.return_value = context.mock_plan
+
+@when("I run plan use with rich output")
+def step_run_plan_use_rich(context: Context):
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=context.mock_service):
+        context.result = context.runner.invoke(plan_app, ["use", "local/test-action", "local/api-service"])
+
+@when('I run plan use with arg "{arg_str}"')
+def step_run_plan_use_with_arg(context: Context, arg_str: str):
+    if "=" in arg_str:
+        key, val_str = arg_str.split("=", 1)
+        try: val = int(val_str)
+        except ValueError:
+            try: val = float(val_str)
+            except ValueError: val = val_str
+        context.mock_plan = _make_plan(arguments={key: val}, arguments_order=[key], automation_profile=AutomationProfileRef(profile_name="trusted", provenance=AutomationProfileProvenance.PLAN))
+        context.mock_service.use_action.return_value = context.mock_plan
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=context.mock_service):
+        context.result = context.runner.invoke(plan_app, ["use", "local/test-action", "local/api-service", "--arg", arg_str])
+
+@when('I run plan use with automation profile "{profile}"')
+def step_run_plan_use_with_profile(context: Context, profile: str):
+    context.mock_plan = _make_plan(automation_profile=AutomationProfileRef(profile_name=profile, provenance=AutomationProfileProvenance.PLAN))
+    context.mock_service.use_action.return_value = context.mock_plan
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=context.mock_service):
+        context.result = context.runner.invoke(plan_app, ["use", "local/test-action", "local/api-service", "--automation-profile", profile])
+
+@when("I run plan use with json format")
+def step_run_plan_use_json(context: Context):
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=context.mock_service):
+        context.result = context.runner.invoke(plan_app, ["use", "local/test-action", "local/api-service", "--format", "json"])
+
+@when("I run plan use with rich output and no arguments")
+def step_run_plan_use_no_args(context: Context):
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=context.mock_service):
+        context.result = context.runner.invoke(plan_app, ["use", "local/test-action", "local/api-service"])
+
+@when("I run plan use with rich output and no automation profile")
+def step_run_plan_use_no_profile(context: Context):
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=context.mock_service):
+        context.result = context.runner.invoke(plan_app, ["use", "local/test-action", "local/api-service"])
+
+@then("the plan use output should succeed")
+def step_plan_use_output_succeed(context: Context):
+    assert context.result.exit_code == 0, f"Expected exit code 0, got {context.result.exit_code}.\nOutput:\n{context.result.output}"
+
+@then("the plan use output should contain the plan ID")
+def step_plan_use_output_contains_plan_id(context: Context):
+    assert _PLAN_ULID in context.result.output, f"Expected plan ID '{_PLAN_ULID}' in output.\nOutput:\n{context.result.output}"
+
+@then('the plan use output should contain "{text}"')
+def step_plan_use_output_contains(context: Context, text: str):
+    assert text in context.result.output, f"Expected '{text}' in output.\nOutput:\n{context.result.output}"

features/tdd_plan_use_structured_panels.feature

@@ -0,0 +1,104 @@
+@tdd_issue @tdd_issue_1468 @cli @plan @use
+Feature: TDD — agents plan use renders spec-required structured panels
+  As a developer
+  I want the ``agents plan use`` rich output to render six structured panels
+  So that users see Plan Created, Inputs, Actors, Automation, Context, and Next Steps
+
+  Background:
+    Given a plan use panels CLI runner
+    And a plan use panels mocked lifecycle service
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Plan Created panel is rendered with required fields
+    Given a plan use panels action exists
+    When I run plan use with rich output
+    Then the plan use output should succeed
+    And the plan use output should contain "Plan Created"
+    And the plan use output should contain the plan ID
+    And the plan use output should contain "Phase"
+    And the plan use output should contain "Action"
+    And the plan use output should contain "Project"
+    And the plan use output should contain "Automation"
+    And the plan use output should contain "Attempt"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Inputs panel is rendered with argument key=value pairs
+    Given a plan use panels action exists
+    When I run plan use with arg "target_coverage_percent=85"
+    Then the plan use output should succeed
+    And the plan use output should contain "Inputs"
+    And the plan use output should contain "target_coverage_percent=85"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Actors panel is rendered with Strategy, Execution, Estimation actors
+    Given a plan use panels action exists
+    When I run plan use with rich output
+    Then the plan use output should succeed
+    And the plan use output should contain "Actors"
+    And the plan use output should contain "Strategy"
+    And the plan use output should contain "Execution"
+    And the plan use output should contain "Estimation"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Automation panel is rendered with Profile, Source, Read-Only fields
+    Given a plan use panels action exists
+    When I run plan use with automation profile "trusted"
+    Then the plan use output should succeed
+    And the plan use output should contain "Automation"
+    And the plan use output should contain "Profile"
+    And the plan use output should contain "Source"
+    And the plan use output should contain "Read-Only"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Context panel is rendered with Resources, Indexed Files, View, Hot Token Budget
+    Given a plan use panels action exists
+    When I run plan use with rich output
+    Then the plan use output should succeed
+    And the plan use output should contain "Context"
+    And the plan use output should contain "Resources"
+    And the plan use output should contain "Indexed Files"
+    And the plan use output should contain "View"
+    And the plan use output should contain "Hot Token Budget"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Next Steps panel is rendered with follow-up commands
+    Given a plan use panels action exists
+    When I run plan use with rich output
+    Then the plan use output should succeed
+    And the plan use output should contain "Next Steps"
+    And the plan use output should contain "agents plan execute"
+    And the plan use output should contain "agents plan status"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: All six panels are rendered in a single plan use invocation
+    Given a plan use panels action exists
+    When I run plan use with rich output
+    Then the plan use output should succeed
+    And the plan use output should contain "Plan Created"
+    And the plan use output should contain "Inputs"
+    And the plan use output should contain "Actors"
+    And the plan use output should contain "Automation"
+    And the plan use output should contain "Context"
+    And the plan use output should contain "Next Steps"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Non-rich format output is not affected by panel changes
+    Given a plan use panels action exists
+    When I run plan use with json format
+    Then the plan use output should succeed
+    And the plan use output should contain "plan_id"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Plan use with no arguments still renders Inputs panel
+    Given a plan use panels action exists
+    When I run plan use with rich output and no arguments
+    Then the plan use output should succeed
+    And the plan use output should contain "Inputs"
+
+  @tdd_issue @tdd_issue_1468
+  Scenario: Plan use with no automation profile renders Automation panel with none
+    Given a plan use panels action exists with no automation profile
+    When I run plan use with rich output and no automation profile
+    Then the plan use output should succeed
+    And the plan use output should contain "Automation"
+    And the plan use output should contain "(none)"

robot/helper_tdd_plan_use_structured_panels.py

@@ -0,0 +1,89 @@
+"""Helper script for tdd_plan_use_structured_panels.robot integration tests."""
+from __future__ import annotations
+import sys; from datetime import datetime; from pathlib import Path
+from unittest.mock import MagicMock, patch
+_SRC = str(Path(__file__).resolve().parents[1] / "src")
+sys.path = [_SRC] + [p for p in sys.path if p != _SRC and not (p.endswith("/src") and "cleveragents" not in p.split("/")[-1])]
+if _SRC not in sys.path: sys.path.insert(0, _SRC)
+for _m in sorted(sys.modules):
+    if _m.startswith("cleveragents"): del sys.modules[_m]
+from typer.testing import CliRunner; from cleveragents.cli.commands.plan import app as plan_app
+from cleveragents.domain.models.core.action import Action, ActionState
+from cleveragents.domain.models.core.plan import (AutomationProfileProvenance, AutomationProfileRef, NamespacedName, Plan, PlanIdentity, PlanPhase, PlanTimestamps, ProcessingState, ProjectLink)
+runner = CliRunner(); _PLAN_ULID = "01JTEST1468PANEMS0000000001"
+
+def _mock_action(name="local/test-action"):
+    return Action(namespaced_name=NamespacedName.parse(name), description="Test", long_description=None, definition_of_done="All panels rendered correctly", strategy_actor="local/strategist", execution_actor="local/executor", reusable=True, read_only=False, state=ActionState.AVAILABLE, created_by=None, created_at=datetime.now(), updated_at=datetime.now())
+
+def _mock_plan(*, project_links=None, arguments=None, arguments_order=None, automation_profile=None, strategy_actor="local/strategist", execution_actor="local/executor", estimation_actor=None):
+    now = datetime.now(); args = dict(arguments) if arguments else {}
+    return Plan(identity=PlanIdentity(plan_id=_PLAN_ULID), namespaced_name=NamespacedName.parse("local/test-plan"), description="Test plan for structured panels", definition_of_done="All panels rendered correctly", action_name="local/test-action", phase=PlanPhase.STRATEGIZE, processing_state=ProcessingState.QUEUED, project_links=project_links or [ProjectLink(project_name="local/api-service")], arguments=args, arguments_order=arguments_order or list(args.keys()), automation_profile=automation_profile, strategy_actor=strategy_actor, execution_actor=execution_actor, estimation_actor=estimation_actor, reusable=True, read_only=False, created_by=None, timestamps=PlanTimestamps(created_at=now, updated_at=now))
+
+def _run_plan_use(extra_args=None, plan=None):
+    ms = MagicMock(); ms.get_action_by_name.return_value = _mock_action()
+    ms.use_action.return_value = plan or _mock_plan(automation_profile=AutomationProfileRef(profile_name="trusted", provenance=AutomationProfileProvenance.PLAN))
+    args = ["use", "local/test-action", "local/api-service"] + (extra_args or [])
+    with patch("cleveragents.cli.commands.plan._get_lifecycle_service", return_value=ms): result = runner.invoke(plan_app, args)
+    return result.exit_code, result.output
+
+def check_plan_created_panel():
+    ec, o = _run_plan_use()
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for f in ["Plan Created", _PLAN_ULID, "Phase", "Action", "Project", "Automation", "Attempt"]: assert f in o or (print(f"FAIL:{f}"), sys.exit(1))
+    print("tdd-1468-plan-created-ok")
+
+def check_inputs_panel():
+    plan = _mock_plan(arguments={"target_coverage_percent": 85}, arguments_order=["target_coverage_percent"], automation_profile=AutomationProfileRef(profile_name="trusted", provenance=AutomationProfileProvenance.PLAN))
+    ec, o = _run_plan_use(extra_args=["--arg", "target_coverage_percent=85"], plan=plan)
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for f in ["Inputs", "target_coverage_percent=85"]: assert f in o or (print(f"FAIL:{f}"), sys.exit(1))
+    print("tdd-1468-inputs-ok")
+
+def check_actors_panel():
+    ec, o = _run_plan_use()
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for f in ["Actors", "Strategy", "Execution", "Estimation"]: assert f in o or (print(f"FAIL:{f}"), sys.exit(1))
+    print("tdd-1468-actors-ok")
+
+def check_automation_panel():
+    ec, o = _run_plan_use(extra_args=["--automation-profile", "trusted"])
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for f in ["Automation", "Profile", "Source", "Read-Only"]: assert f in o or (print(f"FAIL:{f}"), sys.exit(1))
+    print("tdd-1468-automation-ok")
+
+def check_context_panel():
+    ec, o = _run_plan_use()
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for f in ["Context", "Resources", "Indexed Files", "View", "Hot Token Budget"]: assert f in o or (print(f"FAIL:{f}"), sys.exit(1))
+    print("tdd-1468-context-ok")
+
+def check_next_steps_panel():
+    ec, o = _run_plan_use()
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for f in ["Next Steps", "agents plan execute", "agents plan status"]: assert f in o or (print(f"FAIL:{f}"), sys.exit(1))
+    print("tdd-1468-next-steps-ok")
+
+def check_all_six_panels():
+    ec, o = _run_plan_use()
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    for p in ["Plan Created", "Inputs", "Actors", "Automation", "Context", "Next Steps"]: assert p in o or (print(f"FAIL:{p}"), sys.exit(1))
+    print("tdd-1468-all-panels-ok")
+
+def check_json_format():
+    ec, o = _run_plan_use(extra_args=["--format", "json"])
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    assert "plan_id" in o or (print("FAIL"), sys.exit(1))
+    print("tdd-1468-json-ok")
+
+def check_no_profile():
+    plan = _mock_plan(automation_profile=None)
+    ec, o = _run_plan_use(plan=plan)
+    if ec != 0: print(f"FAIL:{ec}", file=sys.stderr); sys.exit(1)
+    assert "Automation" in o and "(none)" in o or (print("FAIL"), sys.exit(1))
+    print("tdd-1468-no-profile-ok")
+
+_COMMANDS = {"check-plan-created-panel": check_plan_created_panel, "check-inputs-panel": check_inputs_panel, "check-actors-panel": check_actors_panel, "check-automation-panel": check_automation_panel, "check-context-panel": check_context_panel, "check-next-steps-panel": check_next_steps_panel, "check-all-six-panels": check_all_six_panels, "check-json-format": check_json_format, "check-no-profile": check_no_profile}
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in _COMMANDS: print(f"Usage: {sys.argv[0]} <{'|'.join(_COMMANDS)}>", file=sys.stderr); sys.exit(2)
+    _COMMANDS[sys.argv[1]]()
+if __name__ == "__main__": main()

robot/tdd_plan_use_structured_panels.robot

@@ -0,0 +1,73 @@
+*** Settings ***
+Documentation    TDD integration tests for agents plan use structured panels (issue #1468)
+...              Verifies rich output renders all six spec-required panels: Plan Created, Inputs, Actors, Automation, Context, Next Steps.
+Resource         ${CURDIR}/common.resource
+Suite Setup      Setup Test Environment
+Suite Teardown   Cleanup Test Environment
+
+*** Variables ***
+${HELPER}    ${CURDIR}/helper_tdd_plan_use_structured_panels.py
+
+*** Test Cases ***
+Plan Use Renders Plan Created Panel
+    [Documentation]    Verify Plan Created panel renders with required fields.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-plan-created-panel    cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-plan-created-ok
+
+Plan Use Renders Inputs Panel
+    [Documentation]    Verify Inputs panel renders with argument key=value pairs.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-inputs-panel        cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-inputs-ok
+
+Plan Use Renders Actors Panel
+    [Documentation]    Verify Actors panel renders with Strategy, Execution, Estimation fields.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-actors-panel        cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-actors-ok
+
+Plan Use Renders Automation Panel
+    [Documentation]    Verify Automation panel renders with Profile, Source, Read-Only fields.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-automation-panel    cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-automation-ok
+
+Plan Use Renders Context Panel
+    [Documentation]    Verify Context panel renders with Resources, Indexed Files, View, Hot Token Budget fields.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-context-panel       cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-context-ok
+
+Plan Use Renders Next Steps Panel
+    [Documentation]    Verify Next Steps panel renders with follow-up commands.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-next-steps-panel    cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-next-steps-ok
+
+Plan Use Renders All Six Panels
+    [Documentation]    Verify all six spec-required panels are rendered in a single invocation.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-all-six-panels      cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-all-panels-ok
+
+Plan Use JSON Format Not Affected By Panel Changes
+    [Documentation]    Verify --format json output is unaffected by panel changes.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-json-format         cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-json-ok
+
+Plan Use No Automation Profile Renders Automation Panel With None
+    [Documentation]    Verify no automation profile renders (none) values.
+    ${result}=    Run Process    ${PYTHON}    ${HELPER}    check-no-profile          cwd=${WORKSPACE}
+    Log    ${result.stdout}
+    Should Be Equal As Integers    ${result.rc}    0
+    Should Contain    ${result.stdout}    tdd-1468-no-profile-ok

src/cleveragents/cli/commands/plan.py

@@ -1131,7 +1131,7 @@ def _recover_errored_execute_plan(
             current_plan.error_details = {
                 "strategy_decisions_json": strategy_json,
             }
-        service._commit_plan(current_plan)
+        service.save_plan(current_plan)
         current_plan = service.get_plan(plan_id)
         if current_plan is None:
             console.print(
@@ -1183,7 +1183,7 @@ def _recover_errored_execute_plan(
         "prior_error_type": error_type,
         "prior_error_details": json.dumps(prior_errors),
     }
-    service._commit_plan(current_plan)
+    service.save_plan(current_plan)
 
     # If reversion succeeded, re-run strategize with error findings
     if current_plan.phase == PlanPhase.STRATEGIZE:
@@ -1331,6 +1331,167 @@ def _get_plan_executor(
     )
 
 
+# =============================================================================
+# Spec-required structured panels for ``agents plan use`` rich output
+# (Issue #1468 — six panels per specification §agents plan use)
+# =============================================================================
+
+
+def _render_plan_created_panel(plan: Any) -> None:
+    """Render the *Plan Created* panel with required fields.
+
+    Required fields: Plan ID, Phase, Action, Project, Automation, Attempt.
+    """
+    from cleveragents.domain.models.core.plan import (
+        Plan as LifecyclePlan,
+    )
+
+    if not isinstance(plan, LifecyclePlan):
+        return  # Legacy plans do not use structured panels
+
+    projects = ", ".join(
+        link.project_name for link in plan.project_links
+    ) or "(none)"
+
+    panel_content = (
+        f"[bold]ID:[/bold] {plan.identity.plan_id}\n"
+        f"[bold]Phase:[/bold] {plan.phase.value}\n"
+        f"[bold]Action:[/bold] {plan.action_name}\n"
+        f"[bold]Project:[/bold] {projects}\n"
+        f"[bold]Automation:[/bold] "
+        f"{plan.automation_profile.profile_name if plan.automation_profile else '(none)'}\n"
+        f"[bold]Attempt:[/bold] {plan.identity.attempt}"
+    )
+    console.print(Panel(panel_content, title="Plan Created", expand=False))
+
+
+def _render_inputs_panel(plan: Any) -> None:
+    """Render the *Inputs* panel with argument key=value pairs.
+
+    If no arguments are provided, the panel displays "(none)".
+    """
+    from cleveragents.domain.models.core.plan import (
+        Plan as LifecyclePlan,
+    )
+
+    if not isinstance(plan, LifecyclePlan):
+        return  # Legacy plans do not use structured panels
+
+    if plan.arguments_order:
+        lines = []
+        for key in plan.arguments_order:
+            value = plan.arguments.get(key)
+            lines.append(f"[bold]{key}:[/bold] {value}")
+        content = "\n".join(lines)
+    else:
+        content = "(none)"
+
+    console.print(Panel(content, title="Inputs", expand=False))
+
+
+def _render_actors_panel(plan: Any) -> None:
+    """Render the *Actors* panel with Strategy, Execution, Estimation actors.
+
+    Each actor is listed with its namespaced name or '(not set)' when absent.
+    """
+    from cleveragents.domain.models.core.plan import (
+        Plan as LifecyclePlan,
+    )
+
+    if not isinstance(plan, LifecyclePlan):
+        return  # Legacy plans do not use structured panels
+
+    strategy = plan.strategy_actor or "(not set)"
+    execution = plan.execution_actor or "(not set)"
+    estimation = plan.estimation_actor or "(not set)"
+    invariant = plan.invariant_actor or "(not set)"
+
+    content = (
+        f"[bold]Strategy:[/bold] {strategy}\n"
+        f"[bold]Execution:[/bold] {execution}\n"
+        f"[bold]Estimation:[/bold] {estimation}\n"
+        f"[bold]Invariant:[/bold] {invariant}"
+    )
+    console.print(Panel(content, title="Actors", expand=False))
+
+
+def _render_automation_panel(plan: Any) -> None:
+    """Render the *Automation* panel with Profile, Source, Read-Only fields.
+
+    When no automation profile is set the panel shows "(none)" values.
+    """
+    from cleveragents.domain.models.core.plan import (
+        Plan as LifecyclePlan,
+    )
+
+    if not isinstance(plan, LifecyclePlan):
+        return  # Legacy plans do not use structured panels
+
+    profile = (
+        plan.automation_profile.profile_name
+        if plan.automation_profile
+        else "(none)"
+    )
+    source = (
+        plan.automation_profile.provenance.value
+        if plan.automation_profile
+        else "(none)"
+    )
+    read_only = "Yes" if getattr(plan, "read_only", False) else "No"
+
+    content = (
+        f"[bold]Profile:[/bold] {profile}\n"
+        f"[bold]Source:[/bold] {source}\n"
+        f"[bold]Read-Only:[/bold] {read_only}"
+    )
+    console.print(Panel(content, title="Automation", expand=False))
+
+
+def _render_context_panel(plan: Any, console) -> None:
+    """Render the *Context* panel with Resources, Indexed Files, View, Hot Token Budget.
+
+    The Context panel draws from execution environment settings and plan metadata.
+    """
+    from cleveragents.domain.models.core.plan import (
+        Plan as LifecyclePlan,
+    )
+
+    if not isinstance(plan, LifecyclePlan):
+        return  # Legacy plans do not use structured panels
+
+    resources = ", ".join(
+        link.project_name for link in plan.project_links
+    ) or "(none)"
+
+    indexed_files = "(pending)"
+    view = "(pending)"
+    hot_token_budget = "<config>"
+
+    content = (
+        f"[bold]Resources:[/bold] {resources}\n"
+        f"[bold]Indexed Files:[/bold] {indexed_files}\n"
+        f"[bold]View:[/bold] {view}\n"
+        f"[bold]Hot Token Budget:[/bold] {hot_token_budget}"
+    )
+    console.print(Panel(content, title="Context", expand=False))
+
+
+def _render_next_steps_panel(plan: Any) -> None:
+    """Render the *Next Steps* panel with suggested follow-up commands.
+
+    Displays ``agents plan execute <id>`` and ``agents plan status <id>``
+    as the primary follow-up actions for a newly created plan.
+    """
+    pan_id = plan.identity.plan_id if hasattr(plan, "identity") else "<plan-id>"
+
+    lines = [
+        f"- Run 'agents plan execute {pan_id}' to start execution",
+        f"- Run 'agents plan status {pan_id}' to check progress",
+    ]
+    content = "\n".join(lines)
+    console.print(Panel(content, title="Next Steps", expand=False))
+
+
 def _print_lifecycle_plan(plan: Any, title: str = "Plan") -> None:
     """Print v3 lifecycle plan details in a nice panel.
 
@@ -1842,23 +2003,25 @@ def use_action(
                 execution_environment,
             ]
         ):
-            service._commit_plan(plan)
+            service.save_plan(plan)
 
         if fmt != OutputFormat.RICH.value:
             data = _plan_spec_dict(plan)
             console.print(format_output(data, fmt))
         else:
-            _print_lifecycle_plan(plan, title="Plan Created")
+            # Render spec-required structured panels (issue #1468).
+            _render_plan_created_panel(plan)
+            _render_inputs_panel(plan)
+            _render_actors_panel(plan)
+            _render_automation_panel(plan)
+            _render_context_panel(plan, console)
+            _render_next_steps_panel(plan)
+
             if plan.is_terminal:
                 console.print(
                     f"\n[dim]Plan completed with state: "
                     f"{plan.state.value if plan.state else 'unknown'}.[/dim]"
                 )
-            else:
-                console.print(
-                    "\n[dim]Plan is now in Strategize phase (queued). "
-                    "Run 'agents plan execute <id>' when ready.[/dim]"
-                )
 
     except ActionNotAvailableError as e:
         console.print(f"[red]Action not available:[/red] {e}")
@@ -1975,7 +2138,7 @@ def execute_plan(
             pre = service.get_plan(plan_id)
             if pre is not None:
                 pre.execution_environment = execution_environment.lower()
-                service._commit_plan(pre)
+                service.save_plan(pre)
 
         # Create per-resource sandboxes (spec §19310) and build the
         # executor with the sandbox path.