main.js · part 124

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

File contents and all parts · All files

Read rejected for ${r}

Invalid file: ${r}

Read failed for ${r}

Unknown read result for ${r}

Unhandled read result case: ${e}

shell or subagent

task id

shell id

When waiting further, avoid round 5-minute waits: prefer slices of 60–270s (keeps prompt cache warm) or 1200s+ (one cache miss buys a long wait).

When waiting further, avoid round 1-minute waits: prefer slices of up to ${t-30}s (keeps prompt cache warm) or ${4*t}s+ (one cache miss buys a long wait).

When waiting further, avoid round ${r}-minute waits: prefer slices of 60–${t-30}s (keeps prompt cache warm) or ${4*t}s+ (one cache miss buys a long wait).

When waiting further, avoid waiting ${function(e){const t=e/60;return Number.isInteger(t)?`${t}`:t.toFixed(1)}(r)}h or more: prefer slices of 60s-${r-1}m (keeps prompt cache warm). Size slices based on expected progress; when progress is unclear, exponential backoff is useful.

When waiting further, size slices based on expected progress. When progress is unclear, exponential backoff is useful.

Check or poll a backgrounded ${i} job. For work that does not have a ${a}, you can omit the ${l} arg to sleep for the full `block_until_ms` duration (prefer this over sleeping in the shell, because it renders nicely to the user). At the end of your turn, you will be notified about any unawaited jobs that completed. If you think a job completed (e.g. because you killed it), observe it with ${n} to skip the notification, because stale notifications can confuse the user.${r?`\n\nPrefer NOT to poll reflexively with ${n}. Multitask on independent work while backgrounded jobs run, or finish your turn and rely on the end-of-turn completion notification. Poll with ${n} only when one of the following is true:\n- Your very next step is blocked on this specific job's result and you have no other productive work to do${t?" (shell jobs only — never wait on a subagent)":""}, OR\n- The task requires close monitoring (see shell guidance below).${t?" Subagents are never a candidate for close monitoring.":""}`:`\n\nPrefer NOT to poll reflexively with ${n}. Multitask on independent work while backgrounded jobs run, or finish your turn and rely on the end-of-turn completion notification.`}
- Never poll a task whose tool result says it was "manually backgrounded by the user".${void 0===o||t?"":`\n- NEVER USE THIS TO POLL OR WAIT VACUOUSLY FOR A SUBAGENT LAUNCHED WITH THE ${o} TOOL — rely on the end-of-turn completion notification instead (it is delivered as soon as the subagent finishes; guessing a wait time is inefficient).`}${t?`\n- Subagents: never wait on a subagent with ${n}. Subagents are always notify-on-completion — multitask on independent work (or respond to the user if there is nothing else productive to do) and wait to be woken up. The only valid use of ${n} on a subagent is a non-blocking status check (\`block_until_ms: 0\`); never use it to block on the subagent finishing.`:""}${r?`\n- Shell: only poll with ${n} when the command requires close monitoring. Close monitoring means a long-running job that can silently hang, degrade, or need a course correction before it completes — e.g. training runs, eval runs, deployments, long builds, datagen pipelines, DB migrations, large data transfers. For fire-and-forget commands (tests, installs, dev servers/watchers, short scripts, etc.) the completion notification is enough — start them, keep working, and only poll with ${n} later if you end up blocked on the result.\n- Shell sanity check (regardless of close monitoring): when you spawn a command directly into the background (\`block_until_ms: 0\`), do a single status check by reading the output file to confirm the command didn't fail to start. This is a one-shot smoke check, not a polling loop.\n- Shell close-monitoring guidance (only applies in the close-monitoring case above):\n  - HARD STOPPING CONSTRAINT: once you've decided to actively poll, don't stop until (a) the job terminates, (b) the command reaches a healthy steady state (only for non-terminating commands, e.g. dev server/watcher), or (c) the command is hung — follow the hang guidance below.\n  - Waiting until a regex matches the output can be useful for e.g. known startup/status/error logs.\n  - Size \`block_until_ms\` to the command's expected runtime. ${c}\n  - Output file header has \`pid\` and \`running_for_ms\` (updated every 5000ms).\n  - When finished, footer with \`exit_code\` and \`elapsed_ms\` appears (regex only matches the body, not header/footer).\n  - If the command is taking longer than expected and appears hung (use judgment based on command type), kill the process if safe to do so using the pid in the header. If possible, fix the hang and proceed.`:""}

Prefer NOT to poll reflexively with ${n}. Multitask on independent work while backgrounded jobs run, or finish your turn and rely on the end-of-turn completion notification. Poll with ${n} only when one of the following is true:
- Your very next step is blocked on this specific job's result and you have no other productive work to do${t?" (shell jobs only — never wait on a subagent)":""}, OR
- The task requires close monitoring (see shell guidance below).${t?" Subagents are never a candidate for close monitoring.":""}

 (shell jobs only — never wait on a subagent)

 Subagents are never a candidate for close monitoring.

Prefer NOT to poll reflexively with ${n}. Multitask on independent work while backgrounded jobs run, or finish your turn and rely on the end-of-turn completion notification.

- NEVER USE THIS TO POLL OR WAIT VACUOUSLY FOR A SUBAGENT LAUNCHED WITH THE ${o} TOOL — rely on the end-of-turn completion notification instead (it is delivered as soon as the subagent finishes; guessing a wait time is inefficient).

- Subagents: never wait on a subagent with ${n}. Subagents are always notify-on-completion — multitask on independent work (or respond to the user if there is nothing else productive to do) and wait to be woken up. The only valid use of ${n} on a subagent is a non-blocking status check (`block_until_ms: 0`); never use it to block on the subagent finishing.

- Shell: only poll with ${n} when the command requires close monitoring. Close monitoring means a long-running job that can silently hang, degrade, or need a course correction before it completes — e.g. training runs, eval runs, deployments, long builds, datagen pipelines, DB migrations, large data transfers. For fire-and-forget commands (tests, installs, dev servers/watchers, short scripts, etc.) the completion notification is enough — start them, keep working, and only poll with ${n} later if you end up blocked on the result.
- Shell sanity check (regardless of close monitoring): when you spawn a command directly into the background (`block_until_ms: 0`), do a single status check by reading the output file to confirm the command didn't fail to start. This is a one-shot smoke check, not a polling loop.
- Shell close-monitoring guidance (only applies in the close-monitoring case above):
  - HARD STOPPING CONSTRAINT: once you've decided to actively poll, don't stop until (a) the job terminates, (b) the command reaches a healthy steady state (only for non-terminating commands, e.g. dev server/watcher), or (c) the command is hung — follow the hang guidance below.
  - Waiting until a regex matches the output can be useful for e.g. known startup/status/error logs.
  - Size `block_until_ms` to the command's expected runtime. ${c}
  - Output file header has `pid` and `running_for_ms` (updated every 5000ms).
  - When finished, footer with `exit_code` and `elapsed_ms` appears (regex only matches the body, not header/footer).
  - If the command is taking longer than expected and appears hung (use judgment based on command type), kill the process if safe to do so using the pid in the header. If possible, fix the hang and proceed.

Max sleep time to block before returning (in milliseconds). Required. Set to 0 for non-blocking status check. Must not exceed 7140000 (${i} minutes).

Max sleep time to block before returning (in milliseconds). Defaults to ${r}ms. Set to 0 for non-blocking status check. Must not exceed 7140000 (${i} minutes).

block_until_ms must be at most 7140000 (${i} minutes)

Optional shell id to poll. If omitted, this tool sleeps for the full block_until_ms duration and then returns. Required when block_until_ms is 0.

Optional shell or subagent id to poll. If omitted, this tool sleeps for the full block_until_ms duration and then returns. Required when block_until_ms is 0.

Optional shell id to poll. If omitted, this tool sleeps for the full block_until_ms duration and then returns. Required when block_until_ms is 0.

Block until the regex matches stdout/stderr stream (or task completes). Matches anywhere in the shell output, not just new output. Will not match terminal file headers or footers, e.g. exit_code. Accepts JavaScript regex patterns (compiled with the multiline `m` flag). Not supported for awaiting subagents: you MUST leave this argument unset.

Block until the regex matches stdout/stderr stream (or task completes). Matches anywhere in the shell output, not just new output. Will not match terminal file headers or footers, e.g. exit_code. Accepts JavaScript regex patterns (compiled with the multiline `m` flag).

Set this to true if you are waiting for subagent(s) to complete. Remember you should NOT be doing this and instead end your turn or do parallel work.

path must be a path to a terminal file

path must be a path to a terminal file

Use to sleep and check shell progress. Never sleep using shell.

Poll a background shell.

Poll a background ${t?"shell or subagent":"shell"} job. For work that does not have a ${t?"task id":"shell id"}, you can omit the ${t?"task_id":"shell_id"} arg to sleep for the full `block_until_ms` duration (prefer this over sleeping in the shell, because it renders nicely to the user).

Monitor backgrounded jobs as follows:
- Never poll a task whose tool result says it was "manually backgrounded by the user".
- When you spawn a command directly into the background (`block_until_ms: 0`), check status immediately by reading the output file to confirm the command didn't fail to start.
- Poll repeatedly to monitor by using this tool between checks (set `block_until_ms` to control how long to wait). If the file gets large, read from the end of the file to capture the latest content.
- Pick your polling intervals using best guess/judgment based on any knowledge you have about the command and its expected runtime, and any output from monitoring the job. When no new output, exponential backoff is a good strategy (e.g. 2000ms, 4000ms, 8000ms, 16000ms...), using educated guess for min and max wait.${r?"\n- Shell only guidance:\n  - Waiting until a regex matches the output can be useful for e.g. known startup/status/error logs.\n  - HARD STOPPING CONSTRAINT: Don't stop polling until (a) job terminates, (b) the command reaches a healthy steady state (only for non-terminating command, e.g. dev server/watcher), or (c) command is hung - follow guidance below.\n  - Output file header has `pid` and `running_for_ms` (updated every 5000ms).\n  - When finished, footer with `exit_code` and `elapsed_ms` appears (regex only matches the body, not header/footer).\n  - If taking longer than expected and the command seems like it is hung (use judgment based on type of command), kill the process if safe to do so using the pid that appears in the header. If possible, try to fix the hang and proceed.":""}

shell or subagent

task id

shell id

- Shell only guidance:
  - Waiting until a regex matches the output can be useful for e.g. known startup/status/error logs.
  - HARD STOPPING CONSTRAINT: Don't stop polling until (a) job terminates, (b) the command reaches a healthy steady state (only for non-terminating command, e.g. dev server/watcher), or (c) command is hung - follow guidance below.
  - Output file header has `pid` and `running_for_ms` (updated every 5000ms).
  - When finished, footer with `exit_code` and `elapsed_ms` appears (regex only matches the body, not header/footer).
  - If taking longer than expected and the command seems like it is hung (use judgment based on type of command), kill the process if safe to do so using the pid that appears in the header. If possible, try to fix the hang and proceed.

Unhandled version: ${t}

Must pass a task id or wait for a nonzero duration.

Regex awaiting is not available for subagents. Run Await without regex, or await a shell task id instead.

Awaiting subagent tasks requires a non-empty conversationId in the agent context

Awaiting subagent ids is not available in this environment (subagent executor resource is not registered).

Unknown legacy subagent await result

Unhandled legacy subagent result case: ${e}

Subagent not found

Failed to await subagent task

Unknown subagent await result

Unhandled subagent await result case: ${e}

Cannot await shell task: terminals folder is unavailable

Failed to read shell output

No shell found for id ${f}

Pattern matched: ${e.regexMatch??""}

Pattern did NOT match.

Slept briefly.

Slept for ${Math.max(1,Math.ceil(t/1e3))}s.

${t} Sleep released early: a new user message is arriving.

Task completed in ${(e.runtimeMs??BigInt(0)).toString()}ms with exit code: ${void 0!==r?String(r):"unknown"}.

Task complete.