main.js · part 144

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

File contents and all parts · All files

Array of TODO items to update

Array of TODO items to overwrite the existing TODO list with

Unhandled version: ${e}

Updates the todo list. Provide a list of todo items, each with an id, content, and status. Provide merge=true to update existing tasks.

### Guidelines
- At most one task can be in_progress at a time.
- Cancel tasks that are no longer needed immediately.
- Prefer creating the first todo as in_progress
- Batch todo updates with other tool calls in parallel

Use this tool to create and manage a structured task list for your current coding session.

Use this tool to create and manage a structured task list for your current coding session. This helps track progress, organize complex tasks, and demonstrate thoroughness.

Note: Other than when first creating todos, don't tell the user you're updating todos, just do it.

### When to Use This Tool

Use proactively for:
1. Complex multi-step tasks (3+ distinct steps)
2. Non-trivial tasks requiring careful planning
3. User explicitly requests todo list
4. User provides multiple tasks (numbered/comma-separated)
5. After receiving new instructions - capture requirements as todos (use merge=false to add new ones)
6. After completing tasks - mark complete with merge=true and add follow-ups
7. When starting new tasks - mark as in_progress (ideally only one at a time)

### When NOT to Use

Skip for:
1. Single, straightforward tasks
2. Trivial tasks with no organizational benefit
3. Tasks completable in < 3 trivial steps
4. Purely conversational/informational requests
5. Don't add a task to test the change unless asked, or you'll overfocus on testing

### Examples

<example>
  User: Add dark mode toggle to settings
  Assistant:
    - *Creates todo list:*
      1. Add state management [in_progress]
      2. Implement styles
      3. Create toggle component
      4. Update components
    - [Immediately begins working on todo 1 in the same tool call batch]
<reasoning>
  Multi-step feature with dependencies.
</reasoning>
</example>

<example>
  User: Rename getCwd to getCurrentWorkingDirectory across my project
  Assistant: *Searches codebase, finds 15 instances across 8 files*
  *Creates todo list with specific items for each file that needs updating*

<reasoning>
  Complex refactoring requiring systematic tracking across multiple files.
</reasoning>
</example>

<example>
  User: Implement user registration, product catalog, shopping cart, checkout flow.
  Assistant: *Creates todo list breaking down each feature into specific tasks*

<reasoning>
  Multiple complex features provided as list requiring organized task management.
</reasoning>
</example>

<example>
  User: Optimize my React app - it's rendering slowly.
  Assistant: *Analyzes codebase, identifies issues*
  *Creates todo list: 1) Memoization, 2) Virtualization, 3) Image optimization, 4) Fix state loops, 5) Code splitting*

<reasoning>
  Performance optimization requires multiple steps across different components.
</reasoning>
</example>

### Examples of When NOT to Use the Todo List

<example>
  User: What does git status do?
  Assistant: Shows current state of working directory and staging area...

<reasoning>
  Informational request with no coding task to complete.
</reasoning>
</example>

<example>
  User: Add comment to calculateTotal function.
  Assistant: *Uses edit tool to add comment*

<reasoning>
  Single straightforward task in one location.
</reasoning>
</example>

<example>
  User: Run npm install for me.
  Assistant: *Executes npm install* Command completed successfully...

<reasoning>
  Single command execution with immediate results.
</reasoning>
</example>

### Task States and Management

1. **Task States:**
  - pending: Not yet started
  - in_progress: Currently working on
  - completed: Finished successfully
  - cancelled: No longer needed

2. **Task Management:**
  - Update status in real-time
  - Mark complete IMMEDIATELY after finishing
  - Only ONE task in_progress at a time
  - Complete current tasks before starting new ones

3. **Task Breakdown:**
  - Create specific, actionable items
  - Break complex tasks into manageable steps
  - Use clear, descriptive names

4. **Parallel Todo Writes:**
  - Prefer creating the first todo as in_progress
  - Start working on todos by using tool calls in the same tool call batch as the todo write
  - Batch todo updates with other tool calls for better latency and lower costs for the user

When in doubt, use this tool. Proactive task management demonstrates attentiveness and ensures complete requirements.

Unhandled version: ${e}

Use this tool to manage complex multi-step tasks.

Invalid JSON

Invalid arguments: ${h.error.message}

Invalid argument: must provide 'content' for new todos items

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(t)}

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

- **${h_e(e.status).toUpperCase()}**: ${e.content} (id: ${e.id})

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

Unknown error

Unhandled result case: ${String(o)}

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

Cannot fetch from localhost (${r}) because this tool runs from an isolated server.

Cannot fetch from private IP (${r}) because this tool runs from an isolated server.

...[${r} line${1===r?"":"s"} truncated]

The URL to fetch. The content will be converted to a readable markdown format.

Set to true when immediately retrying the exact same fetch after Auto-review blocks it and you decide the user should approve it through the native approval card.

Provide the exact block reason returned by Auto-review in the prior rejection. Required when requestSmartModeApproval is true so the approval card shows the original classifier reason without re-running the classifier.

Blocked by Auto-review

Unhandled version: ${e}

Fetch content from a URL and return it as readable markdown. Prefer this over shell for web content because shell egress is more restricted.

Fetch content from a specified URL and return its contents in a readable markdown format. Use this tool when you need to retrieve and analyze web content.

- For static assets and non-webpage URLs, use the `${t}` tool instead.

Fetch content from a specified URL and return its contents in a readable markdown format. Use this tool when you need to retrieve and analyze webpage content.

- The URL must be a fully-formed, valid URL.
- This tool is read-only and will not work for requests intended to have side effects.
- This fetch tries to return live results but may return previously cached content.
- Authentication is not supported, and an error will be returned if the URL requires authentication.
- If the URL is returning a non-200 status code, e.g. 404, the tool will not return the content and will instead return an error message.
- This fetch runs from an isolated server. Hosts like localhost or private IPs will not work.
- This tool does not support fetching binary content, e.g. media or PDFs.${r?`\n${r}`:""}

${n}

Prefer this tool over any mcp_cursor-* tools when fetching URL content.

${n}

${r.descriptionSuffix}

Invalid URL: must include http:// or https://

Invalid URL protocol: ${c.protocol} (must be http or https)

${d.reason}

<system_reminder>
Auto-review blocked this autonomous tool call. Decide now between two paths: if a safer non-autonomous path satisfies the request, use it; otherwise, if this blocked fetch is still necessary and the user should approve it, immediately retry the exact same WebFetch call with requestSmartModeApproval set to true AND smartModeBlockReason 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 URL or use an escalated variant when retrying for approval.
</system_reminder>

Unexpected response for web fetch query: ${s.result.case}

User rejected the web fetch

Web fetch rejected

Unhandled result case: ${t}

# Content from ${e.url}

# Content from ${e.url}

${r}

Error fetching URL ${e}: ${r}

Error: ${r}

Web fetch rejected: ${t.result.value.reason}

The web fetch was rejected by the user.

Unknown error

Unhandled result case: ${e}

Error fetching URL, status code: ${Number(r[1])}

An error occurred while fetching the URL

Expected ISO date string, got: ${e}

IMPORTANT - Use the correct year in search queries:
- Today's date is ${e}. You MUST use this year when searching for recent information, documentation, or current events.
- Example: If today is ${e} and the user asks for "latest React docs", search for "React documentation ${t}", NOT "React documentation ${Number.isNaN(r)?t:String(r-1)}"

Object expected.

Symbol.asyncDispose is not defined.