Agent pushes user toward implementation choices while still in plan mode

### Describe the bug

When working in plan mode (Shift+Tab / `[[PLAN]]` prefix), the agent frequently presents questions and choices that are implementation-oriented — pushing the user to commit to specific implementation decisions before they're ready to leave the planning phase.

For example, while still brainstorming and refining a plan, the agent might ask:

- `Should I start implementing X now?`
- `Which file should I create first?`
- `Ready to proceed? [Yes, start implementing / No]`

This breaks the planning workflow. The user is still iterating on the *what* and *why*, but the agent keeps steering toward the *how* and *when*.

### Expected behavior

While in plan mode, the agent should:

- **Stay in the planning domain** — ask questions about scope, priorities, trade-offs, and approach
- **Not offer to start implementing** or present implementation-action choices
- **Respect that the user may have more input** to contribute to the plan before transitioning
- **Wait for an explicit signal** from the user to begin implementation (e.g. `start`, `do it`, `implement it`, or switching out of plan mode)

Plan mode should feel like a collaborative *design* conversation, not a countdown to execution.

### Example of the problem

1. User (in plan mode): `I want to refactor the auth module`
2. Agent: outlines a plan, then immediately asks `Should I create the new auth service file now? [Yes / No]`
3. User: `Wait, I also want to consider moving the token logic...`
4. Agent: `Got it. Should I start with the token logic refactor? [Start now / Plan more]`

The agent keeps circling back to `let's start` rather than staying in the planning headspace.

### Proposed improvement

- When in plan mode, bias questions toward planning concerns (scope, dependencies, open questions, trade-offs)
- Suppress implementation-action choices (`start`, `create file`, `run command`) until the user explicitly transitions out of plan mode
- Treat plan mode as a hard boundary — the agent should never suggest or begin implementation while `[[PLAN]]` is active

### Additional context

This is especially disruptive during complex multi-phase plans where the user needs several rounds of back-and-forth to shape the approach before any code gets written. Being repeatedly nudged toward implementation breaks the flow and adds friction.

Start by tracing how plan mode is detected from Shift+Tab and the [[PLAN]] prefix, then locate the logic that generates questions and implementation-action choices. Check how plan-mode conversations are tested, and make sure completion means planning questions remain focused on scope and trade-offs until the user explicitly signals implementation or exits plan mode.

Written by the indexing model from the issue text.