feat: uloop cancel stops the tool the Editor is running, and the waiting CLI gets TOOL_CANCELLED

.agents/skills/uloop-cancel/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: uloop-cancel
+description: "Cancel the uloop command the Unity Editor for this project is running now. Use when BUSY keeps rejecting commands or your own command does not finish."
+---
+
+# uloop cancel
+
+Cancel the uloop command that holds the Editor's command slot, from another terminal or after the waiting command was given up on.
+
+## When to Use
+
+- Every command is rejected with `UNITY_SERVER_BUSY` and the running command shows no sign of finishing.
+- A command you started does not return, for example an `execute-dynamic-code` snippet that awaits something that never completes.
+
+## Usage
+
+```bash
+uloop cancel
+uloop cancel --project-path <path>
+```
+
+It takes no other options. It answers while Unity is busy and while a command blocks Unity's main thread.
+
+## Output
+
+Returns JSON with:
+
+- `Outcome`: what the cancel found
+- `RunningToolName`, `RunningToolElapsedSeconds`: the command that held the slot; `null` for `NothingRunning`
+- `Success`: `false` only for `NotCancellable`
+
+| Outcome | Meaning | Exit code |
+|---------|---------|-----------|
+| `Cancelled` | The running command was asked to stop | 0 |
+| `NothingRunning` | No command held the slot | 0 |
+| `NotCancellable` | The running command cannot be cancelled and keeps running | 1 |
+
+When Unity cannot be reached, the error goes to stderr, nothing goes to stdout, and it exits 1. A Unity package too old to support `uloop cancel` answers with a `UNITY_RPC_ERROR` naming the unknown command.
+
+## What Cannot Be Cancelled
+
+`NotCancellable` covers only these:
+
+- `compile` that waits for the domain reload (the default)
+- `run-tests --test-mode PlayMode --respect-enter-play-mode-settings`
+- a tool started by code inside the Editor (an extension or an Editor window), not by the CLI
+
+A default EditMode `run-tests` and `compile --no-wait-for-domain-reload` can be cancelled.
+
+## What the Waiting Command Gets
+
+- Most commands fail with `ErrorCode` `TOOL_CANCELLED` (not retryable).
+- `execute-dynamic-code` returns its usual cancelled result: `Success: false` with "Execution was cancelled or timed out".
+
+`Cancelled` also resumes Play Mode when the Editor is paused, whether a pause point or a manual pause holds it — the same as when the waiting CLI is killed.
+
+## After Cancelling
+
+Run `uloop status` and wait for `Ready` before the next command. `Cancelled` means the command was asked to stop, not that it already stopped:
+
+- A tool that ignores its cancellation token keeps the slot until it returns on its own.
+- `execute-dynamic-code` returns at once and frees the slot, but a snippet that ignores `ct` keeps running in the background.
+- While a command blocks Unity's main thread, `execute-dynamic-code` cannot return; its slot is freed about 5 seconds later, when another command arrives.

.agents/skills/uloop-execute-dynamic-code/references/cancellation.md

@@ -16,11 +16,12 @@ So a `CancellationToken` named `ct` is always in scope; use it without declaring
 - a domain reload starts,
 - the Unity Editor quits,
 - the uloop server inside the Editor stops or restarts,
-- the snippet was sent with `--yield-to-foreground-requests` and another `execute-dynamic-code` request arrives that it yields to.
+- the snippet was sent with `--yield-to-foreground-requests` and another `execute-dynamic-code` request arrives that it yields to,
+- `uloop cancel` is run while the snippet is running.
 
 ## Long awaits block other tool commands
 
-uloop runs one tool command at a time per Editor. While a snippet is awaiting, other tool commands against that Editor (such as `compile`, `get-logs`, or `run-tests`) are rejected as BUSY. An await that may never finish — waiting for an animation or a scripted sequence to complete, or for an external event — keeps the Editor BUSY for as long as it waits. `uloop status` still answers while a tool runs, so use it to check what is running.
+uloop runs one tool command at a time per Editor. While a snippet is awaiting, other tool commands against that Editor (such as `compile`, `get-logs`, or `run-tests`) are rejected as BUSY. An await that may never finish — waiting for an animation or a scripted sequence to complete, or for an external event — keeps the Editor BUSY for as long as it waits. `uloop status` still answers while a tool runs, so use it to check what is running. To stop a running snippet from another terminal, run `uloop cancel`.
 
 Another `execute-dynamic-code` is not rejected as BUSY: it returns `Success: false` with `ErrorMessage` "Another execution is already in progress". Since the next command an agent sends is often another snippet, treat that message as the sign that an earlier snippet is still awaiting.
 
@@ -58,6 +59,6 @@ uloop stops waiting for the snippet and frees the Editor for the next command. A
 
 What the CLI that sent the snippet sees depends on why `ct` fired:
 
-- Yielded to a foreground request: the connection is still open, so the CLI receives `Success: false` with `ErrorMessage` "Execution was cancelled or timed out".
+- Yielded to a foreground request, or stopped by `uloop cancel`: the connection is still open, so the CLI receives `Success: false` with `ErrorMessage` "Execution was cancelled or timed out".
 - The CLI disconnected: no response is sent; the CLI that was waiting is already gone.
 - Domain reload, Editor quit, or server stop/restart: no response arrives. The CLI treats it as a lost connection: after a domain reload it prints "Connection lost during execute-dynamic-code", waits for the Editor to come back, and then reports the disconnect as an error. Check the Editor with `uloop status` before sending the next command.

.agents/skills/uloop-pause-point/references/troubleshooting.md

@@ -24,7 +24,7 @@ A command that waits for a frame or a physics step cannot finish while the Edito
 
 `uloop pause-point-status` still answers while Unity is busy — use it to confirm a hit is holding the pause. Then recover either way:
 
-1. Stop the uloop process that is running the command (Ctrl-C in its terminal, otherwise interrupt or kill that process). Its request is cancelled and returns no result, the Editor pause is released, and the next command runs. This does not apply to every tool: a `run-tests` run that respects Enter Play Mode settings, and a `compile` that waits for a domain reload, are deliberately not cancelled when their client disconnects, so stopping the process leaves the pause in place — use step 2 for those.
+1. Run `uloop cancel` (it answers while Unity is busy). The running command is cancelled, the Editor pause is released, and the next command runs. This does not apply to every tool: a `run-tests` run that respects Enter Play Mode settings, and a `compile` that waits for a domain reload, are deliberately not cancellable, so `uloop cancel` reports `NotCancellable` and leaves the pause in place — use step 2 for those.
 2. Release the pause in the Editor (Edit > Play Mode > Pause). Frames resume, so the running command finishes and returns its result.
 
 Avoid the state instead: never start a frame-waiting snippet while a marker is armed or while the Editor is paused — starting it after the hit deadlocks the same way. Take the hit first (`await-pause-point`, or `enable-pause-point --await`) and inspect the capture; when you are done, resume play (`control-play-mode --action Resume` — the gate is free at that point) and only then run the frame-waiting snippet. While the pause holds, run only snippets that do not wait for a frame or a physics step.

.agents/skills/uloop-status/SKILL.md

@@ -52,6 +52,7 @@ Play Mode does not change the state: a paused Play Mode session is `Ready`, with
 ## Notes
 
 - Exits 0 only for Ready.
+- When `Busy` does not clear and the running command shows no sign of finishing, stop it with `uloop cancel`.
 - It never focuses the window, launches Unity, or takes the command slot, so it is safe to poll.
 - A sandboxed shell that cannot open the Unix socket gets an error, not NotRunning; run it outside the sandbox.
 - uloop cannot detect Safe Mode directly; ServerUnavailable that does not clear is the signal.

.claude/skills/uloop-cancel/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: uloop-cancel
+description: "Cancel the uloop command the Unity Editor for this project is running now. Use when BUSY keeps rejecting commands or your own command does not finish."
+---
+
+# uloop cancel
+
+Cancel the uloop command that holds the Editor's command slot, from another terminal or after the waiting command was given up on.
+
+## When to Use
+
+- Every command is rejected with `UNITY_SERVER_BUSY` and the running command shows no sign of finishing.
+- A command you started does not return, for example an `execute-dynamic-code` snippet that awaits something that never completes.
+
+## Usage
+
+```bash
+uloop cancel
+uloop cancel --project-path <path>
+```
+
+It takes no other options. It answers while Unity is busy and while a command blocks Unity's main thread.
+
+## Output
+
+Returns JSON with:
+
+- `Outcome`: what the cancel found
+- `RunningToolName`, `RunningToolElapsedSeconds`: the command that held the slot; `null` for `NothingRunning`
+- `Success`: `false` only for `NotCancellable`
+
+| Outcome | Meaning | Exit code |
+|---------|---------|-----------|
+| `Cancelled` | The running command was asked to stop | 0 |
+| `NothingRunning` | No command held the slot | 0 |
+| `NotCancellable` | The running command cannot be cancelled and keeps running | 1 |
+
+When Unity cannot be reached, the error goes to stderr, nothing goes to stdout, and it exits 1. A Unity package too old to support `uloop cancel` answers with a `UNITY_RPC_ERROR` naming the unknown command.
+
+## What Cannot Be Cancelled
+
+`NotCancellable` covers only these:
+
+- `compile` that waits for the domain reload (the default)
+- `run-tests --test-mode PlayMode --respect-enter-play-mode-settings`
+- a tool started by code inside the Editor (an extension or an Editor window), not by the CLI
+
+A default EditMode `run-tests` and `compile --no-wait-for-domain-reload` can be cancelled.
+
+## What the Waiting Command Gets
+
+- Most commands fail with `ErrorCode` `TOOL_CANCELLED` (not retryable).
+- `execute-dynamic-code` returns its usual cancelled result: `Success: false` with "Execution was cancelled or timed out".
+
+`Cancelled` also resumes Play Mode when the Editor is paused, whether a pause point or a manual pause holds it — the same as when the waiting CLI is killed.
+
+## After Cancelling
+
+Run `uloop status` and wait for `Ready` before the next command. `Cancelled` means the command was asked to stop, not that it already stopped:
+
+- A tool that ignores its cancellation token keeps the slot until it returns on its own.
+- `execute-dynamic-code` returns at once and frees the slot, but a snippet that ignores `ct` keeps running in the background.
+- While a command blocks Unity's main thread, `execute-dynamic-code` cannot return; its slot is freed about 5 seconds later, when another command arrives.

.claude/skills/uloop-execute-dynamic-code/references/cancellation.md

@@ -16,11 +16,12 @@ So a `CancellationToken` named `ct` is always in scope; use it without declaring
 - a domain reload starts,
 - the Unity Editor quits,
 - the uloop server inside the Editor stops or restarts,
-- the snippet was sent with `--yield-to-foreground-requests` and another `execute-dynamic-code` request arrives that it yields to.
+- the snippet was sent with `--yield-to-foreground-requests` and another `execute-dynamic-code` request arrives that it yields to,
+- `uloop cancel` is run while the snippet is running.
 
 ## Long awaits block other tool commands
 
-uloop runs one tool command at a time per Editor. While a snippet is awaiting, other tool commands against that Editor (such as `compile`, `get-logs`, or `run-tests`) are rejected as BUSY. An await that may never finish — waiting for an animation or a scripted sequence to complete, or for an external event — keeps the Editor BUSY for as long as it waits. `uloop status` still answers while a tool runs, so use it to check what is running.
+uloop runs one tool command at a time per Editor. While a snippet is awaiting, other tool commands against that Editor (such as `compile`, `get-logs`, or `run-tests`) are rejected as BUSY. An await that may never finish — waiting for an animation or a scripted sequence to complete, or for an external event — keeps the Editor BUSY for as long as it waits. `uloop status` still answers while a tool runs, so use it to check what is running. To stop a running snippet from another terminal, run `uloop cancel`.
 
 Another `execute-dynamic-code` is not rejected as BUSY: it returns `Success: false` with `ErrorMessage` "Another execution is already in progress". Since the next command an agent sends is often another snippet, treat that message as the sign that an earlier snippet is still awaiting.
 
@@ -58,6 +59,6 @@ uloop stops waiting for the snippet and frees the Editor for the next command. A
 
 What the CLI that sent the snippet sees depends on why `ct` fired:
 
-- Yielded to a foreground request: the connection is still open, so the CLI receives `Success: false` with `ErrorMessage` "Execution was cancelled or timed out".
+- Yielded to a foreground request, or stopped by `uloop cancel`: the connection is still open, so the CLI receives `Success: false` with `ErrorMessage` "Execution was cancelled or timed out".
 - The CLI disconnected: no response is sent; the CLI that was waiting is already gone.
 - Domain reload, Editor quit, or server stop/restart: no response arrives. The CLI treats it as a lost connection: after a domain reload it prints "Connection lost during execute-dynamic-code", waits for the Editor to come back, and then reports the disconnect as an error. Check the Editor with `uloop status` before sending the next command.

.claude/skills/uloop-pause-point/references/troubleshooting.md

@@ -24,7 +24,7 @@ A command that waits for a frame or a physics step cannot finish while the Edito
 
 `uloop pause-point-status` still answers while Unity is busy — use it to confirm a hit is holding the pause. Then recover either way:
 
-1. Stop the uloop process that is running the command (Ctrl-C in its terminal, otherwise interrupt or kill that process). Its request is cancelled and returns no result, the Editor pause is released, and the next command runs. This does not apply to every tool: a `run-tests` run that respects Enter Play Mode settings, and a `compile` that waits for a domain reload, are deliberately not cancelled when their client disconnects, so stopping the process leaves the pause in place — use step 2 for those.
+1. Run `uloop cancel` (it answers while Unity is busy). The running command is cancelled, the Editor pause is released, and the next command runs. This does not apply to every tool: a `run-tests` run that respects Enter Play Mode settings, and a `compile` that waits for a domain reload, are deliberately not cancellable, so `uloop cancel` reports `NotCancellable` and leaves the pause in place — use step 2 for those.
 2. Release the pause in the Editor (Edit > Play Mode > Pause). Frames resume, so the running command finishes and returns its result.
 
 Avoid the state instead: never start a frame-waiting snippet while a marker is armed or while the Editor is paused — starting it after the hit deadlocks the same way. Take the hit first (`await-pause-point`, or `enable-pause-point --await`) and inspect the capture; when you are done, resume play (`control-play-mode --action Resume` — the gate is free at that point) and only then run the frame-waiting snippet. While the pause holds, run only snippets that do not wait for a frame or a physics step.

.claude/skills/uloop-status/SKILL.md

@@ -52,6 +52,7 @@ Play Mode does not change the state: a paused Play Mode session is `Ready`, with
 ## Notes
 
 - Exits 0 only for Ready.
+- When `Busy` does not clear and the running command shows no sign of finishing, stop it with `uloop cancel`.
 - It never focuses the window, launches Unity, or takes the command slot, so it is safe to poll.
 - A sandboxed shell that cannot open the Unix socket gets an error, not NotRunning; run it outside the sandbox.
 - uloop cannot detect Safe Mode directly; ServerUnavailable that does not clear is the signal.

.github/workflows/dead-code.yml

@@ -49,4 +49,4 @@ jobs:
           --include-kept false
           --format table
           --fail-on high-confidence
-          --max-public-candidates 37
+          --max-public-candidates 38