[FEATURE] Add "Next Steps" section in Plan Mode to defer follow-up tasks from core execution

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

When working in plan mode, I often identify additional tasks, ideas, or modifications while reviewing the generated plan. These additional items are typically sequential successors of the core task — they logically follow after the current plan completes and depend on its outcome. However, there is currently no way to capture these items separately from the core plan.

If I incorporate them directly into the main plan, it negatively impacts the agent's performance and focus. The plan grows beyond the immediate scope, the agent tries to execute everything in one pass, and the result is less precise execution and diluted context. This is especially problematic because these follow-up tasks — while related and sequential — are not part of the current unit of work and should only be considered once the core plan has been completed successfully.

The only workarounds today are:

• Manually editing the plan file (Ctrl+G) to add a "future work" section — but the agent has no semantic understanding that these items should be skipped during execution.
• Noting follow-ups externally (e.g., in a separate document or mental note) — which breaks the workflow and loses the conversational context.

None of these approaches provide a clean separation between "execute now" and "revisit later."

Proposed Solution

Introduce a dedicated "Next Steps" section within plan mode with the following behavior:

1. During planning, the user can define additional tasks, ideas, or modifications under a "Next Steps" area — either through the plan file or via a UI element.
2. During execution, these items are explicitly excluded from the agent's primary execution process. The agent focuses solely on the core plan.
3. After plan completion, the agent presents the previously defined "Next Steps" to the user.
4. The user can then decide for each item whether to:

• Execute it immediately
• Incorporate it into a new plan
• Discard it

Example interaction:

User enters plan mode, defines a plan with 5 implementation steps.
User also adds 3 "Next Steps": a refactoring idea, a test improvement, and a documentation update.

Agent executes the 5 core steps.

Agent: "Plan complete. You had 3 items in Next Steps:
  1. Refactor authentication middleware to reduce duplication
  2. Add edge case tests for the new validation logic
  3. Update API documentation for the changed endpoints

Which of these would you like to proceed with?"

Alternative Solutions

• Structured plan sections — Users could manually split their plan into "Phase 1" / "Phase 2" headings, but the agent treats all sections equally and may attempt to execute everything.
• Multiple sessions — Complete the main plan, then start a new session for follow-ups. This loses context and requires re-explaining the codebase state.
• CLAUDE.md notes — Store follow-up items in the project's CLAUDE.md, but this pollutes persistent instructions with temporary task notes.

Priority

Medium - Would be very helpful

Feature Category

Interactive mode (TUI)

Use Case Example

1. I start a plan mode session to implement a new API endpoint.
2. While reviewing the generated plan, I notice the existing error handling in related files could be improved — but it's not part of the current task.
3. I add "Refactor error handling in src/api/middleware.ts" to Next Steps.
4. I also notice a potential performance optimization — I add "Investigate caching for /users endpoint" to Next Steps.
5. I approve the core plan. The agent executes only the API endpoint implementation.
6. After completion, the agent presents my 2 Next Steps items.
7. I choose to execute the error handling refactor now and discard the caching investigation for later.

Additional Context

• This feature would complement the existing Tasks API (blockedBy dependencies) by adding a higher-level concept of "deferred intent" rather than "blocked execution."
• It aligns with how developers naturally think during planning — capturing tangential ideas without derailing the current focus.
• The implementation could leverage the existing plan file format (.claude/plans/*.md) by introducing a recognized ## Next Steps section that the agent is instructed to skip during execution.
• Similar concepts exist in agile methodologies (e.g., "parking lot" in meetings, "icebox" in sprint planning) and have proven effective at maintaining focus while preserving ideas.