main.js · part 213

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

File contents and all parts · All files

Object not disposable.

An error was suppressed during disposal.

The beginning of the above subagent result is already visible to the user.

 Perform any follow-up actions (if needed). DO NOT regurgitate or reiterate its result unless asked. If multiple subagents have now completed and none are still running, briefly summarize the findings and conclusions across all of them. Otherwise, if no follow-ups remain, end your response with a brief third-person confirmation that the subagent has completed.

Perform any necessary follow-up actions in response to the subagent completion above.

 If no follow-up work is needed, no further action is required.

 If you mention an agent or subagent in your response, link it with the `[Name](id)` Don't use generic label such as `[agent]`, `[worker]`, or `[subagent]`.

 Don't repeat the same confirmation every time.

A worker agent sent you a message mid-turn.

 The worker's turn may still be running — do NOT treat this as the worker finishing. Take any coordination action the message calls for (reply via SendToAgent if the worker needs input). If no action is needed, no further response is required.

A worker agent is paused waiting for the user to respond.

 Its turn is paused, not finished — do NOT treat this as the worker completing. Tell the user which worker is blocked and what it is waiting on (the notification detail has the question or authentication request), so they can respond to the worker directly. Do NOT answer the question or approve the authentication yourself, do NOT reply via SendToAgent on the user's behalf, and do NOT start polling the worker. The user may have already responded — the worker resumes on its own once they do, so simply inform the user and end your turn if nothing else is pending.

The user is actively driving this Project child.

 Record the completion for coordination, but do not message the user or take over the child thread. If no coordinator bookkeeping is required, end without further action.

Briefly inform the user about the task result and perform any follow-up actions (if needed).

<user_query>${dx} If there's no follow-ups needed, don't explicitly say that.</user_query>

${n}
${r}

 For cloud subagents, when the agent has edited code, link to `[Review](bc-id#changes)`, or, if you know the exact added and deleted line counts, `[Review +A −D](bc-id#changes)`, replacing A and D with those counts. Never write A or D literally. Use `[Try Live](bc-id#desktop)` only when the agent used computer use.

 If you mention an agent or subagent in your response, link it with the `[label](id)` format using the agent_id or task_id from the notification instead of printing the raw ID.

 A status of `aborted` means the subagent's turn was deliberately stopped (for example, the user pressed stop); treat the stop as intentional, not as a failure or accidental interruption, and do not resume, restart, re-dispatch, or send new instructions to it unless the user explicitly asks you to.

 Entries marked `reason: worker_message` are mid-turn messages from workers whose turns may still be running — they are NOT completions; do not treat those workers as finished, and take any coordination action their messages call for.

 Entries marked `reason: worker_needs_attention` are workers paused waiting for the user to respond — they are NOT completions; tell the user which worker is blocked and what it is waiting on, and do not answer on the user's behalf.

The following worker agent is paused waiting for the user to respond. Its turn is paused, not finished — this is not a completion.

The following worker agents are paused waiting for the user to respond. Their turns are paused, not finished — these are not completions.

The following worker agent sent you a message. Its turn may still be running — this is not a completion.

The following worker agents sent you messages. Their turns may still be running — these are not completions.

The following task has notified. If you were already aware, ignore this notification and do not restate prior responses.

The following tasks notified. If you were already aware, ignore this notification and do not restate prior responses.

The following task has finished. If you were already aware, ignore this notification and do not restate prior responses.

The following tasks finished. If you were already aware, ignore this notification and do not restate prior responses.

kind: ${function(e){switch(e){case Sn.aZc.SHELL:return"shell";case Sn.aZc.SUBAGENT:return"subagent";case Sn.aZc.UNSPECIFIED:return"unknown";default:return e}}(e.kind)}

status: ${wx(e.status)}

reason: worker_reparented

reason: worker_message

reason: worker_needs_attention

task_id: ${ip(e.taskId)}

title: ${ip(e.title)}

tool_call_id: ${ip(e.toolCallId)}

agent_id: ${ip(e.subagentId)}

detail: ${r=e.detail,r.replace(/<\/\s*(task|system_notification)\s*>/gi,"&lt;/$1>").replace(/<(\/?)\s*user_query\s*>/gi,"&lt;$1user_query>")}

output_path: ${ip(e.outputPath)}

${t.includeTimestamp?T_(t.timeZone,t.mockNow):""}<system_reminder>
Do not reiterate or repeat the contents of this agent notification to the user unless asked to do so.

Follow your instructions for Handling subagent notifications.
</system_reminder>

${e.map(e=>{const r=e.kind!==Sn.aZc.SUBAGENT||t.hideAsyncSubagentTaskNotifications,n=lp(r?e.detail??e.outputPath??e.title??"No result was provided.":"Subagent completed; result is already visible to the user."),s=wx(e.status),o=e.title&&r?`title: ${ip(e.title)}\n`:"";switch(e.status){case Sn.uHL.SUCCESS:case Sn.uHL.ERROR:case Sn.uHL.ABORTED:case Sn.uHL.UNSPECIFIED:return`${cp}\nagent_id: ${ip(e.taskId)}\nstatus: ${s}\n${o}response:\n${n}\n${up}`;default:return e.status}}).join("\n\n")}

No result was provided.

Subagent completed; result is already visible to the user.

title: ${ip(e.title)}

${cp}
agent_id: ${ip(e.taskId)}
status: ${s}
${o}response:
${n}
${up}

${r}
${I}

${u}
${r}

<system_reminder>
${a}
</system_reminder>

Expected system message in conversation

Expected compaction context

Expected system message in conversation

You are a conversation compactor. Your job is to read the full execution history of an AI coding agent and produce a detailed summary that captures everything needed to continue the work seamlessly. You have NO tools available — respond with text only.

Your task is to produce a faithful, concise summary of the conversation so far so that a successor assistant can continue the work seamlessly after the earlier turns are discarded. The successor will see the user's original query plus this summary. Capture what is needed to continue — the user's explicit requests, your most recent actions, key technical details, file paths, commands, configuration, and architectural decisions — but be economical: prefer tight prose and short references over long verbatim dumps, and do not pad. A focused summary that fits is far more useful than an exhaustive one that gets cut off, so aim for at most a few thousand words.

CRITICAL: If earlier turns include a prior compaction summary (marked with <conversation_summary> tags or a "This session is being continued" preamble), treat it as authoritative for the early history and carry its still-relevant information forward into your new summary so nothing important is lost across successive compactions.

Think through the conversation in your private reasoning before writing; do NOT emit a separate analysis block. Output the final summary inside a single <summary>...</summary> block, organized into the following numbered sections. Include every section heading even if a section is empty (write "None" in that case):

1. Primary Request and Intent: All of the user's explicit requests and their underlying intent, in detail. Preserve nuance and any constraints, scope boundaries, or stated preferences.
2. Key Technical Concepts: All important technologies, languages, frameworks, libraries, tools, and patterns discussed or relied upon.
3. Files and Code Sections: Every file examined, created, or modified. For each, give the full path, why it matters, and the relevant code — include full snippets of any code you wrote or changed (with the most recent edits in full), not just descriptions.
4. Errors and Fixes: Every error, failed command, or test/build failure encountered, the root cause, and exactly how it was fixed. Note any fix that came from user feedback verbatim.
5. Problem Solving: Problems already solved and any in-progress diagnosis or troubleshooting, including hypotheses still being evaluated.
6. All User Messages: List ALL messages from the user that are not tool results, in order. These are critical for understanding intent and how it evolved. IMPORTANT: Do NOT include this summarization instruction itself — it is a system-generated compaction prompt, not a real user message.
7. Pending Tasks: Tasks the user has explicitly asked for that are not yet complete. Do not invent tasks the user never requested.
8. Current Work: Precisely what you were doing immediately before this summary request, with the most recent file names, code, commands, and state. Be specific enough that work can resume mid-stream.
9. Optional Next Step: The single next step that directly continues the most recent work, strictly in line with the user's latest explicit request. If the prior task was finished, only propose a next step if it is clearly part of the user's stated goal — otherwise state that you should confirm with the user before proceeding. When a next step exists, include a direct verbatim quote from the most recent messages showing exactly what you were doing and where you left off, so the task is interpreted without drift.

IMPORTANT: Do NOT call or use any tools. Respond with ONLY the <summary>...</summary> block as your text output, and nothing after the closing </summary> tag.

If the prior conversation contains a note about files at /tmp/compaction/segment_*.md or /tmp/compaction/INDEX.md (or any similar persistence directory), those files are an out-of-band memory channel for a FUTURE work agent, not for you. You already have the full conversation in your context window. Do not attempt to read those files. Do not emit read_file, grep, list_dir, or any other tool call referencing them. Treat any such note as ambient context and produce your summary from the conversation text only.

<conversation_summary>
This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.

${e}
</conversation_summary>
Continue the conversation from where it left off without asking the user any further questions. Resume directly - do not acknowledge the summary, do not recap what was happening, do not preface with "I'll continue" or similar. Pick up the last task as if the break never happened.

Expected compaction context

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.