daemon.cjs · part 346

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

File contents and all parts · All files

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

User rejected the mode switch

Mode switched, updating state

### ${displayName} [switchable]
${description4}

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

**Examples:**
${examples}

### ${displayName} (cannot switch to this mode)
${description4}

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
${modeBlocks.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

Whether to merge the todos with the existing todos. If true, the todos will be merged into the existing todos based on the id field. You can leave unchanged properties undefined. If false, the new todos will replace the existing todos.

Array of todo items to write to the workspace

Array of TODO items to update or create

Whether to merge the todos with the existing todos. If true, the todos will be merged into the existing todos based on the id field. You can leave unchanged properties undefined. If false, the new todos will replace the existing todos.

Array of TODO items to update or create

Whether to merge the todos with the existing todos. If true, the todos will be merged into the existing todos based on the id field. You can leave unchanged properties undefined. If false, the new todos will replace the existing todos.

Array of TODO items to update or create

Whether to merge the todos with the existing todos. If true, the todos will be merged into the existing todos based on the id field. You can leave unchanged properties undefined. If false, the new todos will replace the existing todos.

Successfully updated TODOs. Make sure to follow and update your TODO list as you make progress. Cancel and add new TODO tasks as needed when the user makes a correction or follow-up request.

 No TODOs are marked in-progress, make sure to mark them before starting the next.

Here are the latest contents of your todo list:

${JSON.stringify(todosJson)}

Here are the latest contents of your todo list:
${success.todos.map((todo) => `- **${todoStatusToString(todo.status).toUpperCase()}**: ${todo.content} (id: ${todo.id})`).join("\n")}

- **${todoStatusToString(todo.status).toUpperCase()}**: ${todo.content} (id: ${todo.id})

use strict

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

You have many finished todos. Consider cleaning up old ones.

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

The current status of the TODO item