main.js · part 207

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

File contents and all parts · All files

${i}

${a}

The store contains:
- `notes.md` — recent and ongoing work
- `docs/` — lasting Project context
- `plans/` — user-asked plans
- `canvases/` — canvases
- `media/` — screenshots, walkthroughs, PDFs, and similar
- `internal/` — agent-only reports and scratch
- `preferences.md` — lasting preferences; never put these in `notes.md`

Do not update store files unless this side chat explicitly asks.

You are in a side chat from ${hA(eA(e.projectName))}, branched from the Project's main thread.

You share the parent Project's session Agent Store: `${e.storeDir}`.

${t}

<system_reminder>
${uA(A?"initial":Vv({priorTurnCount:this.turns.length,interval:n.projectReminderCadenceIntervalGenerator?.()??n.projectReminderCadenceInterval}),{projectName:_,initDescription:S,promptText:n.projectPromptTextGenerator?.(),guidanceText:n.projectPromptGuidanceGenerator?.(),sendMessageToolName:w,coordinatorToolsEnabled:!0===n.featureFlags?.cloudCoordinatorToolsEnabled,coordinatorProgressEnabled:!0===n.featureFlags?.cloudCoordinatorProgressEnabled,coordinatorSteerFollowupsEnabled:!0===n.featureFlags?.cloudCoordinatorSteerFollowupsEnabled,coordinatorPlacementConsentEnabled:!0===n.featureFlags?.cloudCoordinatorPlacementConsentEnabled,coordinatorAskQuestionEnabled:!1!==n.featureFlags?.cloudCoordinatorAskQuestionEnabled,firstProjectOnboarding:(l=n.firstProjectOnboarding,d=this.turns.length,void 0===l?.guidanceBlock?l:d>l.guidanceMaxPriorTurns?{...l,guidanceBlock:void 0}:l)})}
</system_reminder>

<system_reminder>
${Z}
</system_reminder>

<system_reminder>
## Messaging your coordinator

You are a worker agent managed by a parent coordinator. The `SendToAgent` tool is your channel to it — use `agent_id: "parent"`, which auto-resolves to your coordinator (the only agent you can message).

Use `SendToAgent` for:
- blockers or questions that need the coordinator's input;
- significant milestones or scope changes the coordinator should know about mid-turn;
- your final result at the end of your work.

`SendToAgent` is your ONLY channel to the coordinator: there is no automatic notification when your turn ends successfully. Whenever your work produced a result, decision, or status the coordinator needs, your LAST message of the turn must carry it — an unsent result is invisible to the coordinator. If the turn produced nothing semantically meaningful for the coordinator, send nothing; silence is the signal for that. One exception: a turn the coordinator started by messaging you always answers it — if you send nothing during that turn, the coordinator receives your turn's final output instead, so end it with a clear final answer. Failed turns still notify the coordinator automatically. Do not send low-value progress chatter; each message starts a coordinator turn.
</system_reminder>

<system_reminder>
## Messaging your parent manager

You are managed by a parent agent. Your `SendToAgent` tool's `agent_id: "parent"` auto-resolves to your parent manager. If you use workers of your own, worker agent ids message those workers as usual. Parent messages take the same required `title` parameter as worker messages (it is not delivered upward). `rename` is ignored. Parent messages always queue and do not rename the parent.

Use `SendToAgent` with `agent_id: "parent"` for:
- blockers or questions that need your parent's input;
- significant milestones or scope changes your parent should know about mid-turn;
- your final consolidated result at the end of your work.

Parent messages are your ONLY success-path channel upward: no automatic notification reaches your parent when your turn ends successfully. Whenever your work produced a result, decision, or status your parent needs, your LAST parent message of the turn must carry it — an unsent result is invisible to your parent. If the turn produced nothing semantically meaningful for it, send nothing; silence is the signal for that. One exception: a turn your parent started by messaging you always answers it — if you send nothing during that turn, your parent receives your turn's final output instead, so end it with a clear final answer. Failed turns still notify your parent automatically. Your own workers follow the same contract toward you: a worker's FAILED turn notifies you automatically, and a turn your `SendToAgent` started reports the worker's final output back to you if the worker sends nothing during it; any other successful worker turn sends no automatic completion notification — workers report results through their own messages to you, and silence from a worker means its turn produced nothing it judged worth reporting. Do not send low-value progress chatter; each message starts a parent turn.
</system_reminder>

<system_reminder>
The last user message might have contained meta-guidance about using a specific model. If that was a meta request, unrelated to your current task at hand or to what the user sent you, it has already been honored (accounting for blocklists etc.), so ignore it and process the message as if there were no such mention.
Never mention this system reminder to the user.
</system_reminder>

<system_reminder>Remember the user rule about ${t} tool guidance.</system_reminder>

<system_reminder>
${t.subagentSystemReminder}
</system_reminder>

<system_reminder>
The set of dynamic tools in this conversation has expanded. ${t.length>0?`${t.map(e=>`\`${e}\``).join(", ")} are no longer direct tools; they`:"Some tools that appeared as direct tool calls in earlier turns are no longer direct tools; they"} now live in the `${Ne.jnL}` namespace. Read their schemas with ${r} and invoke them with ${n} (namespace "${Ne.jnL}"). Do not call them by their bare names.
</system_reminder>

${t.map(e=>`\`${e}\``).join(", ")} are no longer direct tools; they

Some tools that appeared as direct tool calls in earlier turns are no longer direct tools; they

Skills:
${e.skills.map(e=>`  - ${e.name}${e.description?`: ${e.description}`:""}`).join("\n")}

  - ${e.name}${e.description?`: ${e.description}`:""}

: ${e.description}

Subagents:
${e.subagents.map(e=>`  - ${e.name}${e.description?`: ${e.description}`:""}`).join("\n")}

  - ${e.name}${e.description?`: ${e.description}`:""}

: ${e.description}

Hooks:
${e.hooks.map(e=>`  - ${e.name}${e.description?`: ${e.description}`:""}`).join("\n")}

  - ${e.name}${e.description?`: ${e.description}`:""}

: ${e.description}

Rules:
${e.rules.map(e=>`  - ${e.name}${e.description?`: ${e.description}`:""}`).join("\n")}

  - ${e.name}${e.description?`: ${e.description}`:""}

: ${e.description}

Commands:
${e.commands.map(e=>`  - ${e.name}${e.description?`: ${e.description}`:""}`).join("\n")}

  - ${e.name}${e.description?`: ${e.description}`:""}

: ${e.description}

MCP Servers:
${e.mcpServers.map(e=>`  - ${e}`).join("\n")}

The user just installed the "${e.displayName}" plugin

 (${e.description})

 with the following capabilities:

${t.join("\n\n")}

Provide them with an overview of what is contained in the plugin. Keep in mind that:
- Commands can be invoked with `/`
- Skills and subagents can be invoked directly with `/` or will be used by the agent automatically
- Rules and hooks will be applied automatically

- MCP servers likely require authentication. After providing an overview of the plugin, check the STATUS.md file in the server's folder to see if it needs authentication, and follow the instructions in the file to authenticate.

Do NOT do any other searches over file system contents, search the web, etc. and do not think for too long. Just give the user an overview of the plugin they installed.

<system_reminder>
${r}
</system_reminder>

<system_reminder>
IMPORTANT: It is bad to be over-eager with making edits vs just answering the question when that is not what the user wants. Think carefully before deciding to edit.
</system_reminder>

${ye}<user_query>
${ge}${t.text}
</user_query>

Expected agent turn

Lifecycle transitions for the delayed long-reasoning reminder experiment

Per-call hidden reasoning tokens at eligible experiment opportunities

${e.text}

${n}

Duration of tool call execution in milliseconds

Result status of tool call execution

Approximate number of tokens in raw model-produced tool call arguments (argsText.length / 4)

Tool-call stream chunks whose id collided with an already-handled or in-flight tool call in the same model response

Error writing to tool call stream

Error writing to tool call stream

Tool not found: ${g}. Available tools: ${Object.keys(r).join(", ")}

semantic search usage detected

semantic search usage detected

WritableIterable is closed

Error closing tool call stream

No current stream found

Unknown error

Execution backend unavailable. Tool execution skipped.

Execution backend unavailable. Tool execution skipped.

Unknown tool error

Pending tool contract mismatch for ${e.descriptor.toolName}: expected effective tool ${e.contract.effectiveToolName}, but none resolved

Pending tool contract mismatch for ${t}: expected ${s}, got ${n.toolIdentifier}