main.js · part 241

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/extensions/cursor-agent-host/dist/main.js, part 241. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

Steer-driven shell background handoff failed

Shell exec stream closed without an exit event; surfacing exec-backend-unavailable instead of a fabricated exit-0 success

command not found: dump_zsh_state

Unhandled version: ${e}

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

Switch between modes: ${1===r.length?r[0]:2===r.length?`${r[0]} and ${r[1]}`:`${r.slice(0,-1).join(", ")}, and ${r[r.length-1]}`}. Proactively consider switching modes for relevant requests.

${r[0]} and ${r[1]}

${r.slice(0,-1).join(", ")}, and ${r[r.length-1]}

The mode to switch to. Allowed values: ${t}.

target_mode_id must be one of: ${e.join(", ")}

Optional explanation for why the mode switch is requested. This helps the user understand why you're switching modes.

### ${r} [switchable]
${n}

**Switch to ${r.split(" ")[0]} when:**
${s}

**Examples:**
${o}

### ${r} (cannot switch to this mode)
${n}

Agent Mode

Default implementation mode with full access to all tools for making changes.

- You have a clear understanding of what to implement
- Planning/debugging is complete and you're ready to code
- The task is straightforward with an obvious implementation
- You've gathered enough context and are ready to execute

- After planning: "I've designed the approach, ready to implement" → Switch to Agent
- After debugging: "Found the bug, it's a null check issue" → Switch to Agent
- Simple task: User asks to "Add a comment to this function" → Stay in Agent (no switch needed)

Cloud Mode

Runs the agent in the Cloud (background). Useful for long-running work and browser/environment automation.

- The task likely needs browser automation (Playwright/Cypress/Selenium, UI flows, screenshots)
- The task likely needs environment automation (docker-compose, multi-service integration, emulators/VMs)
- You want the agent to keep running even if the local machine sleeps/closes

- User: "Fix this UI flow and run the Playwright tests" → Switch to Cloud
- User: "Start docker-compose and validate the end-to-end flow" → Switch to Cloud
- User: "Run unit tests / lint / typecheck" → Stay in Agent (Cloud not needed)

Plan Mode

Read-only collaborative mode for designing implementation approaches before coding.

- The task has multiple valid approaches with significant trade-offs
- Architectural decisions are needed (e.g., "Add caching" - Redis vs in-memory vs file-based)
- The task touches many files or systems (large refactors, migrations)
- Requirements are unclear and you need to explore before understanding scope
- You would otherwise ask multiple clarifying questions

- User: "Add user authentication" → Switch to Plan (session vs JWT, storage, middleware decisions)
- User: "Refactor the database layer" → Switch to Plan (large scope, architectural impact)
- User: "Make the app faster" → Switch to Plan (need to profile, multiple optimization strategies)

Debug Mode

Systematic troubleshooting mode for investigating bugs, failures, and unexpected behavior with runtime evidence.

- User reports a bug, error, or unexpected behavior
- Tests are failing and the cause is unclear
- You need to form and test hypotheses about root causes
- The issue requires systematic elimination of possibilities
- ONLY use this mode to debug with runtime evidence (capture logs when the user repros the issue).

- User: "The login is broken" → Switch to Debug (need to reproduce, check logs, trace flow)
- User: "Tests are failing in CI" → Switch to Debug (systematic investigation needed)
- User: "Why is this returning null?" → Switch to Debug (need to trace execution path)

Multitask Mode

Parallelizes substantial work across asynchronous subagents while keeping quick clarification and light context gathering in the foreground.

- The request naturally splits into multiple substantial units of work
- You want to keep the user unblocked by delegating long-running or multi-step work
- Foreground work should stay limited to quick questions and light context gathering

- User: "Audit these five services in parallel" → Switch to Multitask
- User: "Implement several independent features across the repo" → Switch to Multitask
- User: "Add one small helper function" → Stay in Agent (no need to parallelize)

Ask Mode

Read-only mode for exploring code and answering questions without making changes.

- User wants information, not implementation
- The request is purely exploratory or educational
- User explicitly asks you not to make changes
- You need to explain code without modifying it

- User: "How does the auth system work?" → Switch to Ask (explanation only)
- User: "What files handle routing?" → Switch to Ask (exploration only)
- User: "Don't change anything, just explain this" → Switch to Ask

Switch the interaction mode to better match the current task. Each mode is optimized for a specific type of work.

## When to Switch Modes

Switch modes proactively when:
1. **Task type changes** - User shifts from asking questions to requesting implementation, or vice versa
2. **Complexity emerges** - What seemed simple reveals architectural decisions or multiple approaches
3. **Debugging needed** - An error, bug, or unexpected behavior requires investigation
4. **Planning needed** - The task is large, ambiguous, or has significant trade-offs to discuss
5. **You're stuck** - Multiple attempts without progress suggest a different approach is needed

## When NOT to Switch

Do NOT switch modes for:
- Simple, clear tasks that can be completed quickly in current mode
- Mid-implementation when you're making good progress
- Minor clarifying questions (just ask them)
- Tasks where the current mode is working well

## Available Modes
${n.join("\n")}

## Important Notes

- **Be proactive**: Don't wait for the user to ask you to switch modes
- **Explain briefly**: When switching, briefly explain why in your `explanation` parameter
- **Don't over-switch**: If the current mode is working, stay in it
- **User approval required**: Mode switches require user consent

User rejected the mode switch

Mode switched, updating state

Switched composer mode to ${t.toModeId}

Switched composer mode from ${t.fromModeId} to ${t.toModeId}

Error switching mode: ${e.result.value.error}

Mode switch was rejected by the user. Do not attempt to switch modes again.

Unknown error

Unhandled result case: ${e.result}

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

The description/content of the todo item

The current status of the todo item

Unique identifier for the todo item

Unique identifier for the TODO item

The description/content of the todo item