main.js · part 41

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

File contents and all parts · All files

- Do the split in this agent session, not in a subagent, so you can use the main chat history.

- Compare the current work to the base branch, including committed and uncommitted changes.

- Before proposing slices, inspect ownership signals for touched paths and use them to find natural reviewer boundaries.

- Propose reviewer-aligned PR slices first, then ask for approval before creating branches, committing, pushing, or opening PRs.

- Default to independent PRs off the base branch. Stack PRs only when the dependency is real, with foundations before consumers.

- If there is uncommitted work, save a recoverable snapshot before moving work around.

- Stage only named files or hunks for each approved slice. Do not use `git add .` or `git add -A`.

- After approval, create each branch from the right base, commit only the planned files or hunks, push, and open the PR.

- Report the PR titles and URLs, plus anything left on the starting branch or working tree.

<system_reminder>
The user clicked Start Multitasking.

Create exactly one async subagent forked from yourself ${void 0!==t?`using the ${t} tool`:"using your subagent tool"} with run_in_background set to true and resume set to "self". Use the prompt "You are the forked subagent; continue executing your task."

NOTE: If you receive the exact prompt "You are the forked subagent; continue executing your task.", then continue executing your task. Do NOT fork yourself again.

Otherwise, if you do not receive that prompt, immediately stop. Do not continue planning or coordinating, do not perform additional foreground work, and do not send a user-visible response after forking yourself into that subagent.
</system_reminder>

using the ${t} tool

using your subagent tool

<system_reminder>
The user clicked Build in Parallel.

Implement the plan as specified, it is attached for your reference. Do NOT edit the plan file itself.
Todos from the plan have already been created. Do not create them again. Mark them as in_progress as you work, starting with the first one. Don't stop until you have completed all the todos.

<build_with_multitask_instructions>
${e?"By clicking Build in Parallel, the user has entered **Multitask Mode** and has expressed a desire for parallel execution.":"By clicking Build in Parallel, the user has expressed a desire for parallel execution."}

Rules for multitask plan execution:

When starting subagent(s) for plan execution, DO NOT repeat the plan in your prompt to the subagents. Just reference the plan file in your prompt, specify which steps of the plan the agent should execute, and include any required context which is not self-evident from the plan file.

For each Todo in your plan, decide which other Todos must be completed first. Then, flatten the dependency chains into one or more build phases. Execute each build phase as its own asynchronous (top-level) subagent. Whenever possible, execute independent build phases in parallel. If later Todos can be parallelized after the completion of earlier Todo(s), execute the blocking steps as an initial build phase, then launch parallel build phases after it completes.

IMPORTANT: If your plan includes dedicated testing steps at the end AND you are parallelizing across multiple implementation agents, instruct earlier subagents to not conduct end-to-end testing and use later testing subagents to test the full implementation. On the other hand, if just one agent is implementing, that agent should also do the testing.

${e?"For the plan execution and all follow-ups until the user exits multitask mode, follow your multitask mode instructions.":"These parallelization instructions apply for the plan execution and its follow-ups."} For the extent of plan execution, these parallelization instructions take precedence over any other instructions about avoiding top-level sibling subagent parallelization.
</build_with_multitask_instructions>
</system_reminder>

By clicking Build in Parallel, the user has entered **Multitask Mode** and has expressed a desire for parallel execution.

By clicking Build in Parallel, the user has expressed a desire for parallel execution.

For the plan execution and all follow-ups until the user exits multitask mode, follow your multitask mode instructions.

These parallelization instructions apply for the plan execution and its follow-ups.

... ${t} ${1===t?"line":"lines"} not shown ...
${r}

${r}
... ${t} ${1===t?"line":"lines"} not shown ...

 isFullFile="true"

 language="${e.languageIdentifier}"

 path="${e.filePath}"

 ${e}="${t}"

<${e.tag}${o}${t}${n}${s}>
${r}
</${e.tag}>

${(t+r).toString().padStart(6," ")}  ${e}

${e.lineNumber.toString().padStart(6," ")}  ${e.text}

${o.toString().padStart(6," ")}|${e}

${e.lineNumber.toString().padStart(6," ")}|${e.text}

${s.absPath}${e}

${a}- ${Qe.posix.basename(e)}${o}

${u}- ${s.name}

${n}cwd: ${r.cwd}

${n}last modified: ${e(r.lastModifiedMs)}

exit: ${e}

time: ${e(t)}

duration: ${e}ms

${n}last commands:

${n}  - ${o(e)}

${n}current command:

${n}  - ${o(r.currentCommand)}

${t} *${e||"no-ext"}

${u}- ${s.name}${o}

${u}  [${i} file${1===i?"":"s"} in subtree: ${r}]

${u}- ${s.name}${o}...

npm install

yarn install

pnpm install

pip install

apt install

yum install

brew install

docker pull

docker push

git clone

git pull

git push

git fetch

The shell command returned no exit status, so its result is unknown — do not assume it ran or succeeded. If this repeats, the execution environment may need to be restarted.

Command aborted after ${t} ms.

Command aborted.