daemon.cjs · part 322

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

File contents and all parts · All files

Failed to sync latest plan file todos

Backend plan write requires requestContext.env.artifactsFolder

CreatePlan name is required and must be non-empty when writing a backend plan file

Backend plan write permission denied: ${v2.error ?? v2.path}

Backend plan write failed: no space

Backend plan write failed: ${writeResult.result.value.error}

Backend plan write rejected: ${writeResult.result.value.reason}

Backend plan write failed: unknown result

Unhandled write result: ${String(_exhaustive)}

use strict

use strict

use strict

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

A detailed, concrete plan for accomplishing the user's request

A short 3-4 word name for the plan. IMPORTANT: This should only be provided on the FIRST CreatePlan call. On subsequent updates, this field will be ignored to keep the plan file name stable.

A 1-2 sentence high-level description of the plan that summarizes what will be accomplished

Unique identifier for the todo

Description of the todo task

Array of implementation todos

Name of the implementation phase

Todos within this phase

Implementation phases, each containing related todos

Must provide a non-empty 'plan' for plan creation

In project mode, 'phases' is required.

Invalid JSON

Invalid JSON

Invalid arguments: ${parsedArgs.error.message}

Missing result in create plan response

Plan file created at: 

You can read the plan contents from this file. If at any point you can no longer find it there, the user may have moved it to the workspace .cursor/plans/ directory.

To update this plan, use your file editing tools directly on this file. The provided to-dos have been added to the file as well in the frontmatter, and should be edited there. Do NOT call create_plan again to update the plan.

Plan created successfully

Error: ${result.value.error}

Unknown error

Unhandled result case: ${String(_exhaustiveCheck)}

UPDATING THE PLAN:
- This tool creates a NEW plan file each time it is called
- The plan file URI will be returned in the tool result
- To update an existing plan, read and edit the plan file directly using your file editing tools
- Do NOT call this tool again to update an existing plan

TASK ORGANIZATION (Project Mode):

Use 'phases' to organize implementation tasks into logical stages:
- Each phase has a 'name' and contains its own array of 'todos'
- Phases group related tasks into logical implementation stages
- Example phases: "Phase 1: Foundation", "Phase 2: Core Features", "Phase 3: Polish"
- Each todo within a phase needs a unique ID (e.g., "setup-auth") and descriptive content
- Todos should be clear, specific, and actionable tasks

TASK ORGANIZATION:

Use 'todos' for organizing implementation tasks:
- Each todo should be a clear, specific, and actionable task
- Each todo needs a unique ID (e.g., "setup-auth") and descriptive content
- If the plan is simple, provide just a few high-level todos or none at all

When creating your plan, provide, optionally, a structured list of implementation todos:
- Each todo should be a clear, specific, and actionable task that can be tracked and completed
- If the plan is simple, you should provide just a few high-level todos or none at all
- Each todo needs:
  - A clear, unique ID (e.g., "setup-auth", "implement-ui", "add-tests")
  - A descriptive content explaining what needs to be done

UPDATING THE PLAN:
- This tool creates a NEW plan file each time it is called
- The plan file URI will be returned in the tool result
- To update an existing plan, read and edit the plan file directly using your file editing tools
- Do NOT call this tool again to update an existing plan

TASK ORGANIZATION (Project Mode):

Use 'phases' to organize implementation tasks into logical stages:
- Each phase has a 'name' and contains its own array of 'todos'.
- Each todo within a phase should be a clear, specific, and actionable task.
- Each todo within a phase needs a unique ID (e.g., "setup-auth") and descriptive content.
- For implementation plans, provide phases and todos unless the change is truly trivial. If the plan is simple, provide just a few high-level todos.

TASK ORGANIZATION:

Use 'todos' for organizing implementation tasks:
- Each todo should be a clear, specific, and actionable task.
- Each todo needs a unique ID (e.g., "setup-auth") and descriptive content.
- For implementation plans, provide todos unless the change is truly trivial. If the plan is simple, provide just a few high-level todos.

TASK ORGANIZATION:

Use 'todos' for organizing implementation tasks:
- Each todo should be a clear, specific, and actionable task.
- Each todo needs a unique ID (e.g., "setup-auth") and descriptive content.
- For implementation plans, provide todos unless the change is truly trivial. If the plan is simple, provide just a few high-level todos.

Ask the user these questions and wait for the user's response prior to creating your plan.

Present these to the user using the ${askQuestionToolName} tool.

Use this tool to create a concise plan for accomplishing the user's request. This tool should be called at the end of the planning phase to finalize and store the plan.

The plan you create should be properly formatted in markdown, using appropriate sections and headers. The plan should be very concise and actionable, providing the minimum amount of detail for the user to understand and action the plan. It may be helpful to identify the most important couple files you will change, and existing code you will leverage. Cite specific file paths and essential snippets of code.${!isC15 && (planModePromptCitation ?? false) ? " When mentioning files, use markdown links with the full file path (for example, `[backend/src/foo.ts](backend/src/foo.ts)`)." : ""} IMPORTANT: Do NOT use markdown tables in plan content (they cannot be rendered for the user); use bullet lists instead. The first line MUST BE A TITLE for the plan formatted as a level 1 markdown heading.

${isC15 ? c15TaskOrganization : taskOrganizationDescription}

${isC15 ? c15UpdatePlan : updatePlanContent}

Additional guidelines:
- Avoid asking clarifying questions in the plan itself. Ask them before calling this tool. ${getClarifyingQuestionGuidance(allTools)}
- Todos help break down complex plans into manageable, trackable tasks
- Focus on high-level meaningful decisions rather than low-level implementation details
- A good plan is glanceable, not a wall of text.${enableCodeLineage === true ? `
- If your research uncovered deliberate design decisions, past reversions, or intentional tradeoffs (from CodeLineage or git history), surface these as constraints in your plan. Explain what the proposed changes preserve, what they deliberately change, and how they relate to those prior decisions.` : ""}${isC15 ? `
- The plan will FAIL if arguments aren't given in order of name, overview, plan, todos. Follow the argument ordering.` : ""}

 When mentioning files, use markdown links with the full file path (for example, `[backend/src/foo.ts](backend/src/foo.ts)`).

- If your research uncovered deliberate design decisions, past reversions, or intentional tradeoffs (from CodeLineage or git history), surface these as constraints in your plan. Explain what the proposed changes preserve, what they deliberately change, and how they relate to those prior decisions.

- The plan will FAIL if arguments aren't given in order of name, overview, plan, todos. Follow the argument ordering.

Use this tool to create the approval plan for accomplishing the user's request. This tool should be called at the end of the planning phase to finalize and store the plan.

The plan you create should be properly formatted in markdown, using appropriate sections and headers. The first line MUST BE A TITLE for the plan formatted as a level 1 markdown heading.${!isC15 && (planModePromptCitation ?? false) ? " When mentioning files, use markdown links with the full file path (for example, `[backend/src/foo.ts](backend/src/foo.ts)`)." : ""}

PLAN QUALITY REQUIREMENTS:
- Make the plan concise, specific, and executable without re-deciding the approach.
- Commit to one recommended implementation path; do not include unresolved questions, options, or TBDs.
- Name primary files, functions, components, configs, tests, schemas, and existing utilities or patterns to reuse when knowable.
- Include concrete implementation steps. Brief context is fine only when it supports those steps.
- Specify important defaults, boundaries, and validation criteria.
- Include verification: tests, commands, manual checks, or exact conditions that would trigger follow-up work.
- Keep the plan proportional to the request.

${isC15 ? refinedC15TaskOrganization : refinedTaskOrganizationDescription}

${isC15 ? c15UpdatePlan : updatePlanContent}

Additional guidelines:
- Do not put unresolved questions, options, or choices in the plan. Resolve them before calling this tool. ${getClarifyingQuestionGuidance(allTools)}
- Include low-level details only when they remove ambiguity, such as exact file placement, API names, config keys, schema fields, or validation commands.
- If the user's request is primarily explanatory or investigative and no code changes are planned, make that explicit. Do not invent implementation todos.
- Do not use emojis in the plan.${enableCodeLineage === true ? `
- If your research uncovered deliberate design decisions, past reversions, or intentional tradeoffs (from CodeLineage or git history), surface these as constraints in your plan. Explain what the proposed changes preserve, what they deliberately change, and how they relate to those prior decisions.` : ""}${isC15 ? `
- The plan will FAIL if arguments aren't given in order of name, overview, plan, todos. Follow the argument ordering.` : ""}

 When mentioning files, use markdown links with the full file path (for example, `[backend/src/foo.ts](backend/src/foo.ts)`).

- If your research uncovered deliberate design decisions, past reversions, or intentional tradeoffs (from CodeLineage or git history), surface these as constraints in your plan. Explain what the proposed changes preserve, what they deliberately change, and how they relate to those prior decisions.

- The plan will FAIL if arguments aren't given in order of name, overview, plan, todos. Follow the argument ordering.

Use this tool to create a concise plan for accomplishing the user's request. This tool should be called at the end of the planning phase to finalize and store the plan.

The plan you create should be properly formatted in markdown, using appropriate sections and headers. The plan should be very concise and actionable, providing the minimum amount of detail for the user to understand and action the plan. It may be helpful to identify the most important couple files you will change, and existing code you will leverage. Cite specific file paths and essential snippets of code. IMPORTANT: Do NOT use markdown tables in plan content (they cannot be rendered for the user); use bullet lists instead. The first line MUST BE A TITLE for the plan formatted as a level 1 markdown heading.

When creating your plan, provide, optionally, a structured list of implementation todos:
- Each todo should be a clear, specific, and actionable task that can be tracked and completed
- Each todo needs:
  - A clear, unique ID (e.g., "setup-auth", "implement-ui", "add-tests")
  - A descriptive content explaining what needs to be done

UPDATING THE PLAN:
- This tool creates a NEW plan file each time it is called
- The plan file URI will be returned in the tool result
- To update an existing plan, read and edit the plan file directly using your file editing tools
- Do NOT call this tool again to update an existing plan

Additional guidelines:
- Avoid asking clarifying questions in the plan itself. Ask them before calling this tool. ${getClarifyingQuestionGuidance(props.allTools)}
- Focus on high-level meaningful decisions rather than low-level implementation details

use strict

use strict