main.js · part 236

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

File contents and all parts · All files

Optional cross-check summary when multiple checks were investigated in one turn.

Record structured CI investigation results for the Checks panel after subagent investigation completes. Call once per investigation turn with one finding per failing check and an optional overall summary. Does not modify the repo or storage; findings are read from this tool call by the UI.

Recorded CI investigation findings for the Checks panel.

Error recording CI findings: ${e.result.value.error}

Unknown CI investigation findings result

Unhandled result case: ${String(t)}

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

One or two keywords, or a short exact phrase in quotes, to search for in conversation titles and visible user/assistant message text. Every unquoted keyword must match the same conversation; use separate searches for additional keywords.

Maximum number of conversation results to return (1-100). Defaults to 20.

No matching conversations found.

Found ${e.hits.length} conversation${1===e.hits.length?"":"s"}:

${t+1}. [${kF[e.source]??"unknown"}] "${e.title}" (id: ${e.conversationId}, updated: ${r})

   snippet: ${e.snippet}

Additional matches were omitted because the result limit was reached.

The conversation search index is rebuilding; results may be incomplete.

Search stopped early; partial results were returned.

Search a fast local index of the user's local conversations and cached cloud agent conversations. Every unquoted keyword must match the same conversation, so queries with many keywords often return no results; run several searches with 1–2 keywords each instead. Use quotes only for a short exact phrase. Returns conversation IDs, titles, and short snippets—not full transcripts. Some cloud agent conversations may not be searchable.

Unexpected result case: ${n.result.case}

Conversation search failed: ${e.result.value.error}

Conversation search returned no result.

Unhandled result case: ${t}

Conversation search failed

... (line ${i} omitted)

... (lines ${i}-${a} omitted)

${function(e,t){const r={};for(const t of e){const e=t.relativeWorkspacePath??"";r[e]||(r[e]=[]),r[e].push(t)}let n="";for(const[e,s]of Object.entries(r))n+=`${QF(e,s,t)}\n`;return n}(n,r).trim()}

${QF(e,s,t)}

${i}${o.map(e=>function(e){const t=e.relativeWorkspacePath??"",r=e.range?.startPosition?.line??0,n=e.range?.endPosition?.line??0,s=e.detailedLines??[],o=[];for(const e of s.slice(0,10)){if(!e.isSignature)break;{const t=e.text.trim();if(""===t||"..."===t)continue;Number.isInteger(e.lineNumber)?o.push(`${String(e.lineNumber).padStart(5," ")}|${e.text}`):o.push(e.text)}}const i=[`path="${t}"`];o.length>0&&i.push('showSignaturesOnly="true"');r>0&&i.push(`startLine="${r}"`);n>0&&n!==r&&i.push(`endLine="${n}"`);const a=`<search_result ${i.join(" ")}>`,c="</search_result>";return o.length>0?`${a}\n${o.join("\n")}\n${c}`:`${a}${c}`}(e)).join("\n")}

${String(e.lineNumber).padStart(5," ")}|${e.text}

<search_result ${i.join(" ")}>

${a}
${o.join("\n")}
${c}

One sentence explanation as to why this tool is being used, and how it contributes to the goal.

A complete question about what you want to understand. Ask as if talking to a colleague: 'How does X work?', 'What happens when Y?', 'Where is Z handled?'

Prefix directory paths to limit search scope (single directory only, no glob patterns)

If true, only search pull requests and return no code results.

The number of results to return. Must be between 1 and ${r}.

The number of results to return. Defaults to ${r}. Do not specify a value larger than ${r}.

A complete question about what you want to understand. Ask as if talking to a colleague: 'How does X work?', 'What happens when Y?', 'Where is Z handled?'

Prefix directory paths to limit search scope (single directory only, no glob patterns)

The number of results to return. Must be between 1 and ${r}.

The number of results to return. Defaults to ${r}. Do not specify a value larger than ${r}.

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

`SemanticSearch`: semantic search that finds code by meaning, not exact text

Find snippets of code from the codebase most relevant to the search query.
This is a semantic search tool, so the query should ask for something semantically matching what is needed.
Ask a complete question about what you want to understand. Ask as if talking to a colleague: 'How does X work?', 'What happens when Y?', 'Where is Z handled?
If it makes sense to only search in particular directories, please specify them in the target_directories field (single directory only, no glob patterns).

`${t}`: semantic search that finds code by meaning, not exact text

### When to Use This Tool

Use `${t}` when you need to:
- Explore unfamiliar codebases
- Ask "how / where / what" questions to understand behavior
- Find code by meaning rather than exact text

### When NOT to Use

Skip `${t}` for:
1. Exact text matches (use `${r}`)
2. Reading known files (use `${n}`)
3. Simple symbol lookups (use `${r}`)
4. Find file by name (use `${yt(e,"GLOB")}`)

### Examples

<example>
  Query: "Where is interface MyInterface implemented in the frontend?"
<reasoning>
  Good: Complete question asking about implementation location with specific context (frontend).
</reasoning>
</example>

<example>
  Query: "Where do we encrypt user passwords before saving?"
<reasoning>
  Good: Clear question about a specific process with context about when it happens.
</reasoning>
</example>

<example>
  Query: "MyInterface frontend"
<reasoning>
  BAD: Too vague; use a specific question instead. This would be better as "Where is MyInterface used in the frontend?"
</reasoning>
</example>

<example>
  Query: "AuthService"
<reasoning>
  BAD: Single word searches should use `${r}` for exact text matching instead.
</reasoning>
</example>

<example>
  Query: "What is AuthService? How does AuthService work?"
<reasoning>
  BAD: Combines two separate queries. A single semantic search is not good at looking for multiple things in parallel. Split into separate parallel searches: like "What is AuthService?" and "How does AuthService work?"
</reasoning>
</example>

### Target Directories

- Provide ONE directory or file path; [] searches the whole repo. No globs or wildcards.
  Good:
  - ["backend/api/"]   - focus directory
  - ["src/components/Button.tsx"] - single file
  - [] - search everywhere when unsure
  BAD:
  - ["frontend/", "backend/"] - multiple paths
  - ["src/**/utils/**"] - globs
  - ["*.ts"] or ["**/*"] - wildcard paths

### Search Strategy

1. Start with exploratory queries - semantic search is powerful and often finds relevant context in one go. Begin broad with [] if you're not sure where relevant code is.
2. Review results; if a directory or file stands out, rerun with that as the target.
3. Break large questions into smaller ones (e.g. auth roles vs session storage).
4. For big files (>1K lines) run `${t}`, or `${r}` if you know the exact symbols you're looking for, scoped to that file instead of reading the entire file.

<example>
  Step 1: { "query": "How does user authentication work?", "target_directories": [], "explanation": "Find auth flow" }
  Step 2: Suppose results point to backend/auth/ → rerun:
          { "query": "Where are user roles checked?", "target_directories": ["backend/auth/"], "explanation": "Find role logic" }
<reasoning>
  Good strategy: Start broad to understand overall system, then narrow down to specific areas based on initial results.
</reasoning>
</example>

<example>
  Query: "How are websocket connections handled?"
  Target: ["backend/services/realtime.ts"]
<reasoning>
  Good: We know the answer is in this specific file, but the file is too large to read entirely, so we use semantic search to find the relevant parts.
</reasoning>
</example>

### Usage
- When full chunk contents are provided, avoid re-reading the exact same chunk contents using the ${n} tool.
- Sometimes, just the chunk signatures and not the full chunks will be shown. Chunk signatures are usually Class or Function signatures that chunks are contained in. Use the ${n} or ${r} tools to explore these chunks or files if you think they might be relevant.
- When reading chunks that weren't provided as full chunks (e.g. only as line ranges or signatures), you'll sometimes want to expand the chunk ranges to include the start of the file to see imports, expand the range to include lines from the signature, or expand the range to read multiple chunks from a file at once.

Unhandled version: ${e}

Unhandled version: ${e}

No codebase index found. Use other search tools.

Index invalid. Use other search tools.

Codebase search is unavailable for this conversation because the codebase index could not be found. Do not retry ${e}. Use ${t?.GREP?.name??"Grep"}, ${t?.GLOB?.name??"Glob"}, and ${t?.READ?.name??"Read"} instead.

The semantic search results are empty. Consider using a different search query or using grep search instead to find relevant results.

Error: ${t.value.errorMessage}

Unknown error