main.js · part 236

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

File contents and all parts · All files

Shell tool executing

Command classifier failed

Model accessed agent transcript path

Auto-review shell approvals require a conversation id

Smart Mode shell preflight state

Smart Mode shell native approval requested

Smart Mode shell allowlist precheck starting

Smart Mode shell allowlist precheck completed

Shell allowlist precheck failed

Smart Mode shell sandbox autorun bypass

Smart Mode shell classifier allowed

Smart Mode shell classifier rejected

Smart Mode shell classifier blocked

Smart Mode shell approval provider allowed

${w.reason}

<system_reminder>
Auto-review blocked this autonomous tool call. Decide now between two paths: (1) if a genuinely safer, lower-privilege, authorized path satisfies the request, use it; (2) if this blocked action is still necessary and the user should approve it, immediately retry the exact same Shell call with request_smart_mode_approval set to true AND smart_mode_block_reason set to the exact block reason text above. That retry is what shows the native approval card; stopping here leaves the user with no approval UI. Do not change the command, add permissions, or use an escalated variant when retrying for approval. Trying a different anonymous public file host, pastebin, disposable transfer link, or similar courier is NOT path (1) — that is the same unauthorized data-exposure crossing — so for that class prefer path (2) or ask the user, do not shop for another intermediary.
</system_reminder>

Smart Mode shell background handoff

Unknown error starting background command

Unhandled background result case: ${e}

Failed to clean up rejected background shell approval

Smart Mode shell foreground handoff

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