bump version to 0.9.1

chore(deps): update dependency katex to v0.16.44 (#204 )
* chore(deps): update dependency katex to v0.16.44 * chore: download vendored JS files --------- Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-08-13 23:42:25 -06:00 · 2026-03-28 20:32:20 -07:00 · 2026-03-28 20:31:00 -07:00 · 2026-03-28 20:30:23 -07:00 · 2026-03-28 20:28:06 -07:00 · 2026-03-28 20:24:53 -07:00
107 changed files with 2359 additions and 696 deletions
@@ -5,55 +5,40 @@
    "helpers:pinGitHubActionDigests",
    ":separateMajorReleases"
  ],
-  "labels": [
-    "dependencies"
+  "gitIgnoredAuthors": [
+    "41898282+github-actions[bot]@users.noreply.github.com"
  ],
+  "labels": ["dependencies"],
  "prConcurrentLimit": 5,
  "prHourlyLimit": 2,
-  "schedule": [
-    "before 9am on Monday"
-  ],
+  "schedule": ["before 9am on Monday"],
  "timezone": "America/New_York",
  "lockFileMaintenance": {
    "enabled": true,
-    "schedule": [
-      "before 9am on Monday"
-    ]
+    "schedule": ["before 9am on Monday"]
  },
  "customManagers": [
    {
      "customType": "regex",
      "description": "Track vendored KaTeX version",
-      "managerFilePatterns": [
-        "/pyproject\\.toml$/"
-      ],
-      "matchStrings": [
-        "katex-(?<currentValue>[\\d.]+)/"
-      ],
+      "managerFilePatterns": ["/pyproject\\.toml$/"],
+      "matchStrings": ["katex-(?<currentValue>[\\d.]+)/"],
      "depNameTemplate": "katex",
      "datasourceTemplate": "npm"
    },
    {
      "customType": "regex",
      "description": "Track vendored Highlight.js version",
-      "managerFilePatterns": [
-        "/pyproject\\.toml$/"
-      ],
-      "matchStrings": [
-        "hljs-(?<currentValue>[\\d.]+)/"
-      ],
+      "managerFilePatterns": ["/pyproject\\.toml$/"],
+      "matchStrings": ["hljs-(?<currentValue>[\\d.]+)/"],
      "depNameTemplate": "highlight.js",
      "datasourceTemplate": "npm"
    },
    {
      "customType": "regex",
      "description": "Track vendored Mermaid version",
-      "managerFilePatterns": [
-        "/pyproject\\.toml$/"
-      ],
-      "matchStrings": [
-        "mermaid-(?<currentValue>[\\d.]+)/"
-      ],
+      "managerFilePatterns": ["/pyproject\\.toml$/"],
+      "matchStrings": ["mermaid-(?<currentValue>[\\d.]+)/"],
      "depNameTemplate": "mermaid",
      "datasourceTemplate": "npm"
    }
@@ -62,14 +47,8 @@
    {
      "description": "LLM SDKs — always review manually",
      "groupName": "LLM SDKs",
-      "matchPackageNames": [
-        "openai",
-        "anthropic",
-        "mcp"
-      ],
-      "schedule": [
-        "before 9am on Monday"
-      ],
+      "matchPackageNames": ["openai", "anthropic", "mcp"],
+      "schedule": ["before 9am on Monday"],
      "automerge": false
    },
    {
@@ -83,73 +62,38 @@
        "httpx-sse",
        "pydantic"
      ],
-      "schedule": [
-        "before 9am on Wednesday"
-      ],
+      "schedule": ["before 9am on Wednesday"],
      "automerge": true,
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchUpdateTypes": ["patch"]
    },
    {
      "description": "Database layer",
      "groupName": "Database",
-      "matchPackageNames": [
-        "sqlalchemy",
-        "alembic",
-        "psycopg"
-      ],
-      "schedule": [
-        "before 9am on Wednesday"
-      ],
+      "matchPackageNames": ["sqlalchemy", "alembic", "psycopg"],
+      "schedule": ["before 9am on Wednesday"],
      "automerge": true,
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchUpdateTypes": ["patch"]
    },
    {
      "description": "Security-critical — always review manually",
      "groupName": "Security",
-      "matchPackageNames": [
-        "PyJWT",
-        "pyjwt",
-        "bcrypt"
-      ],
+      "matchPackageNames": ["PyJWT", "pyjwt", "bcrypt"],
      "automerge": false
    },
    {
      "description": "Infrastructure dependencies",
      "groupName": "Infrastructure",
-      "matchPackageNames": [
-        "structlog",
-        "redis",
-        "croniter",
-        "discord.py"
-      ],
-      "schedule": [
-        "before 9am on the first day of the month"
-      ],
+      "matchPackageNames": ["structlog", "redis", "croniter", "discord.py"],
+      "schedule": ["before 9am on the first day of the month"],
      "automerge": true,
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchUpdateTypes": ["patch"]
    },
    {
-      "description": "Vendored JS — requires manual file download after merge",
+      "description": "Vendored JS — CI workflow downloads files automatically",
      "groupName": "Vendored JS",
-      "matchPackageNames": [
-        "katex",
-        "highlight.js",
-        "mermaid"
-      ],
-      "schedule": [
-        "before 9am on the first day of the month"
-      ],
-      "automerge": false,
-      "prBodyNotes": [
-        "This PR updates version references only.",
-        "After merging, run `scripts/update-vendored-js.sh <lib> <version>` to download the actual files."
-      ]
+      "matchPackageNames": ["katex", "highlight.js", "mermaid"],
+      "schedule": ["before 9am on the first day of the month"],
+      "automerge": false
    },
    {
      "description": "Dev/test tooling",
@@ -162,46 +106,29 @@
        "pytest-cov",
        "pre-commit"
      ],
-      "schedule": [
-        "before 9am on the first day of the month"
-      ],
+      "schedule": ["before 9am on the first day of the month"],
      "automerge": true,
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchUpdateTypes": ["patch"]
    },
    {
      "description": "Docker base images",
      "groupName": "Docker Images",
-      "matchManagers": [
-        "dockerfile",
-        "docker-compose"
-      ],
-      "schedule": [
-        "before 9am on the first day of the month"
-      ],
+      "matchManagers": ["dockerfile", "docker-compose"],
+      "schedule": ["before 9am on the first day of the month"],
      "automerge": false
    },
    {
      "description": "TypeScript SDK dev dependencies",
      "groupName": "TypeScript SDK",
-      "matchFileNames": [
-        "sdk/typescript/**"
-      ],
-      "schedule": [
-        "before 9am on the first day of the month"
-      ],
+      "matchFileNames": ["sdk/typescript/**"],
+      "schedule": ["before 9am on the first day of the month"],
      "automerge": true,
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchUpdateTypes": ["patch"]
    },
    {
      "description": "GitHub Actions — group all action updates",
      "groupName": "GitHub Actions",
-      "matchManagers": [
-        "github-actions"
-      ],
+      "matchManagers": ["github-actions"],
      "automerge": false
    }
  ]
@@ -67,7 +67,7 @@ jobs:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
        with:
-          python-version: "3.12"
+          python-version: "3.14"
      - run: pip install -e ".[test,mq,postgres]"
      - run: pytest tests/ -m "not live" --storage-backend=postgresql -q
        env:
@@ -19,7 +19,7 @@ jobs:
          python-version: "3.14"
      - run: pip install build
      - run: python -m build
-      - uses: pypa/gh-action-pypi-publish@release/v1
+      - uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # release/v1

      - name: Create GitHub Release
        uses: softprops/action-gh-release@153bb8e04406b158c6c84fc1615b65b24149a1fe # v2
@@ -0,0 +1,86 @@
+name: Complete Vendored JS Updates
+
+# When Renovate bumps a vendored JS version in pyproject.toml, this
+# workflow downloads the actual files and commits them to the PR branch
+# so the PR is merge-ready without manual intervention.
+#
+# Note: the commit is made with GITHUB_TOKEN, so it won't re-trigger CI
+# automatically.  The reviewer should re-run CI once this workflow passes,
+# or Renovate's next rebase will trigger it.
+
+on:
+  pull_request:
+    paths:
+      - pyproject.toml
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: "PR number to update"
+        required: true
+        type: number
+
+permissions:
+  contents: write
+  pull-requests: read
+
+jobs:
+  vendor-js:
+    if: github.actor == 'renovate[bot]' || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Resolve PR head ref
+        id: ref
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            ref=$(gh pr view "${{ inputs.pr_number }}" --repo "${{ github.repository }}" --json headRefName -q .headRefName)
+          else
+            ref="${{ github.head_ref }}"
+          fi
+          echo "head_ref=${ref}" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          ref: ${{ steps.ref.outputs.head_ref }}
+
+      - name: Detect vendored JS changes
+        id: detect
+        run: |
+          updates=()
+          for lib in katex hljs mermaid; do
+            version=$(grep -oE "${lib}-[0-9.]+" pyproject.toml | head -1 | sed "s/${lib}-//")
+            [[ -z "$version" ]] && continue
+            [[ -d "turnstone/shared_static/${lib}-${version}" ]] && continue
+            updates+=("${lib}:${version}")
+          done
+          if [[ ${#updates[@]} -eq 0 ]]; then
+            echo "found=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "found=true" >> "$GITHUB_OUTPUT"
+            printf '%s\n' "${updates[@]}" > /tmp/updates.txt
+            echo "Libs to update:"
+            cat /tmp/updates.txt
+          fi
+
+      - name: Download vendored files
+        if: steps.detect.outputs.found == 'true'
+        run: |
+          while IFS=: read -r lib version; do
+            echo "::group::Updating ${lib} to ${version}"
+            bash scripts/update-vendored-js.sh "$lib" "$version"
+            echo "::endgroup::"
+          done < /tmp/updates.txt
+
+      - name: Commit and push
+        if: steps.detect.outputs.found == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add -A
+          if git diff --cached --quiet; then
+            echo "No changes to commit"
+            exit 0
+          fi
+          git commit -m "chore: download vendored JS files"
+          git push
@@ -8,7 +8,7 @@ FROM python:3.14-slim
 LABEL org.opencontainers.image.title="turnstone" \
      org.opencontainers.image.description="Multi-node AI orchestration platform"

-COPY --from=ghcr.io/astral-sh/uv:0.11.1 /uv /usr/local/bin/uv
+COPY --from=ghcr.io/astral-sh/uv:0.11.2 /uv /usr/local/bin/uv

 # System dependencies for psycopg (PostgreSQL client library)
 RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends libpq5 \
@@ -290,7 +290,7 @@ All entry points read `~/.config/turnstone/config.toml`. CLI flags override conf
 [api]
 base_url = "http://localhost:8000/v1"
 api_key = ""
-tavily_key = ""        # only needed for local/vLLM models without native search
+# tavily_key = ""      # only needed for local/vLLM models without native search

 [model]
 name = ""              # empty = auto-detect
@@ -452,9 +452,12 @@ after `/clear` or `/new` commands).
 {"type": "clear_ui"}
 ```

-**`cancelled`** -- the generation was cancelled by the user (via the Stop
-button or `POST /v1/api/cancel`). The client should finalize any in-progress
-assistant message with whatever partial content was streamed.
+**`cancelled`** -- a cancel request was acknowledged (via the Stop button or
+`POST /v1/api/cancel`). This signals that cancellation is in progress, not
+that it is complete. The worker thread may still be finishing — wait for
+`stream_end` before transitioning to a ready state. The client should clear
+any in-progress assistant rendering but not re-enable the send button until
+`stream_end` arrives.

 ```json
 {"type": "cancelled"}
@@ -793,23 +796,35 @@ containing the resumed session's messages.

 Cancels the active generation in a workstream. Sets a cooperative cancellation
 flag that is checked at multiple points in the generation loop (per streaming
-chunk, before tool execution, inside bash commands). The session transitions to
-`idle` state and preserves any partial content already streamed.
+chunk, before tool execution, inside bash commands). Also closes the underlying
+HTTP stream to the LLM provider, unblocking any pending read immediately.
+The session transitions to `idle` state and preserves any partial content
+already streamed.

 If the workstream is waiting for tool approval or plan review, the pending
 prompt is automatically denied/rejected to unblock the worker thread.

 Calling this endpoint when the workstream is already idle is a harmless no-op.

+**Force cancel:** When `force` is `true`, the server abandons the stuck worker
+thread immediately and transitions the workstream to `idle`. The abandoned
+thread continues to wind down in the background (killing any running
+subprocesses and exiting at the next cancellation checkpoint). During this
+wind-down it may emit a final `stream_end` event which the server suppresses
+for the orphaned thread. Use force cancel when cooperative cancel has not
+resolved within a few seconds — the web UI offers this as a "Force Stop"
+button automatically.
+
 **Request body:**

 ```json
-{"ws_id": "abc123"}
+{"ws_id": "abc123", "force": false}
 ```

 | Field  | Type   | Required | Description          |
 |--------|--------|----------|----------------------|
 | `ws_id`| string | yes      | Target workstream ID |
+| `force`| bool   | no       | Abandon stuck worker immediately (default: `false`) |

 **Response:**

@@ -91,7 +91,7 @@ turnstone/
    _config.py        Base ChannelConfig dataclass
    discord/          Discord adapter (bot, cog, views, streaming, config)
  shared_static/      Shared design system (base.css, auth.js, theme.js, toast.js, utils.js, kb.js)
-    katex-0.16.42/    Vendored KaTeX math rendering library (MIT, woff2 fonts)
+    katex-0.16.44/    Vendored KaTeX math rendering library (MIT, woff2 fonts)
  ui/
    colors.py         ANSI color constants with NO_COLOR support
    markdown.py       Streaming terminal markdown renderer (line-buffered)
@@ -40,12 +40,23 @@ running --> error : Exception during\ntool execution

 error --> thinking : New send() call\n_emit_state("thinking")

-thinking --> idle : cancel() called\n_emit_state("idle")
+thinking --> idle : cancel() called\nstream aborted\n_emit_state("idle")

 running --> idle : cancel() called\n_emit_state("idle")

 attention --> idle : cancel() unblocks\napproval/plan wait\n_emit_state("idle")

+note left of idle
+  **Cancel escalation:**
+  1. **Cooperative**: cancel() sets event + closes
+     SDK stream → worker exits at next checkpoint
+  2. **Force**: force=true abandons the worker
+     thread, emits stream_end immediately.
+     Orphaned thread still kills subprocesses
+     but skips message mutations (generation
+     counter prevents stale writes).
+end note
+
 note right of thinking
  **Emitted via:**
  session._emit_state(state)
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7896c6e041b6dbb89d034468fa980c8fe645df5eb969d45ef966ccc6399edac2
-size 200083
+oid sha256:7bf27afa267d5b8d6da38e83213ed1b8e87639d5105a0a1ccc2e5a4bf4d3b67e
+size 185282
@@ -75,7 +75,7 @@ Both `TurnstoneServer` (sync) and `AsyncTurnstoneServer` (async) expose:
 | | `approve(*, ws_id, approved, feedback, always)` | `StatusResponse` |
 | | `plan_feedback(*, ws_id, feedback)` | `StatusResponse` |
 | | `command(*, ws_id, command)` | `StatusResponse` |
-| | `cancel(ws_id)` | `StatusResponse` |
+| | `cancel(ws_id, *, force=False)` | `StatusResponse` |
 | **Streaming** | `stream_events(ws_id)` | `Iterator[ServerEvent]` |
 | | `stream_global_events()` | `Iterator[ServerEvent]` |
 | **High-level** | `send_and_wait(message, ws_id, *, timeout, on_event)` | `TurnResult` |
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "turnstone"
-version = "0.8.9"
+version = "0.9.1"
 description = "Multi-node AI orchestration platform with tool use, agent routing, and cluster simulation."
 readme = "README.md"
 license = "BUSL-1.1"
@@ -79,7 +79,7 @@ include = [
  "turnstone/console/static/*.js",
  "turnstone/shared_static/*.css",
  "turnstone/shared_static/*.js",
-  "turnstone/shared_static/katex-0.16.42/**/*",
+  "turnstone/shared_static/katex-0.16.44/**/*",
  "turnstone/shared_static/hljs-11.11.1/**/*",
  "turnstone/shared_static/mermaid-11.13.0/**/*",
  "turnstone/sdk/py.typed",
@@ -2,7 +2,7 @@
  "openapi": "3.1.0",
  "info": {
    "title": "turnstone Console API",
-    "version": "0.8.4",
+    "version": "0.9.0",
    "description": "Cluster-wide visibility and control across all turnstone nodes."
  },
  "paths": {
@@ -3002,7 +3002,7 @@
            "content": {
              "application/json": {
                "schema": {
-                  "$ref": "#/components/schemas/StatusResponse"
+                  "$ref": "#/components/schemas/DeleteSettingResponse"
                }
              }
            }
@@ -3453,6 +3453,126 @@
        }
      }
    },
+    "/v1/api/admin/tls/ca": {
+      "get": {
+        "summary": "CA status: initialization state, CN, cert count, cert inventory",
+        "operationId": "v1_api_admin_tls_ca_get",
+        "tags": [
+          "Admin"
+        ],
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    },
+    "/v1/api/admin/tls/ca.pem": {
+      "get": {
+        "summary": "Download CA root certificate (PEM format)",
+        "operationId": "v1_api_admin_tls_ca.pem_get",
+        "tags": [
+          "Admin"
+        ],
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    },
+    "/v1/api/admin/tls/certs": {
+      "get": {
+        "summary": "List all issued TLS certificates",
+        "operationId": "v1_api_admin_tls_certs_get",
+        "tags": [
+          "Admin"
+        ],
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    },
+    "/v1/api/admin/tls/certs/{domain}/renew": {
+      "post": {
+        "summary": "Force-renew a certificate by domain",
+        "operationId": "v1_api_admin_tls_certs_{domain}_renew_post",
+        "tags": [
+          "Admin"
+        ],
+        "parameters": [
+          {
+            "name": "domain",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success"
+          },
+          "404": {
+            "description": "Error 404",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Error 500",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/api/admin/tls/certs/{domain}": {
+      "delete": {
+        "summary": "Delete a certificate by domain",
+        "operationId": "v1_api_admin_tls_certs_{domain}_delete",
+        "tags": [
+          "Admin"
+        ],
+        "parameters": [
+          {
+            "name": "domain",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success"
+          },
+          "404": {
+            "description": "Error 404",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
    "/health": {
      "get": {
        "summary": "Console health check",
@@ -3507,6 +3627,34 @@
        "title": "StatusResponse",
        "type": "object"
      },
+      "DeleteSettingResponse": {
+        "description": "DELETE /v1/api/admin/settings/{key} response.",
+        "properties": {
+          "status": {
+            "default": "ok",
+            "examples": [
+              "ok"
+            ],
+            "title": "Status",
+            "type": "string"
+          },
+          "key": {
+            "description": "Dotted setting key that was reset",
+            "title": "Key",
+            "type": "string"
+          },
+          "default": {
+            "description": "Registry default value the setting reverted to",
+            "title": "Default"
+          }
+        },
+        "required": [
+          "key",
+          "default"
+        ],
+        "title": "DeleteSettingResponse",
+        "type": "object"
+      },
      "AuthLoginRequest": {
        "description": "POST /v1/api/auth/login request body.\n\nEither username+password or token must be provided.",
        "properties": {
@@ -2,7 +2,7 @@
  "openapi": "3.1.0",
  "info": {
    "title": "turnstone Server API",
-    "version": "0.8.4",
+    "version": "0.9.0",
    "description": "Single-node workstream management, chat interaction, and real-time streaming."
  },
  "paths": {
@@ -1223,6 +1223,12 @@
            "description": "Target workstream ID",
            "title": "Ws Id",
            "type": "string"
+          },
+          "force": {
+            "default": false,
+            "description": "Force cancel: abandon the stuck worker thread immediately. Use when cooperative cancel has not resolved within a few seconds.",
+            "title": "Force",
+            "type": "boolean"
          }
        },
        "required": [
@@ -20,6 +20,7 @@
      "dev": true,
      "license": "MIT",
      "optional": true,
+      "peer": true,
      "dependencies": {
        "@emnapi/wasi-threads": "1.2.0",
        "tslib": "^2.4.0"
@@ -32,6 +33,7 @@
      "dev": true,
      "license": "MIT",
      "optional": true,
+      "peer": true,
      "dependencies": {
        "tslib": "^2.4.0"
      }
@@ -43,6 +45,7 @@
      "dev": true,
      "license": "MIT",
      "optional": true,
+      "peer": true,
      "dependencies": {
        "tslib": "^2.4.0"
      }
@@ -55,26 +58,28 @@
      "license": "MIT"
    },
    "node_modules/@napi-rs/wasm-runtime": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.1.tgz",
-      "integrity": "sha512-p64ah1M1ld8xjWv3qbvFwHiFVWrq1yFvV4f7w+mzaqiR4IlSgkqhcRdHwsGgomwzBH51sRY4NEowLxnaBjcW/A==",
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.2.tgz",
+      "integrity": "sha512-sNXv5oLJ7ob93xkZ1XnxisYhGYXfaG9f65/ZgYuAu3qt7b3NadcOEhLvx28hv31PgX8SZJRYrAIPQilQmFpLVw==",
      "dev": true,
      "license": "MIT",
      "optional": true,
      "dependencies": {
-        "@emnapi/core": "^1.7.1",
-        "@emnapi/runtime": "^1.7.1",
        "@tybys/wasm-util": "^0.10.1"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
      }
    },
    "node_modules/@oxc-project/types": {
-      "version": "0.120.0",
-      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.120.0.tgz",
-      "integrity": "sha512-k1YNu55DuvAip/MGE1FTsIuU3FUCn6v/ujG9V7Nq5Df/kX2CWb13hhwD0lmJGMGqE+bE1MXvv9SZVnMzEXlWcg==",
+      "version": "0.122.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.122.0.tgz",
+      "integrity": "sha512-oLAl5kBpV4w69UtFZ9xqcmTi+GENWOcPF7FCrczTiBbmC0ibXxCwyvZGbO39rCVEuLGAZM84DH0pUIyyv/YJzA==",
      "dev": true,
      "license": "MIT",
      "funding": {
@@ -82,9 +87,9 @@
      }
    },
    "node_modules/@rolldown/binding-android-arm64": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.10.tgz",
-      "integrity": "sha512-jOHxwXhxmFKuXztiu1ORieJeTbx5vrTkcOkkkn2d35726+iwhrY1w/+nYY/AGgF12thg33qC3R1LMBF5tHTZHg==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.12.tgz",
+      "integrity": "sha512-pv1y2Fv0JybcykuiiD3qBOBdz6RteYojRFY1d+b95WVuzx211CRh+ytI/+9iVyWQ6koTh5dawe4S/yRfOFjgaA==",
      "cpu": [
        "arm64"
      ],
@@ -99,9 +104,9 @@
      }
    },
    "node_modules/@rolldown/binding-darwin-arm64": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.10.tgz",
-      "integrity": "sha512-gED05Teg/vtTZbIJBc4VNMAxAFDUPkuO/rAIyyxZjTj1a1/s6z5TII/5yMGZ0uLRCifEtwUQn8OlYzuYc0m70w==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.12.tgz",
+      "integrity": "sha512-cFYr6zTG/3PXXF3pUO+umXxt1wkRK/0AYT8lDwuqvRC+LuKYWSAQAQZjCWDQpAH172ZV6ieYrNnFzVVcnSflAg==",
      "cpu": [
        "arm64"
      ],
@@ -116,9 +121,9 @@
      }
    },
    "node_modules/@rolldown/binding-darwin-x64": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.10.tgz",
-      "integrity": "sha512-rI15NcM1mA48lqrIxVkHfAqcyFLcQwyXWThy+BQ5+mkKKPvSO26ir+ZDp36AgYoYVkqvMcdS8zOE6SeBsR9e8A==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.12.tgz",
+      "integrity": "sha512-ZCsYknnHzeXYps0lGBz8JrF37GpE9bFVefrlmDrAQhOEi4IOIlcoU1+FwHEtyXGx2VkYAvhu7dyBf75EJQffBw==",
      "cpu": [
        "x64"
      ],
@@ -133,9 +138,9 @@
      }
    },
    "node_modules/@rolldown/binding-freebsd-x64": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.10.tgz",
-      "integrity": "sha512-XZRXHdTa+4ME1MuDVp021+doQ+z6Ei4CCFmNc5/sKbqb8YmkiJdj8QKlV3rCI0AJtAeSB5n0WGPuJWNL9p/L2w==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.12.tgz",
+      "integrity": "sha512-dMLeprcVsyJsKolRXyoTH3NL6qtsT0Y2xeuEA8WQJquWFXkEC4bcu1rLZZSnZRMtAqwtrF/Ib9Ddtpa/Gkge9Q==",
      "cpu": [
        "x64"
      ],
@@ -150,9 +155,9 @@
      }
    },
    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.10.tgz",
-      "integrity": "sha512-R0SQMRluISSLzFE20sPWYHVmJdDQnRyc/FzSCN72BqQmh2SOZUFG+N3/vBZpR4C6WpEUVYJLrYUXaj43sJsNLA==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.12.tgz",
+      "integrity": "sha512-YqWjAgGC/9M1lz3GR1r1rP79nMgo3mQiiA+Hfo+pvKFK1fAJ1bCi0ZQVh8noOqNacuY1qIcfyVfP6HoyBRZ85Q==",
      "cpu": [
        "arm"
      ],
@@ -167,13 +172,16 @@
      }
    },
    "node_modules/@rolldown/binding-linux-arm64-gnu": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.10.tgz",
-      "integrity": "sha512-Y1reMrV/o+cwpduYhJuOE3OMKx32RMYCidf14y+HssARRmhDuWXJ4yVguDg2R/8SyyGNo+auzz64LnPK9Hq6jg==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.12.tgz",
+      "integrity": "sha512-/I5AS4cIroLpslsmzXfwbe5OmWvSsrFuEw3mwvbQ1kDxJ822hFHIx+vsN/TAzNVyepI/j/GSzrtCIwQPeKCLIg==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
+      "libc": [
+        "glibc"
+      ],
      "license": "MIT",
      "optional": true,
      "os": [
@@ -184,13 +192,16 @@
      }
    },
    "node_modules/@rolldown/binding-linux-arm64-musl": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.10.tgz",
-      "integrity": "sha512-vELN+HNb2IzuzSBUOD4NHmP9yrGwl1DVM29wlQvx1OLSclL0NgVWnVDKl/8tEks79EFek/kebQKnNJkIAA4W2g==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.12.tgz",
+      "integrity": "sha512-V6/wZztnBqlx5hJQqNWwFdxIKN0m38p8Jas+VoSfgH54HSj9tKTt1dZvG6JRHcjh6D7TvrJPWFGaY9UBVOaWPw==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
+      "libc": [
+        "musl"
+      ],
      "license": "MIT",
      "optional": true,
      "os": [
@@ -201,13 +212,16 @@
      }
    },
    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.10.tgz",
-      "integrity": "sha512-ZqrufYTgzxbHwpqOjzSsb0UV/aV2TFIY5rP8HdsiPTv/CuAgCRjM6s9cYFwQ4CNH+hf9Y4erHW1GjZuZ7WoI7w==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.12.tgz",
+      "integrity": "sha512-AP3E9BpcUYliZCxa3w5Kwj9OtEVDYK6sVoUzy4vTOJsjPOgdaJZKFmN4oOlX0Wp0RPV2ETfmIra9x1xuayFB7g==",
      "cpu": [
        "ppc64"
      ],
      "dev": true,
+      "libc": [
+        "glibc"
+      ],
      "license": "MIT",
      "optional": true,
      "os": [
@@ -218,13 +232,16 @@
      }
    },
    "node_modules/@rolldown/binding-linux-s390x-gnu": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.10.tgz",
-      "integrity": "sha512-gSlmVS1FZJSRicA6IyjoRoKAFK7IIHBs7xJuHRSmjImqk3mPPWbR7RhbnfH2G6bcmMEllCt2vQ/7u9e6bBnByg==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.12.tgz",
+      "integrity": "sha512-nWwpvUSPkoFmZo0kQazZYOrT7J5DGOJ/+QHHzjvNlooDZED8oH82Yg67HvehPPLAg5fUff7TfWFHQS8IV1n3og==",
      "cpu": [
        "s390x"
      ],
      "dev": true,
+      "libc": [
+        "glibc"
+      ],
      "license": "MIT",
      "optional": true,
      "os": [
@@ -235,13 +252,16 @@
      }
    },
    "node_modules/@rolldown/binding-linux-x64-gnu": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.10.tgz",
-      "integrity": "sha512-eOCKUpluKgfObT2pHjztnaWEIbUabWzk3qPZ5PuacuPmr4+JtQG4k2vGTY0H15edaTnicgU428XW/IH6AimcQw==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.12.tgz",
+      "integrity": "sha512-RNrafz5bcwRy+O9e6P8Z/OCAJW/A+qtBczIqVYwTs14pf4iV1/+eKEjdOUta93q2TsT/FI0XYDP3TCky38LMAg==",
      "cpu": [
        "x64"
      ],
      "dev": true,
+      "libc": [
+        "glibc"
+      ],
      "license": "MIT",
      "optional": true,
      "os": [
@@ -252,13 +272,16 @@
      }
    },
    "node_modules/@rolldown/binding-linux-x64-musl": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.10.tgz",
-      "integrity": "sha512-Xdf2jQbfQowJnLcgYfD/m0Uu0Qj5OdxKallD78/IPPfzaiaI4KRAwZzHcKQ4ig1gtg1SuzC7jovNiM2TzQsBXA==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.12.tgz",
+      "integrity": "sha512-Jpw/0iwoKWx3LJ2rc1yjFrj+T7iHZn2JDg1Yny1ma0luviFS4mhAIcd1LFNxK3EYu3DHWCps0ydXQ5i/rrJ2ig==",
      "cpu": [
        "x64"
      ],
      "dev": true,
+      "libc": [
+        "musl"
+      ],
      "license": "MIT",
      "optional": true,
      "os": [
@@ -269,9 +292,9 @@
      }
    },
    "node_modules/@rolldown/binding-openharmony-arm64": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.10.tgz",
-      "integrity": "sha512-o1hYe8hLi1EY6jgPFyxQgQ1wcycX+qz8eEbVmot2hFkgUzPxy9+kF0u0NIQBeDq+Mko47AkaFFaChcvZa9UX9Q==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.12.tgz",
+      "integrity": "sha512-vRugONE4yMfVn0+7lUKdKvN4D5YusEiPilaoO2sgUWpCvrncvWgPMzK00ZFFJuiPgLwgFNP5eSiUlv2tfc+lpA==",
      "cpu": [
        "arm64"
      ],
@@ -286,9 +309,9 @@
      }
    },
    "node_modules/@rolldown/binding-wasm32-wasi": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.10.tgz",
-      "integrity": "sha512-Ugv9o7qYJudqQO5Y5y2N2SOo6S4WiqiNOpuQyoPInnhVzCY+wi/GHltcLHypG9DEUYMB0iTB/huJrpadiAcNcA==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.12.tgz",
+      "integrity": "sha512-ykGiLr/6kkiHc0XnBfmFJuCjr5ZYKKofkx+chJWDjitX+KsJuAmrzWhwyOMSHzPhzOHOy7u9HlFoa5MoAOJ/Zg==",
      "cpu": [
        "wasm32"
      ],
@@ -303,9 +326,9 @@
      }
    },
    "node_modules/@rolldown/binding-win32-arm64-msvc": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.10.tgz",
-      "integrity": "sha512-7UODQb4fQUNT/vmgDZBl3XOBAIOutP5R3O/rkxg0aLfEGQ4opbCgU5vOw/scPe4xOqBwL9fw7/RP1vAMZ6QlAQ==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.12.tgz",
+      "integrity": "sha512-5eOND4duWkwx1AzCxadcOrNeighiLwMInEADT0YM7xeEOOFcovWZCq8dadXgcRHSf3Ulh1kFo/qvzoFiCLOL1Q==",
      "cpu": [
        "arm64"
      ],
@@ -320,9 +343,9 @@
      }
    },
    "node_modules/@rolldown/binding-win32-x64-msvc": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.10.tgz",
-      "integrity": "sha512-PYxKHMVHOb5NJuDL53vBUl1VwUjymDcYI6rzpIni0C9+9mTiJedvUxSk7/RPp7OOAm3v+EjgMu9bIy3N6b408w==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.12.tgz",
+      "integrity": "sha512-PyqoipaswDLAZtot351MLhrlrh6lcZPo2LSYE+VDxbVk24LVKAGOuE4hb8xZQmrPAuEtTZW8E6D2zc5EUZX4Lw==",
      "cpu": [
        "x64"
      ],
@@ -337,9 +360,9 @@
      }
    },
    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.10.tgz",
-      "integrity": "sha512-UkVDEFk1w3mveXeKgaTuYfKWtPbvgck1dT8TUG3bnccrH0XtLTuAyfCoks4Q/M5ZGToSVJTIQYCzy2g/atAOeg==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.12.tgz",
+      "integrity": "sha512-HHMwmarRKvoFsJorqYlFeFRzXZqCt2ETQlEDOb9aqssrnVBB1/+xgTGtuTrIk5vzLNX1MjMtTf7W9z3tsSbrxw==",
      "dev": true,
      "license": "MIT"
    },
@@ -387,31 +410,31 @@
      "license": "MIT"
    },
    "node_modules/@vitest/expect": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.1.tgz",
-      "integrity": "sha512-xAV0fqBTk44Rn6SjJReEQkHP3RrqbJo6JQ4zZ7/uVOiJZRarBtblzrOfFIZeYUrukp2YD6snZG6IBqhOoHTm+A==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.2.tgz",
+      "integrity": "sha512-gbu+7B0YgUJ2nkdsRJrFFW6X7NTP44WlhiclHniUhxADQJH5Szt9mZ9hWnJPJ8YwOK5zUOSSlSvyzRf0u1DSBQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@standard-schema/spec": "^1.1.0",
        "@types/chai": "^5.2.2",
-        "@vitest/spy": "4.1.1",
-        "@vitest/utils": "4.1.1",
+        "@vitest/spy": "4.1.2",
+        "@vitest/utils": "4.1.2",
        "chai": "^6.2.2",
-        "tinyrainbow": "^3.0.3"
+        "tinyrainbow": "^3.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/@vitest/mocker": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.1.tgz",
-      "integrity": "sha512-h3BOylsfsCLPeceuCPAAJ+BvNwSENgJa4hXoXu4im0bs9Lyp4URc4JYK4pWLZ4pG/UQn7AT92K6IByi6rE6g3A==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.2.tgz",
+      "integrity": "sha512-Ize4iQtEALHDttPRCmN+FKqOl2vxTiNUhzobQFFt/BM1lRUTG7zRCLOykG/6Vo4E4hnUdfVLo5/eqKPukcWW7Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@vitest/spy": "4.1.1",
+        "@vitest/spy": "4.1.2",
        "estree-walker": "^3.0.3",
        "magic-string": "^0.30.21"
      },
@@ -432,26 +455,26 @@
      }
    },
    "node_modules/@vitest/pretty-format": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.1.tgz",
-      "integrity": "sha512-GM+TEQN5WhOygr1lp7skeVjdLPqqWMHsfzXrcHAqZJi/lIVh63H0kaRCY8MDhNWikx19zBUK8ceaLB7X5AH9NQ==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.2.tgz",
+      "integrity": "sha512-dwQga8aejqeuB+TvXCMzSQemvV9hNEtDDpgUKDzOmNQayl2OG241PSWeJwKRH3CiC+sESrmoFd49rfnq7T4RnA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "tinyrainbow": "^3.0.3"
+        "tinyrainbow": "^3.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/@vitest/runner": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.1.tgz",
-      "integrity": "sha512-f7+FPy75vN91QGWsITueq0gedwUZy1fLtHOCMeQpjs8jTekAHeKP80zfDEnhrleviLHzVSDXIWuCIOFn3D3f8A==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.2.tgz",
+      "integrity": "sha512-Gr+FQan34CdiYAwpGJmQG8PgkyFVmARK8/xSijia3eTFgVfpcpztWLuP6FttGNfPLJhaZVP/euvujeNYar36OQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@vitest/utils": "4.1.1",
+        "@vitest/utils": "4.1.2",
        "pathe": "^2.0.3"
      },
      "funding": {
@@ -459,14 +482,14 @@
      }
    },
    "node_modules/@vitest/snapshot": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.1.tgz",
-      "integrity": "sha512-kMVSgcegWV2FibXEx9p9WIKgje58lcTbXgnJixfcg15iK8nzCXhmalL0ZLtTWLW9PH1+1NEDShiFFedB3tEgWg==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.2.tgz",
+      "integrity": "sha512-g7yfUmxYS4mNxk31qbOYsSt2F4m1E02LFqO53Xpzg3zKMhLAPZAjjfyl9e6z7HrW6LvUdTwAQR3HHfLjpko16A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@vitest/pretty-format": "4.1.1",
-        "@vitest/utils": "4.1.1",
+        "@vitest/pretty-format": "4.1.2",
+        "@vitest/utils": "4.1.2",
        "magic-string": "^0.30.21",
        "pathe": "^2.0.3"
      },
@@ -475,9 +498,9 @@
      }
    },
    "node_modules/@vitest/spy": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.1.tgz",
-      "integrity": "sha512-6Ti/KT5OVaiupdIZEuZN7l3CZcR0cxnxt70Z0//3CtwgObwA6jZhmVBA3yrXSVN3gmwjgd7oDNLlsXz526gpRA==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.2.tgz",
+      "integrity": "sha512-DU4fBnbVCJGNBwVA6xSToNXrkZNSiw59H8tcuUspVMsBDBST4nfvsPsEHDHGtWRRnqBERBQu7TrTKskmjqTXKA==",
      "dev": true,
      "license": "MIT",
      "funding": {
@@ -485,15 +508,15 @@
      }
    },
    "node_modules/@vitest/utils": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.1.tgz",
-      "integrity": "sha512-cNxAlaB3sHoCdL6pj6yyUXv9Gry1NHNg0kFTXdvSIZXLHsqKH7chiWOkwJ5s5+d/oMwcoG9T0bKU38JZWKusrQ==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.2.tgz",
+      "integrity": "sha512-xw2/TiX82lQHA06cgbqRKFb5lCAy3axQ4H4SoUFhUsg+wztiet+co86IAMDtF6Vm1hc7J6j09oh/rgDn+JdKIQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@vitest/pretty-format": "4.1.1",
+        "@vitest/pretty-format": "4.1.2",
        "convert-source-map": "^2.0.0",
-        "tinyrainbow": "^3.0.3"
+        "tinyrainbow": "^3.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
@@ -739,6 +762,9 @@
        "arm64"
      ],
      "dev": true,
+      "libc": [
+        "glibc"
+      ],
      "license": "MPL-2.0",
      "optional": true,
      "os": [
@@ -760,6 +786,9 @@
        "arm64"
      ],
      "dev": true,
+      "libc": [
+        "musl"
+      ],
      "license": "MPL-2.0",
      "optional": true,
      "os": [
@@ -781,6 +810,9 @@
        "x64"
      ],
      "dev": true,
+      "libc": [
+        "glibc"
+      ],
      "license": "MPL-2.0",
      "optional": true,
      "os": [
@@ -802,6 +834,9 @@
        "x64"
      ],
      "dev": true,
+      "libc": [
+        "musl"
+      ],
      "license": "MPL-2.0",
      "optional": true,
      "os": [
@@ -916,6 +951,7 @@
      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
      "dev": true,
+      "license": "MIT",
      "engines": {
        "node": ">=12"
      },
@@ -953,14 +989,14 @@
      }
    },
    "node_modules/rolldown": {
-      "version": "1.0.0-rc.10",
-      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.10.tgz",
-      "integrity": "sha512-q7j6vvarRFmKpgJUT8HCAUljkgzEp4LAhPlJUvQhA5LA1SUL36s5QCysMutErzL3EbNOZOkoziSx9iZC4FddKA==",
+      "version": "1.0.0-rc.12",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.12.tgz",
+      "integrity": "sha512-yP4USLIMYrwpPHEFB5JGH1uxhcslv6/hL0OyvTuY+3qlOSJvZ7ntYnoWpehBxufkgN0cvXxppuTu5hHa/zPh+A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@oxc-project/types": "=0.120.0",
-        "@rolldown/pluginutils": "1.0.0-rc.10"
+        "@oxc-project/types": "=0.122.0",
+        "@rolldown/pluginutils": "1.0.0-rc.12"
      },
      "bin": {
        "rolldown": "bin/cli.mjs"
@@ -969,21 +1005,21 @@
        "node": "^20.19.0 || >=22.12.0"
      },
      "optionalDependencies": {
-        "@rolldown/binding-android-arm64": "1.0.0-rc.10",
-        "@rolldown/binding-darwin-arm64": "1.0.0-rc.10",
-        "@rolldown/binding-darwin-x64": "1.0.0-rc.10",
-        "@rolldown/binding-freebsd-x64": "1.0.0-rc.10",
-        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.10",
-        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.10",
-        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.10",
-        "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.10",
-        "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.10",
-        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.10",
-        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.10",
-        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.10",
-        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.10",
-        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.10",
-        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.10"
+        "@rolldown/binding-android-arm64": "1.0.0-rc.12",
+        "@rolldown/binding-darwin-arm64": "1.0.0-rc.12",
+        "@rolldown/binding-darwin-x64": "1.0.0-rc.12",
+        "@rolldown/binding-freebsd-x64": "1.0.0-rc.12",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.12",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.12",
+        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.12",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.12",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.12",
+        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.12",
+        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.12",
+        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.12",
+        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.12",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.12",
+        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.12"
      }
    },
    "node_modules/siginfo": {
@@ -1084,16 +1120,16 @@
      }
    },
    "node_modules/vite": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.1.tgz",
-      "integrity": "sha512-wt+Z2qIhfFt85uiyRt5LPU4oVEJBXj8hZNWKeqFG4gRG/0RaRGJ7njQCwzFVjO+v4+Ipmf5CY7VdmZRAYYBPHw==",
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.3.tgz",
+      "integrity": "sha512-B9ifbFudT1TFhfltfaIPgjo9Z3mDynBTJSUYxTjOQruf/zHH+ezCQKcoqO+h7a9Pw9Nm/OtlXAiGT1axBgwqrQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "lightningcss": "^1.32.0",
-        "picomatch": "^4.0.3",
+        "picomatch": "^4.0.4",
        "postcss": "^8.5.8",
-        "rolldown": "1.0.0-rc.10",
+        "rolldown": "1.0.0-rc.12",
        "tinyglobby": "^0.2.15"
      },
      "bin": {
@@ -1162,19 +1198,19 @@
      }
    },
    "node_modules/vitest": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.1.tgz",
-      "integrity": "sha512-yF+o4POL41rpAzj5KVILUxm1GCjKnELvaqmU9TLLUbMfDzuN0UpUR9uaDs+mCtjPe+uYPksXDRLQGGPvj1cTmA==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.2.tgz",
+      "integrity": "sha512-xjR1dMTVHlFLh98JE3i/f/WePqJsah4A0FK9cc8Ehp9Udk0AZk6ccpIZhh1qJ/yxVWRZ+Q54ocnD8TXmkhspGg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "@vitest/expect": "4.1.1",
-        "@vitest/mocker": "4.1.1",
-        "@vitest/pretty-format": "4.1.1",
-        "@vitest/runner": "4.1.1",
-        "@vitest/snapshot": "4.1.1",
-        "@vitest/spy": "4.1.1",
-        "@vitest/utils": "4.1.1",
+        "@vitest/expect": "4.1.2",
+        "@vitest/mocker": "4.1.2",
+        "@vitest/pretty-format": "4.1.2",
+        "@vitest/runner": "4.1.2",
+        "@vitest/snapshot": "4.1.2",
+        "@vitest/spy": "4.1.2",
+        "@vitest/utils": "4.1.2",
        "es-module-lexer": "^2.0.0",
        "expect-type": "^1.3.0",
        "magic-string": "^0.30.21",
@@ -1185,7 +1221,7 @@
        "tinybench": "^2.9.0",
        "tinyexec": "^1.0.2",
        "tinyglobby": "^0.2.15",
-        "tinyrainbow": "^3.0.3",
+        "tinyrainbow": "^3.1.0",
        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
        "why-is-node-running": "^2.3.0"
      },
@@ -1202,10 +1238,10 @@
        "@edge-runtime/vm": "*",
        "@opentelemetry/api": "^1.9.0",
        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
-        "@vitest/browser-playwright": "4.1.1",
-        "@vitest/browser-preview": "4.1.1",
-        "@vitest/browser-webdriverio": "4.1.1",
-        "@vitest/ui": "4.1.1",
+        "@vitest/browser-playwright": "4.1.2",
+        "@vitest/browser-preview": "4.1.2",
+        "@vitest/browser-webdriverio": "4.1.2",
+        "@vitest/ui": "4.1.2",
        "happy-dom": "*",
        "jsdom": "*",
        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
@@ -93,10 +93,13 @@ export class TurnstoneServer extends BaseClient {
    });
  }

-  async cancel(wsId: string): Promise<StatusResponse> {
-    return this.request("POST", "/v1/api/cancel", {
-      json: { ws_id: wsId },
-    });
+  async cancel(
+    wsId: string,
+    opts?: { force?: boolean },
+  ): Promise<StatusResponse> {
+    const body: Record<string, unknown> = { ws_id: wsId };
+    if (opts?.force) body.force = true;
+    return this.request("POST", "/v1/api/cancel", { json: body });
  }

  // -- Streaming ------------------------------------------------------------
@@ -39,7 +39,13 @@ def _make_bridge(**overrides) -> Bridge:
        approval_timeout=1,
    )
    defaults.update(overrides)
-    return Bridge(**defaults)
+    bridge = Bridge(**defaults)
+    # Replace real httpx client with a mock so daemon threads spawned by
+    # _handle_approval / _handle_plan_review don't make real HTTP calls
+    # after the test's patch context exits.
+    bridge._http.close()
+    bridge._http = MagicMock()
+    return bridge


 def _approval_items(tool_name: str = "bash") -> list[dict]:
@@ -1,5 +1,6 @@
 """Tests for generation cancellation (cooperative cancel via threading.Event)."""

+import contextlib
 import threading
 import time
 from dataclasses import dataclass, field
@@ -7,7 +8,7 @@ from unittest.mock import MagicMock, patch

 import pytest

-from turnstone.core.session import ChatSession, GenerationCancelled
+from turnstone.core.session import ChatSession, GenerationCancelled, _CancelRef


 class NullUI:
@@ -407,3 +408,402 @@ class TestStreamFlushBeforeToolCalls:
        stream_end_idx = next(i for i, e in enumerate(events) if e[0] == "stream_end")
        late_content = [e for e in events[stream_end_idx + 1 :] if e[0] == "content"]
        assert late_content == [], f"Content after stream_end: {late_content}"
+
+
+class TestStreamAbort:
+    """Tests for cancel() closing the underlying SDK stream."""
+
+    def test_cancel_closes_cancel_stream(self, tmp_db):
+        """cancel() calls .close() on the stored SDK stream handle."""
+        session = _make_session()
+        mock_stream = MagicMock()
+        session._cancel_stream = mock_stream
+        session.cancel()
+        mock_stream.close.assert_called_once()
+        assert session._cancel_event.is_set()
+
+    def test_cancel_without_stream_is_safe(self, tmp_db):
+        """cancel() with no active stream just sets the event."""
+        session = _make_session()
+        assert session._cancel_stream is None
+        session.cancel()  # Should not raise
+        assert session._cancel_event.is_set()
+
+    def test_cancel_stream_close_error_suppressed(self, tmp_db):
+        """Errors from stream.close() are suppressed."""
+        session = _make_session()
+        mock_stream = MagicMock()
+        mock_stream.close.side_effect = RuntimeError("already closed")
+        session._cancel_stream = mock_stream
+        session.cancel()  # Should not raise
+        assert session._cancel_event.is_set()
+
+    def test_cancel_ref_populated_after_first_chunk(self, tmp_db):
+        """_cancel_ref is populated by the provider after the first chunk
+        arrives (lazy generator evaluation)."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = "stop"
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        sdk_stream = MagicMock()
+
+        def fake_provider_stream():
+            # Simulate provider appending to cancel_ref before first yield
+            session._cancel_ref.append(sdk_stream)
+            yield FakeChunk(content_delta="hi", finish_reason="stop")
+
+        with (
+            patch.object(
+                session,
+                "_create_stream_with_retry",
+                return_value=fake_provider_stream(),
+            ),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+            session.send("test")
+
+        # After stream completes, cancel_stream should be cleared
+        assert session._cancel_stream is None
+        assert len(session._cancel_ref) == 0
+
+    def test_transport_error_during_cancel_becomes_generation_cancelled(self, tmp_db):
+        """When cancel() closes the stream, the resulting transport error
+        is converted to GenerationCancelled."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = ""
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        def stream_that_errors():
+            yield FakeChunk(content_delta="Hello")
+            session._cancel_event.set()
+            raise ConnectionError("stream closed")
+
+        with (
+            patch.object(
+                session,
+                "_create_stream_with_retry",
+                return_value=stream_that_errors(),
+            ),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+            session.send("test")
+
+        # Should complete as cancelled, not error
+        assert "idle" in ui.states
+        assert any("cancelled" in i.lower() for i in ui.infos)
+        # Partial content preserved
+        assistant_msgs = [m for m in session.messages if m["role"] == "assistant"]
+        assert len(assistant_msgs) == 1
+        assert assistant_msgs[0]["content"] == "Hello"
+
+    def test_non_cancel_exception_not_swallowed(self, tmp_db):
+        """Exceptions during streaming that aren't caused by cancel
+        should propagate normally."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = ""
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        def stream_that_errors():
+            yield FakeChunk(content_delta="Hello")
+            raise ValueError("unexpected error")
+
+        with (
+            patch.object(
+                session,
+                "_create_stream_with_retry",
+                return_value=stream_that_errors(),
+            ),
+            patch.object(session, "_full_messages", return_value=[]),
+            pytest.raises(ValueError, match="unexpected error"),
+        ):
+            session.send("test")
+
+    def test_check_cancelled_between_retries(self, tmp_db):
+        """_try_stream checks for cancellation between retry attempts."""
+        session = _make_session()
+        session.cancel()
+
+        with pytest.raises(GenerationCancelled):
+            session._try_stream(
+                client=MagicMock(),
+                model="test",
+                msgs=[],
+            )
+
+
+class TestCancelRef:
+    """Tests for the _CancelRef list proxy."""
+
+    def test_append_sets_cancel_stream(self, tmp_db):
+        """Appending a stream handle to _CancelRef sets _cancel_stream eagerly."""
+        session = _make_session()
+        mock_stream = MagicMock()
+        assert session._cancel_stream is None
+
+        session._cancel_ref.append(mock_stream)
+
+        assert session._cancel_stream is mock_stream
+
+    def test_append_closes_stream_when_already_cancelled(self, tmp_db):
+        """If cancel is already set when a stream is appended, it is closed immediately."""
+        session = _make_session()
+        session.cancel()  # Set cancel event before stream is created
+
+        mock_stream = MagicMock()
+        session._cancel_ref.append(mock_stream)
+
+        mock_stream.close.assert_called_once()
+
+    def test_append_does_not_close_stream_when_not_cancelled(self, tmp_db):
+        """Stream is not closed if cancel hasn't been requested."""
+        session = _make_session()
+        mock_stream = MagicMock()
+
+        session._cancel_ref.append(mock_stream)
+
+        mock_stream.close.assert_not_called()
+        assert session._cancel_stream is mock_stream
+
+    def test_append_close_error_suppressed(self, tmp_db):
+        """Errors from stream.close() during eager close are suppressed."""
+        session = _make_session()
+        session.cancel()
+
+        mock_stream = MagicMock()
+        mock_stream.close.side_effect = RuntimeError("already closed")
+
+        session._cancel_ref.append(mock_stream)  # Should not raise
+
+    def test_cancel_ref_is_cancel_ref_instance(self, tmp_db):
+        """ChatSession._cancel_ref is a _CancelRef instance."""
+        session = _make_session()
+        assert isinstance(session._cancel_ref, _CancelRef)
+
+    def test_cancel_ref_cleared_after_stream_ends(self, tmp_db):
+        """_cancel_ref is cleared in the send() finally block after streaming."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+        mock_stream = MagicMock()
+        session._cancel_ref.append(mock_stream)
+        assert len(session._cancel_ref) == 1
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = "stop"
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        with (
+            patch.object(
+                session,
+                "_create_stream_with_retry",
+                return_value=iter([FakeChunk(content_delta="hi", finish_reason="stop")]),
+            ),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+            session.send("test")
+
+        # After send() completes, _cancel_ref is cleared in the finally block
+        assert len(session._cancel_ref) == 0
+
+
+class TestForceCancelGeneration:
+    """Tests for per-generation tracking that prevents orphaned-thread side-effects."""
+
+    def test_check_cancelled_raises_for_orphaned_generation(self, tmp_db):
+        """_check_cancelled raises GenerationCancelled when my_generation is stale."""
+        session = _make_session()
+        session._generation = 2  # Simulate two generations having run
+
+        with pytest.raises(GenerationCancelled):
+            session._check_cancelled(my_generation=1)  # Generation 1 is orphaned
+
+    def test_check_cancelled_ok_for_current_generation(self, tmp_db):
+        """_check_cancelled does not raise when my_generation matches current."""
+        session = _make_session()
+        session._generation = 3
+        session._check_cancelled(my_generation=3)  # Should not raise
+
+    def test_force_cancel_orphaned_thread_does_not_mutate_messages(self, tmp_db):
+        """An abandoned generation (force-cancel) cannot append to session.messages."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        # We can't trivially test the full threading scenario in a unit test,
+        # so directly verify that _check_cancelled raises when my_generation
+        # is stale, which is what guards _stream_response against orphaned
+        # (force-cancelled) threads continuing to mutate messages.
+        session._generation = 5
+        with pytest.raises(GenerationCancelled):
+            session._check_cancelled(my_generation=4)  # orphaned generation
+
+    def test_new_cancel_event_per_generation_in_send(self, tmp_db):
+        """send() replaces _cancel_event with a fresh Event each generation."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = "stop"
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        original_event = session._cancel_event
+
+        with (
+            patch.object(
+                session,
+                "_create_stream_with_retry",
+                return_value=iter([FakeChunk(content_delta="hi", finish_reason="stop")]),
+            ),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+            session.send("test")
+
+        # After send() completes, _cancel_event should be a NEW Event
+        # (not the same object as before the call).
+        assert session._cancel_event is not original_event
+        assert not session._cancel_event.is_set()
+
+
+class TestForceCancelThreaded:
+    """Force cancel with actual threads — verifies orphaned thread behavior."""
+
+    def test_force_cancel_orphan_does_not_mutate_messages(self, tmp_db):
+        """After force cancel + new send(), the orphaned thread must not
+        append stale content to session.messages."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = ""
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        barrier = threading.Event()
+        old_done = threading.Event()
+
+        def slow_stream():
+            yield FakeChunk(content_delta="Old content")
+            barrier.set()  # signal: first chunk delivered
+            time.sleep(2)  # simulate stuck stream
+            yield FakeChunk(content_delta=" more", finish_reason="stop")
+
+        # Start generation 1 (will get stuck)
+        with (
+            patch.object(session, "_create_stream_with_retry", return_value=slow_stream()),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+
+            def run_old():
+                with contextlib.suppress(Exception):
+                    session.send("old message")
+                old_done.set()
+
+            t1 = threading.Thread(target=run_old, daemon=True)
+            t1.start()
+            assert barrier.wait(timeout=5), "stream did not start"
+
+        # Force cancel: simulate what the server does
+        session.cancel()
+        # Increment generation as new send() would
+        session._generation += 1
+        session._cancel_event = threading.Event()
+
+        # Wait for old thread to notice generation mismatch and exit
+        assert old_done.wait(timeout=10), "orphaned thread did not exit"
+
+        # The orphaned thread should NOT have appended its content
+        assistant_msgs = [m for m in session.messages if m["role"] == "assistant"]
+        # May have partial content from before cancel, but NOT the full
+        # "Old content more" that would appear without the generation guard
+        for msg in assistant_msgs:
+            assert "more" not in msg.get("content", "")
+
+    def test_force_cancel_then_new_send_succeeds(self, tmp_db):
+        """A new send() after force cancel works cleanly."""
+        ui = NullUI()
+        session = _make_session(ui=ui)
+
+        @dataclass
+        class FakeChunk:
+            content_delta: str = ""
+            reasoning_delta: str = ""
+            tool_call_deltas: list = field(default_factory=list)
+            usage: None = None
+            finish_reason: str = "stop"
+            info_delta: str = ""
+            provider_blocks: list = field(default_factory=list)
+
+        barrier = threading.Event()
+
+        def stuck_stream():
+            yield FakeChunk(content_delta="stuck")
+            barrier.set()
+            time.sleep(2)
+            yield FakeChunk(content_delta=" end", finish_reason="stop")
+
+        # Start stuck generation
+        with (
+            patch.object(session, "_create_stream_with_retry", return_value=stuck_stream()),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+            t = threading.Thread(target=lambda: session.send("old"), daemon=True)
+            t.start()
+            assert barrier.wait(timeout=5), "stream did not start"
+
+        # Force cancel
+        session.cancel()
+
+        # New generation should work
+        fresh_stream = iter([FakeChunk(content_delta="Fresh response")])
+        with (
+            patch.object(session, "_create_stream_with_retry", return_value=fresh_stream),
+            patch.object(session, "_full_messages", return_value=[]),
+        ):
+            session.send("new message")
+
+        # The new generation should have completed successfully
+        assert "idle" in ui.states
+        assistant_msgs = [m for m in session.messages if m["role"] == "assistant"]
+        assert any("Fresh response" in m.get("content", "") for m in assistant_msgs)
@@ -390,6 +390,7 @@ class TestApprovalVerdictDisplay:
        bot.config.streaming_edit_interval = 1.5
        bot.config.auto_approve = False
        bot.config.auto_approve_tools = []
+        bot.storage = None
        bot._streaming = {}
        bot._pending_approval_msgs = {}
        bot._notify_reply_channels = {}
@@ -4,6 +4,7 @@ from __future__ import annotations

 import json
 import time
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any
 from unittest.mock import MagicMock
@@ -179,10 +180,13 @@ class TestErrorHandling:
        provider = _make_mock_provider(side_effect=RuntimeError("API error"))
        judge = _make_judge(provider)

-        result = judge._evaluate_single(
-            _make_item(),
-            [{"role": "user", "content": "test"}],
-        )
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            result = judge._evaluate_single(
+                _make_item(),
+                [{"role": "user", "content": "test"}],
+                cancel_event=None,
+                executor=pool,
+            )
        assert result is None

    def test_provider_error_heuristic_still_returned(self):
@@ -211,10 +215,13 @@ class TestErrorHandling:
        result_mock.content = ""

        judge = _make_judge(provider)
-        result = judge._evaluate_single(
-            _make_item(),
-            [{"role": "user", "content": "test"}],
-        )
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            result = judge._evaluate_single(
+                _make_item(),
+                [{"role": "user", "content": "test"}],
+                cancel_event=None,
+                executor=pool,
+            )
        assert result is None


@@ -254,10 +261,13 @@ class TestMultiTurnToolUse:
        provider.create_completion.side_effect = [turn1, turn2]

        judge = _make_judge(provider)
-        verdict = judge._evaluate_single(
-            _make_item(),
-            [{"role": "user", "content": "test"}],
-        )
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            verdict = judge._evaluate_single(
+                _make_item(),
+                [{"role": "user", "content": "test"}],
+                cancel_event=None,
+                executor=pool,
+            )
        assert verdict is not None
        assert verdict.tier == "llm"
        assert provider.create_completion.call_count == 2
@@ -299,10 +309,13 @@ class TestMultiTurnToolUse:
        ]

        judge = _make_judge(provider)
-        judge._evaluate_single(
-            _make_item(),
-            [{"role": "user", "content": "test"}],
-        )
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            judge._evaluate_single(
+                _make_item(),
+                [{"role": "user", "content": "test"}],
+                cancel_event=None,
+                executor=pool,
+            )
        # Should have called create_completion exactly _JUDGE_MAX_TURNS times
        assert provider.create_completion.call_count == 5

@@ -401,6 +401,64 @@ class TestSessionIntegration:
        prepared = session._prepare_tool(tc)
        assert "error" in prepared
        assert "Unknown tool" in prepared["error"]
+        # Error lists available tools so the model can self-correct
+        assert "bash" in prepared["error"]
+        # Surfaces warning to user
+        session.ui.on_error.assert_called_once()
+        assert "nonexistent" in session.ui.on_error.call_args[0][0]
+
+    def test_prepare_tool_strips_whitespace_from_name(self, tmp_db):
+        """Local models may produce tool names with leading/trailing whitespace."""
+        session = self._make_session(mcp_client=None)
+        tc = {
+            "id": "call_strip",
+            "function": {"name": "  bash\n", "arguments": '{"command": "echo hi"}'},
+        }
+        prepared = session._prepare_tool(tc)
+        assert prepared["func_name"] == "bash"
+        assert "error" not in prepared
+
+    def test_prepare_tool_malformed_json_surfaces_error(self, tmp_db):
+        """Malformed JSON args should surface a warning to the user and
+        give the model a hint about expected format."""
+        session = self._make_session(mcp_client=None)
+        tc = {
+            "id": "call_bad",
+            "function": {"name": "bash", "arguments": "{command: echo hi}"},
+        }
+        prepared = session._prepare_tool(tc)
+        assert "error" in prepared
+        assert "JSON parse error" in prepared["error"]
+        assert "command" in prepared["error"]  # hint about expected key
+        assert "Please retry" in prepared["error"]
+        # User-facing warning
+        session.ui.on_error.assert_called_once()
+        assert "Malformed tool call" in session.ui.on_error.call_args[0][0]
+
+    def test_ensure_tool_call_ids_dict(self, tmp_db):
+        """_ensure_tool_call_ids fills empty IDs on streaming-style dict."""
+        from turnstone.core.session import ChatSession
+
+        tool_calls_acc = {
+            0: {"id": "", "function": {"name": "bash", "arguments": "{}"}},
+            1: {"id": "", "function": {"name": "read_file", "arguments": "{}"}},
+        }
+        ChatSession._ensure_tool_call_ids(tool_calls_acc)
+        ids = [tc["id"] for tc in tool_calls_acc.values()]
+        assert all(id_.startswith("call_") for id_ in ids)
+        assert len(set(ids)) == 2  # unique
+
+    def test_ensure_tool_call_ids_list(self, tmp_db):
+        """_ensure_tool_call_ids fills empty IDs on list (agent path)."""
+        from turnstone.core.session import ChatSession
+
+        tool_calls = [
+            {"id": None, "function": {"name": "bash", "arguments": "{}"}},
+            {"id": "call_existing", "function": {"name": "bash", "arguments": "{}"}},
+        ]
+        ChatSession._ensure_tool_call_ids(tool_calls)
+        assert tool_calls[0]["id"].startswith("call_")
+        assert tool_calls[1]["id"] == "call_existing"  # preserved

    def test_mcp_command_no_client(self, tmp_db):
        session = self._make_session(mcp_client=None)
@@ -1368,3 +1426,130 @@ class TestShutdownCleanup:
        assert mgr.get_prompts() == []
        assert mgr._resource_map == {}
        assert mgr._prompt_map == {}
+
+
+# ---------------------------------------------------------------------------
+# TCP probe and unreachable server handling
+# ---------------------------------------------------------------------------
+
+
+class TestTCPProbe:
+    """MCPClientManager._tcp_probe should fail fast on unreachable servers."""
+
+    def test_tcp_probe_unreachable_raises_connection_error(self):
+        """Unreachable host raises ConnectionError, not TimeoutError."""
+        mgr = MCPClientManager({})
+
+        async def _run():
+            with pytest.raises(ConnectionError, match="unreachable"):
+                await mgr._tcp_probe("test-server", "http://127.0.0.1:1")
+
+        asyncio.run(_run())
+
+    def test_tcp_probe_parses_url_correctly(self):
+        """Port and host are extracted from the URL."""
+        mgr = MCPClientManager({})
+
+        async def _run():
+            # Non-routable port — should fail with ConnectionError
+            with pytest.raises(ConnectionError):
+                await mgr._tcp_probe("srv", "https://127.0.0.1:1/mcp")
+
+        asyncio.run(_run())
+
+    def test_tcp_probe_default_port_http(self):
+        """Default port 80 used for http:// URLs without explicit port."""
+        mgr = MCPClientManager({})
+
+        async def _run():
+            # Will fail (nothing on port 80), but should not crash on parsing
+            with pytest.raises(ConnectionError):
+                await mgr._tcp_probe("srv", "http://127.0.0.1")
+
+        asyncio.run(_run())
+
+    def test_tcp_probe_dns_failure(self):
+        """Unresolvable hostname raises ConnectionError."""
+        mgr = MCPClientManager({})
+
+        async def _run():
+            with pytest.raises(ConnectionError):
+                await mgr._tcp_probe("srv", "http://this.host.does.not.exist.invalid:8080/mcp")
+
+        asyncio.run(_run())
+
+
+class TestConnectOneUnreachable:
+    """_connect_one should handle unreachable HTTP servers gracefully."""
+
+    def test_unreachable_http_server_raises_connection_error(self):
+        """Unreachable HTTP MCP server raises ConnectionError without spinning."""
+        mgr = MCPClientManager({})
+        mgr._loop = asyncio.new_event_loop()
+
+        async def _run():
+            with pytest.raises(ConnectionError, match="unreachable"):
+                await mgr._connect_one(
+                    "bad-server",
+                    {
+                        "type": "http",
+                        "url": "http://127.0.0.1:1/mcp",
+                    },
+                )
+
+        mgr._loop.run_until_complete(_run())
+        mgr._loop.close()
+
+        # Server should NOT be in sessions (connection failed)
+        assert "bad-server" not in mgr._sessions
+
+    def test_connect_all_continues_after_unreachable_server(self):
+        """_connect_all logs error and continues to next server."""
+        mgr = MCPClientManager(
+            {
+                "bad": {"type": "http", "url": "http://127.0.0.1:1/mcp"},
+            }
+        )
+
+        loop = asyncio.new_event_loop()
+        loop.run_until_complete(mgr._connect_all())
+        loop.close()
+
+        assert "bad" not in mgr._sessions
+        assert "bad" in mgr._last_error
+
+
+class TestSafeCloseStack:
+    """_safe_close_stack should suppress errors from broken anyio scopes."""
+
+    def test_suppresses_runtime_error(self):
+        """RuntimeError from broken cancel scope is suppressed."""
+
+        async def _run():
+            stack = AsyncExitStack()
+            await stack.__aenter__()
+
+            # Simulate a broken close that raises RuntimeError
+            async def _broken_close():
+                raise RuntimeError("Attempted to exit cancel scope in a different task")
+
+            stack.aclose = _broken_close
+            # Should not raise
+            await MCPClientManager._safe_close_stack(stack)
+
+        asyncio.run(_run())
+
+    def test_suppresses_cancelled_error(self):
+        """CancelledError during close is suppressed."""
+
+        async def _run():
+            stack = AsyncExitStack()
+            await stack.__aenter__()
+
+            async def _cancel_close():
+                raise asyncio.CancelledError()
+
+            stack.aclose = _cancel_close
+            await MCPClientManager._safe_close_stack(stack)
+
+        asyncio.run(_run())
@@ -4,6 +4,7 @@ from turnstone.core.metacognition import (
    NUDGE_COMPLETION,
    NUDGE_CORRECTION,
    NUDGE_DENIAL,
+    NUDGE_REPEAT,
    NUDGE_RESUME,
    NUDGE_START,
    NUDGE_TOOL_ERROR,
@@ -288,3 +289,22 @@ class TestToolErrorNudge:
    def test_not_with_zero_memories(self):
        state: dict[str, float] = {}
        assert should_nudge("tool_error", state, message_count=5, memory_count=0) is False
+
+
+class TestRepeatNudge:
+    def test_format(self):
+        assert format_nudge("repeat") == NUDGE_REPEAT
+
+    def test_fires(self):
+        state: dict[str, float] = {}
+        assert should_nudge("repeat", state, message_count=5) is True
+
+    def test_cooldown(self):
+        state: dict[str, float] = {}
+        assert should_nudge("repeat", state, message_count=5) is True
+        assert should_nudge("repeat", state, message_count=6) is False
+
+    def test_no_memory_requirement(self):
+        """Repeat nudge should fire even with zero memories."""
+        state: dict[str, float] = {}
+        assert should_nudge("repeat", state, message_count=5, memory_count=0) is True
@@ -140,6 +140,34 @@ class TestOpenAIProvider:
    def test_provider_name(self) -> None:
        assert self.provider.provider_name == "openai"

+    # -- _sanitize_messages ---------------------------------------------------
+
+    def test_sanitize_messages_none_content_no_tool_calls(self) -> None:
+        msgs = [{"role": "assistant", "content": None}]
+        assert self.provider._sanitize_messages(msgs) == [{"role": "assistant", "content": ""}]
+
+    def test_sanitize_messages_none_content_with_tool_calls(self) -> None:
+        msgs = [{"role": "assistant", "content": None, "tool_calls": [{"id": "1"}]}]
+        result = self.provider._sanitize_messages(msgs)
+        assert result[0]["content"] is None
+        assert result[0]["tool_calls"] == [{"id": "1"}]
+
+    def test_sanitize_messages_empty_string_passthrough(self) -> None:
+        msgs = [{"role": "assistant", "content": ""}]
+        assert self.provider._sanitize_messages(msgs) == msgs
+
+    def test_sanitize_messages_non_assistant_unchanged(self) -> None:
+        msgs = [{"role": "user", "content": None}]
+        result = self.provider._sanitize_messages(msgs)
+        assert result[0]["content"] is None
+
+    def test_sanitize_messages_does_not_mutate_original(self) -> None:
+        original = {"role": "assistant", "content": None}
+        self.provider._sanitize_messages([original])
+        assert original["content"] is None
+
+    # -- convert_tools --------------------------------------------------------
+
    def test_convert_tools_passthrough(self) -> None:
        tools = [
            {
@@ -699,6 +699,7 @@ class TestWebSearchGating:
        with (
            patch.object(session, "_get_capabilities", return_value=caps),
            patch("turnstone.core.session.get_tavily_key", return_value=None),
+            patch("turnstone.core.web_search._ddg_available", return_value=False),
        ):
            tools = session._get_active_tools()

@@ -754,3 +755,150 @@ class TestWebSearchGating:

        names = [t.get("function", {}).get("name") for t in tools]
        assert "web_search" in names
+
+
+class TestMCPToolGating:
+    """MCP tools should not be offered when no MCP servers provide them."""
+
+    def test_mcp_tools_filtered_without_mcp_client(self, tmp_db, mock_openai_client):
+        """read_resource and use_prompt excluded when no MCP client."""
+        session = ChatSession(
+            client=mock_openai_client,
+            model="local-model",
+            ui=MagicMock(),
+            instructions=None,
+            temperature=0.5,
+            max_tokens=1000,
+            tool_timeout=10,
+        )
+        assert session._mcp_client is None
+
+        tools = session._get_active_tools()
+        names = [t.get("function", {}).get("name") for t in tools]
+        assert "read_resource" not in names
+        assert "use_prompt" not in names
+
+    def test_read_resource_filtered_when_no_resources(self, tmp_db, mock_openai_client):
+        """read_resource excluded when MCP client has no resources."""
+        mcp_client = MagicMock()
+        mcp_client.get_tools.return_value = []
+        mcp_client.resource_count = 0
+        mcp_client.prompt_count = 2
+
+        session = ChatSession(
+            client=mock_openai_client,
+            model="local-model",
+            ui=MagicMock(),
+            instructions=None,
+            temperature=0.5,
+            max_tokens=1000,
+            tool_timeout=10,
+            mcp_client=mcp_client,
+        )
+
+        tools = session._get_active_tools()
+        names = [t.get("function", {}).get("name") for t in tools]
+        assert "read_resource" not in names
+        assert "use_prompt" in names
+
+    def test_use_prompt_filtered_when_no_prompts(self, tmp_db, mock_openai_client):
+        """use_prompt excluded when MCP client has no prompts."""
+        mcp_client = MagicMock()
+        mcp_client.get_tools.return_value = []
+        mcp_client.resource_count = 3
+        mcp_client.prompt_count = 0
+
+        session = ChatSession(
+            client=mock_openai_client,
+            model="local-model",
+            ui=MagicMock(),
+            instructions=None,
+            temperature=0.5,
+            max_tokens=1000,
+            tool_timeout=10,
+            mcp_client=mcp_client,
+        )
+
+        tools = session._get_active_tools()
+        names = [t.get("function", {}).get("name") for t in tools]
+        assert "use_prompt" not in names
+        assert "read_resource" in names
+
+    def test_mcp_tools_kept_when_servers_have_both(self, tmp_db, mock_openai_client):
+        """Both tools present when MCP client has resources and prompts."""
+        mcp_client = MagicMock()
+        mcp_client.get_tools.return_value = []
+        mcp_client.resource_count = 1
+        mcp_client.prompt_count = 1
+
+        session = ChatSession(
+            client=mock_openai_client,
+            model="local-model",
+            ui=MagicMock(),
+            instructions=None,
+            temperature=0.5,
+            max_tokens=1000,
+            tool_timeout=10,
+            mcp_client=mcp_client,
+        )
+
+        tools = session._get_active_tools()
+        names = [t.get("function", {}).get("name") for t in tools]
+        assert "read_resource" in names
+        assert "use_prompt" in names
+
+    def test_mcp_tools_filtered_with_tool_search_active(self, tmp_db, mock_openai_client):
+        """Gating applies even when tool_search is active (client-side path)."""
+        mcp_client = MagicMock()
+        mcp_client.get_tools.return_value = []
+        mcp_client.resource_count = 0
+        mcp_client.prompt_count = 0
+
+        session = ChatSession(
+            client=mock_openai_client,
+            model="local-model",
+            ui=MagicMock(),
+            instructions=None,
+            temperature=0.5,
+            max_tokens=1000,
+            tool_timeout=10,
+            mcp_client=mcp_client,
+            tool_search="on",
+        )
+        assert session._tool_search is not None
+
+        tools = session._get_active_tools()
+        names = [t.get("function", {}).get("name") for t in tools]
+        assert "read_resource" not in names
+        assert "use_prompt" not in names
+
+    def test_mcp_tools_filtered_with_native_tool_search(self, tmp_db, mock_openai_client):
+        """Gating applies when provider handles tool search natively."""
+        from unittest.mock import patch
+
+        from turnstone.core.providers._protocol import ModelCapabilities
+
+        mcp_client = MagicMock()
+        mcp_client.get_tools.return_value = []
+        mcp_client.resource_count = 0
+        mcp_client.prompt_count = 0
+
+        session = ChatSession(
+            client=mock_openai_client,
+            model="local-model",
+            ui=MagicMock(),
+            instructions=None,
+            temperature=0.5,
+            max_tokens=1000,
+            tool_timeout=10,
+            mcp_client=mcp_client,
+            tool_search="on",
+        )
+
+        caps = ModelCapabilities(supports_tool_search=True)
+        with patch.object(session, "_get_capabilities", return_value=caps):
+            tools = session._get_active_tools()
+
+        names = [t.get("function", {}).get("name") for t in tools]
+        assert "read_resource" not in names
+        assert "use_prompt" not in names
@@ -1,3 +1,3 @@
 """turnstone - Multi-node AI orchestration platform with tool use, agent routing, and cluster simulation."""

-__version__ = "0.8.9"
+__version__ = "0.9.1"
@@ -41,6 +41,11 @@ class CommandRequest(BaseModel):

 class CancelRequest(BaseModel):
    ws_id: str = Field(description="Target workstream ID")
+    force: bool = Field(
+        default=False,
+        description="Force cancel: abandon the stuck worker thread immediately. "
+        "Use when cooperative cancel has not resolved within a few seconds.",
+    )


 class CreateWorkstreamRequest(BaseModel):
@@ -80,7 +80,12 @@ class TLSManager:

            setup_metrics(self._event_dispatcher)
        except ImportError:
-            pass  # prometheus_client not installed
+            pass  # prometheus_client or lacme.metrics missing
+        except ValueError as exc:
+            if "Duplicated timeseries" in str(exc):
+                log.debug("tls_metrics_already_registered")
+            else:
+                raise

    def _subscribe_events(self) -> None:
        """Subscribe structlog handlers to lacme lifecycle events."""
@@ -322,7 +327,7 @@ class TLSManager:
        _require_lacme()
        from lacme.mtls import server_ssl_context

-        return server_ssl_context(  # type: ignore[no-any-return]
+        return server_ssl_context(  # type: ignore[no-any-return,unused-ignore]
            cert_pem=self._frontend_bundle.fullchain_pem,
            key_pem=self._frontend_bundle.key_pem,
            ca_cert_pem=self.get_root_cert_pem(),
@@ -339,7 +344,7 @@ class TLSManager:
        _require_lacme()
        from lacme.mtls import client_ssl_context

-        return client_ssl_context(  # type: ignore[no-any-return]
+        return client_ssl_context(  # type: ignore[no-any-return,unused-ignore]
            cert_pem=self._internal_bundle.cert_pem,
            key_pem=self._internal_bundle.key_pem,
            ca_cert_pem=self.get_root_cert_pem(),
@@ -853,6 +853,10 @@ If you used read_file to check a target, cite what you found."""
 # ---------------------------------------------------------------------------


+class _ExecutorPoisonedError(Exception):
+    """Raised when a timeout leaves the executor's worker thread stuck."""
+
+
 class IntentJudge:
    """Session-scoped LLM judge for intent validation.

@@ -912,18 +916,12 @@ class IntentJudge:
            self._model = session_model
            self._judge_context_window = context_window

-        # Executor for timeout-guarded API calls (1 thread — judge is serial)
-        self._executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="judge-api")
-
-    def shutdown(self) -> None:
-        """Release the executor thread pool."""
-        self._executor.shutdown(wait=False, cancel_futures=True)
-
    def evaluate(
        self,
        items: list[dict[str, Any]],
        messages: list[dict[str, Any]],
        callback: Callable[[IntentVerdict], None],
+        cancel_event: threading.Event | None = None,
    ) -> list[IntentVerdict]:
        """Evaluate tool calls. Returns heuristic verdicts immediately.

@@ -936,6 +934,10 @@ class IntentJudge:
                ``func_args``, ``approval_label``, ``call_id``).
            messages: Conversation history (OpenAI message format).
            callback: Called with each LLM verdict (or timeout/error fallback).
+            cancel_event: When set, the daemon judge thread abandons
+                remaining work.  Callers should set this after the user
+                has already made an approval decision so the judge does
+                not keep consuming inference resources.

        Returns:
            List of heuristic verdicts (one per item), available immediately.
@@ -958,7 +960,7 @@ class IntentJudge:
        # Spawn daemon thread for LLM judge
        thread = threading.Thread(
            target=self._run_judge,
-            args=(items, messages, heuristic_verdicts, callback),
+            args=(items, messages, heuristic_verdicts, callback, cancel_event),
            daemon=True,
            name="intent-judge",
        )
@@ -972,25 +974,44 @@ class IntentJudge:
        messages: list[dict[str, Any]],
        heuristic_verdicts: list[IntentVerdict],
        callback: Callable[[IntentVerdict], None],
+        cancel_event: threading.Event | None = None,
    ) -> None:
        """Daemon thread: run LLM judge for each item and invoke callback."""
-        for item, h_verdict in zip(items, heuristic_verdicts, strict=True):
-            try:
-                llm_verdict = self._evaluate_single(item, messages)
-                # Arbitrate: only callback when LLM upgrades the heuristic
-                if llm_verdict and llm_verdict.confidence > h_verdict.confidence:
-                    callback(llm_verdict)
-                # else: heuristic already delivered, no duplicate callback
-            except Exception:
-                log.exception(
-                    "Judge evaluation failed for %s",
-                    item.get("func_name", "?"),
-                )
+        # Evaluation-scoped executor — avoids sharing mutable state with
+        # other daemon threads from concurrent evaluate() calls.
+        executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="judge-api")
+        try:
+            for idx, (item, h_verdict) in enumerate(zip(items, heuristic_verdicts, strict=True)):
+                if cancel_event and cancel_event.is_set():
+                    log.debug("judge.cancelled", remaining=len(items) - idx)
+                    return
+                try:
+                    llm_verdict = self._evaluate_single(item, messages, cancel_event, executor)
+                    if cancel_event and cancel_event.is_set():
+                        return
+                    # Arbitrate: only callback when LLM upgrades the heuristic
+                    if llm_verdict and llm_verdict.confidence > h_verdict.confidence:
+                        callback(llm_verdict)
+                    # else: heuristic already delivered, no duplicate callback
+                except _ExecutorPoisonedError:
+                    # Timeout left the worker stuck — replace the executor
+                    # so subsequent items don't queue behind it.
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="judge-api")
+                except Exception:
+                    log.exception(
+                        "Judge evaluation failed for %s",
+                        item.get("func_name", "?"),
+                    )
+        finally:
+            executor.shutdown(wait=False, cancel_futures=True)

    def _evaluate_single(
        self,
        item: dict[str, Any],
        messages: list[dict[str, Any]],
+        cancel_event: threading.Event | None,
+        executor: ThreadPoolExecutor,
    ) -> IntentVerdict | None:
        """Run LLM judge for a single tool call. Returns verdict or None."""
        start = time.monotonic()
@@ -1020,6 +1041,9 @@ class IntentJudge:
        result = None  # will hold the last CompletionResult

        for turn in range(_JUDGE_MAX_TURNS):
+            if cancel_event and cancel_event.is_set():
+                return None
+
            turn_start = time.monotonic()

            is_last_turn = turn == _JUDGE_MAX_TURNS - 1
@@ -1043,7 +1067,7 @@ class IntentJudge:
            # 10 minutes — far too long for an advisory judge on local models.
            per_call_timeout = max(timeout_budget, 5.0)  # at least 5s
            try:
-                future = self._executor.submit(
+                future = executor.submit(
                    self._provider.create_completion,
                    client=self._client,
                    model=self._model,
@@ -1053,17 +1077,24 @@ class IntentJudge:
                    temperature=0.0,
                    reasoning_effort="medium",
                )
-                result = future.result(timeout=per_call_timeout)
+                # Poll in 1s increments so we notice cancellation promptly
+                # instead of blocking for the full per_call_timeout.
+                deadline = time.monotonic() + per_call_timeout
+                while True:
+                    remaining = deadline - time.monotonic()
+                    if cancel_event and cancel_event.is_set():
+                        future.cancel()
+                        return None
+                    if remaining <= 0:
+                        raise TimeoutError
+                    try:
+                        result = future.result(timeout=min(remaining, 1.0))
+                        break
+                    except TimeoutError:
+                        pass  # loop back to check remaining/cancel
            except TimeoutError:
                log.warning("Judge LLM call timed out on turn %d (%.0fs)", turn, per_call_timeout)
-                # Abandon the lingering API call and replace the executor so
-                # subsequent items in the batch don't queue behind it.
-                self._executor.shutdown(wait=False, cancel_futures=True)
-                self._executor = ThreadPoolExecutor(
-                    max_workers=1,
-                    thread_name_prefix="judge-api",
-                )
-                return None
+                raise _ExecutorPoisonedError from None
            except Exception:
                log.exception("Judge LLM call failed on turn %d", turn)
                return None
@@ -176,6 +176,8 @@ class MCPClientManager:
        for name, cfg in self._server_configs.items():
            try:
                await self._connect_one(name, cfg)
+            except asyncio.CancelledError:
+                raise  # propagate so the background task can be cleanly stopped
            except Exception as exc:
                log.warning("Failed to connect MCP server '%s'", name, exc_info=True)
                self._set_error(name, f"{type(exc).__name__}: {exc}")
@@ -199,6 +201,49 @@ class MCPClientManager:
            self._refresh_task = asyncio.get_running_loop().create_task(self._periodic_refresh())

    _CONNECT_TIMEOUT = 30  # seconds — prevents hung connections on broken remotes
+    _TCP_PROBE_TIMEOUT = 5  # seconds — fast TCP pre-flight for HTTP transports
+
+    async def _tcp_probe(self, name: str, url: str) -> None:
+        """Fast TCP connect check before entering the MCP transport context.
+
+        Fails fast when the server is unreachable, avoiding the anyio
+        cancel-scope orphan bug that causes 100% CPU spin.
+        """
+        from urllib.parse import urlparse
+
+        parsed = urlparse(url)
+        host = parsed.hostname
+        if not host:
+            raise ConnectionError(f"MCP server '{name}' has invalid URL (no hostname): {url}")
+        try:
+            port = parsed.port or (443 if parsed.scheme == "https" else 80)
+        except ValueError:
+            raise ConnectionError(f"MCP server '{name}' has invalid port in URL: {url}") from None
+        try:
+            _, writer = await asyncio.wait_for(
+                asyncio.open_connection(host, port),
+                timeout=self._TCP_PROBE_TIMEOUT,
+            )
+            writer.close()
+            await writer.wait_closed()
+        except (TimeoutError, OSError) as exc:
+            raise ConnectionError(
+                f"MCP server '{name}' unreachable at {host}:{port}: {exc}"
+            ) from None
+
+    @staticmethod
+    async def _safe_close_stack(stack: AsyncExitStack) -> None:
+        """Close an AsyncExitStack, suppressing errors from broken anyio scopes.
+
+        Called from exception handlers — must not raise, otherwise cleanup
+        errors could mask the original exception.  CancelledError is caught
+        explicitly because it is the primary failure mode (stray cancel from
+        broken anyio scope) and is BaseException, not Exception.
+        """
+        try:
+            await asyncio.wait_for(stack.aclose(), timeout=5)
+        except (Exception, asyncio.CancelledError):
+            log.debug("Error closing AsyncExitStack; ignoring", exc_info=True)

    async def _connect_one(self, name: str, cfg: dict[str, Any]) -> None:
        """Connect to a single MCP server and discover its tools."""
@@ -213,6 +258,13 @@ class MCPClientManager:
        transport = cfg.get("type", "stdio")
        try:
            if transport in ("http", "streamable-http") or "url" in cfg:
+                # Pre-flight TCP check: fail fast before entering the anyio
+                # task group in streamablehttp_client.  An immediate connect
+                # failure (ECONNREFUSED) inside the anyio context causes a
+                # CancelledError that escapes asyncio.wait_for and leaves
+                # orphaned cancel-scope tasks spinning at 100% CPU.
+                await self._tcp_probe(name, cfg["url"])
+
                read, write, _ = await asyncio.wait_for(
                    stack.enter_async_context(
                        streamablehttp_client(url=cfg["url"], headers=cfg.get("headers"))
@@ -235,15 +287,25 @@ class MCPClientManager:
                    env=env,
                )
                read, write = await stack.enter_async_context(stdio_client(params))
+        except asyncio.CancelledError:
+            # Stray CancelledError from broken anyio cancel scope — treat as
+            # connection failure.  But if the task is genuinely being cancelled
+            # (shutdown), re-raise so we don't block teardown.
+            task = asyncio.current_task()
+            if task is not None and task.cancelling():
+                await self._safe_close_stack(stack)
+                raise
+            log.warning("MCP server '%s' connection failed (anyio cancel)", name)
+            await self._safe_close_stack(stack)
+            raise TimeoutError(f"Connection failed for '{name}'") from None
        except TimeoutError:
            log.warning(
                "MCP server '%s' connection timed out after %ds", name, self._CONNECT_TIMEOUT
            )
-            with contextlib.suppress(Exception):
-                await stack.aclose()
+            await self._safe_close_stack(stack)
            raise TimeoutError(f"Connection timed out after {self._CONNECT_TIMEOUT}s") from None
        except Exception:
-            await stack.aclose()
+            await self._safe_close_stack(stack)
            raise

        # Register notification handler — dispatches tool, resource, and
@@ -274,21 +336,27 @@ class MCPClientManager:
                ClientSession(read, write, message_handler=_on_notification)  # type: ignore[arg-type]
            )
        except Exception:
-            await stack.aclose()
+            await self._safe_close_stack(stack)
            raise

        self._per_server_stacks[name] = stack
        try:
            await asyncio.wait_for(session.initialize(), timeout=self._CONNECT_TIMEOUT)
+        except asyncio.CancelledError:
+            self._per_server_stacks.pop(name, None)
+            task = asyncio.current_task()
+            if task is not None and task.cancelling():
+                await self._safe_close_stack(stack)
+                raise
+            await self._safe_close_stack(stack)
+            raise TimeoutError(f"MCP handshake failed for '{name}'") from None
        except TimeoutError:
            self._per_server_stacks.pop(name, None)
-            with contextlib.suppress(Exception):
-                await stack.aclose()
+            await self._safe_close_stack(stack)
            raise TimeoutError(f"MCP handshake timed out after {self._CONNECT_TIMEOUT}s") from None
        except Exception:
            self._per_server_stacks.pop(name, None)
-            with contextlib.suppress(Exception):
-                await stack.aclose()
+            await self._safe_close_stack(stack)
            raise
        self._sessions[name] = session

@@ -873,8 +941,7 @@ class MCPClientManager:

            async def _close_all_stacks() -> None:
                for stack in self._per_server_stacks.values():
-                    with contextlib.suppress(Exception):
-                        await stack.aclose()
+                    await self._safe_close_stack(stack)

            future = asyncio.run_coroutine_threadsafe(_close_all_stacks(), self._loop)
            try:
@@ -984,10 +1051,7 @@ class MCPClientManager:
                self._sessions.pop(name, None)
                stack = self._per_server_stacks.pop(name, None)
                if stack is not None:
-                    try:
-                        await asyncio.wait_for(stack.aclose(), timeout=10)
-                    except (TimeoutError, Exception):
-                        log.warning("Timed out closing MCP server '%s', forcing cleanup", name)
+                    await self._safe_close_stack(stack)
                # Clean up per-server state (on the event loop thread)
                self._per_server_tools.pop(name, None)
                self._per_server_resources.pop(name, None)
@@ -50,6 +50,13 @@ NUDGE_TOOL_ERROR = (
    "previous session. Use memory(action='search') to find relevant guidance."
 )

+NUDGE_REPEAT = (
+    "You just called the same tool with the same arguments as a previous "
+    "call in this conversation. Repeating the exact same action will produce "
+    "the same result. Stop and reconsider your approach — try a different "
+    "tool, different arguments, or ask the user for clarification."
+)
+
 _NUDGE_MAP: dict[str, str] = {
    "correction": NUDGE_CORRECTION,
    "denial": NUDGE_DENIAL,
@@ -57,6 +64,7 @@ _NUDGE_MAP: dict[str, str] = {
    "completion": NUDGE_COMPLETION,
    "start": NUDGE_START,
    "tool_error": NUDGE_TOOL_ERROR,
+    "repeat": NUDGE_REPEAT,
 }

 # ---------------------------------------------------------------------------
@@ -7,6 +7,7 @@ The ``anthropic`` SDK is imported lazily so it remains an optional dependency.
 from __future__ import annotations

 import json
+import sys
 from typing import TYPE_CHECKING, Any

 from turnstone.core.providers._protocol import (
@@ -459,6 +460,7 @@ class AnthropicProvider:
        reasoning_effort: str = "medium",
        extra_params: dict[str, Any] | None = None,
        deferred_names: frozenset[str] | None = None,
+        cancel_ref: list[Any] | None = None,
    ) -> Iterator[StreamChunk]:
        _ensure_anthropic()
        caps = self.get_capabilities(model)
@@ -476,8 +478,25 @@ class AnthropicProvider:
            deferred_names,
        )

-        with client.messages.stream(**kwargs) as stream:
+        manager = client.messages.stream(**kwargs)
+        try:
+            stream = manager.__enter__()
+        except BaseException:
+            manager.__exit__(*sys.exc_info())
+            raise
+        if cancel_ref is not None:
+            cancel_ref.append(stream)
+        return self._iter_with_cleanup(stream, manager)
+
+    def _iter_with_cleanup(self, stream: Any, manager: Any) -> Iterator[StreamChunk]:
+        """Iterate the Anthropic stream, ensuring the context manager exits."""
+        try:
            yield from self._iter_anthropic_stream(stream)
+        except BaseException:
+            manager.__exit__(*sys.exc_info())
+            raise
+        else:
+            manager.__exit__(None, None, None)

    def _iter_anthropic_stream(self, stream: Any) -> Iterator[StreamChunk]:
        """Convert Anthropic streaming events to normalized StreamChunks."""
@@ -273,6 +273,29 @@ class OpenAIProvider:
                result.append(tool)
        return result

+    # -- message sanitisation ------------------------------------------------
+
+    @staticmethod
+    def _sanitize_messages(
+        messages: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """Ensure assistant messages always have ``content`` or ``tool_calls``.
+
+        OpenAI-compatible APIs reject assistant messages that have neither.
+        This is a defensive catch-all; the upstream layers should already
+        guarantee well-formed messages.
+        """
+        out: list[dict[str, Any]] = []
+        for msg in messages:
+            if (
+                msg.get("role") == "assistant"
+                and msg.get("content") is None
+                and not msg.get("tool_calls")
+            ):
+                msg = {**msg, "content": ""}
+            out.append(msg)
+        return out
+
    # -- streaming -----------------------------------------------------------

    def create_streaming(
@@ -287,8 +310,10 @@ class OpenAIProvider:
        reasoning_effort: str = "medium",
        extra_params: dict[str, Any] | None = None,
        deferred_names: frozenset[str] | None = None,
+        cancel_ref: list[Any] | None = None,
    ) -> Iterator[StreamChunk]:
        caps = self.get_capabilities(model)
+        messages = self._sanitize_messages(messages)
        kwargs: dict[str, Any] = {
            "model": model,
            "messages": messages,
@@ -306,7 +331,9 @@ class OpenAIProvider:
            kwargs["extra_body"] = extra_params

        stream = client.chat.completions.create(**kwargs)
-        yield from self._iter_stream(stream)
+        if cancel_ref is not None:
+            cancel_ref.append(stream)
+        return self._iter_stream(stream)

    def _iter_stream(self, stream: Any) -> Iterator[StreamChunk]:
        """Convert OpenAI stream chunks to normalized StreamChunks."""
@@ -402,6 +429,7 @@ class OpenAIProvider:
        deferred_names: frozenset[str] | None = None,
    ) -> CompletionResult:
        caps = self.get_capabilities(model)
+        messages = self._sanitize_messages(messages)
        kwargs: dict[str, Any] = {
            "model": model,
            "messages": messages,
@@ -125,8 +125,15 @@ class LLMProvider(Protocol):
        reasoning_effort: str = "medium",
        extra_params: dict[str, Any] | None = None,
        deferred_names: frozenset[str] | None = None,
+        cancel_ref: list[Any] | None = None,
    ) -> Iterator[StreamChunk]:
-        """Create a streaming request, yielding normalized StreamChunks."""
+        """Create a streaming request, yielding normalized StreamChunks.
+
+        If *cancel_ref* is provided the provider appends the underlying SDK
+        stream object (which has a ``.close()`` method) before yielding the
+        first chunk.  The caller can then close it from another thread to
+        abort a blocked HTTP read immediately.
+        """
        ...

    def create_completion(
@@ -12,6 +12,7 @@ import base64
 import concurrent.futures
 import contextlib
 import dataclasses
+import hashlib
 import json
 import mimetypes
 import os
@@ -116,6 +117,34 @@ class GenerationCancelled(BaseException):
    """


+class _CancelRef(list[Any]):
+    """List proxy used for ``ChatSession._cancel_ref``.
+
+    Providers call ``cancel_ref.append(stream_handle)`` eagerly — the HTTP
+    call and registration happen before the iterator is returned to the
+    caller.  By overriding ``append`` we update ``ChatSession._cancel_stream``
+    immediately.  If cancellation was already requested before the stream
+    was created (e.g. cancel during retry backoff), the stream is closed
+    on arrival so the blocked iteration is unblocked.
+    """
+
+    __slots__ = ("_session",)
+
+    def __init__(self, session: ChatSession) -> None:
+        super().__init__()
+        self._session = session
+
+    def append(self, stream: Any) -> None:
+        super().append(stream)
+        self._session._cancel_stream = stream
+        # If cancel was requested before the first chunk arrived (the worker
+        # thread is blocked inside the provider generator waiting for the HTTP
+        # response), close the stream immediately to unblock it.
+        if self._session._cancel_event.is_set():
+            with contextlib.suppress(Exception):
+                stream.close()
+
+
 # Image extensions handled as vision content (SVG excluded — it's XML text)
 _IMAGE_EXTENSIONS: frozenset[str] = frozenset(
    {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".tif", ".ico"}
@@ -312,13 +341,21 @@ class ChatSession:
        self._watch_dispatch_depth = 0
        # Metacognitive nudges: ephemeral prompts for proactive memory use
        self._metacog_state: dict[str, float] = {}
-        self._pending_nudge: list[str] = []
+        self._pending_nudge: list[tuple[str, str]] = []  # (type, text)
+        # Repeat detection: track recent tool call signatures
+        self._recent_tool_sigs: set[str] = set()
        # Cooperative cancellation: set from outside to stop generation
        self._cancel_event = threading.Event()
+        self._cancel_ref: _CancelRef = _CancelRef(self)  # provider appends SDK stream here
+        self._cancel_stream: Any = None  # closeable SDK stream handle
+        self._generation: int = 0  # monotonic counter; orphaned threads skip cleanup
+        self._active_procs: set[subprocess.Popen[str]] = set()  # for force-kill
+        self._procs_lock = threading.Lock()
        self._cancelled_partial_msg: dict[str, Any] | None = None
        # Intent validation judge (lazy-initialized)
        self._judge_config: JudgeConfig | None = judge_config
        self._judge: IntentJudge | None = None
+        self._judge_cancel_event: threading.Event | None = None
        # MCP tool integration: merge external tools with built-in
        self._mcp_client = mcp_client
        self._mcp_refresh_cb: Any = None  # Callable | None (avoid import)
@@ -639,8 +676,8 @@ class ChatSession:

    def close(self) -> None:
        """Release resources (listener registrations, etc.)."""
-        if self._judge is not None:
-            self._judge.shutdown()
+        if self._judge_cancel_event is not None:
+            self._judge_cancel_event.set()
        if self._mcp_client and self._mcp_refresh_cb:
            self._mcp_client.remove_listener(self._mcp_refresh_cb)
            self._mcp_refresh_cb = None
@@ -779,6 +816,7 @@ class ChatSession:
        self._ws_id = ws_id
        self.messages = messages
        self._read_files.clear()
+        self._recent_tool_sigs.clear()
        self._last_usage = None
        self._title_generated = True  # don't re-title resumed workstreams
        self._msg_tokens = [
@@ -820,7 +858,7 @@ class ChatSession:
            memory_count=self._visible_memory_count(),
            cooldown_secs=self._mem_cfg.nudge_cooldown,
        ):
-            self._pending_nudge.append(format_nudge("resume"))
+            self._pending_nudge.append(("resume", format_nudge("resume")))
        self._init_system_messages()
        return True

@@ -1022,9 +1060,14 @@ class ChatSession:
                "Use memory(action='search') or memory(action='list') for more."
            )
        if self._pending_nudge:
-            for nudge in self._pending_nudge:
+            types = []
+            for nudge_type, nudge_text in self._pending_nudge:
                dev_parts.append("")
-                dev_parts.append(nudge)
+                dev_parts.append(nudge_text)
+                types.append(nudge_type)
+            # Surface nudge activity to the user so they can see
+            # the metacognitive prompts being applied.
+            self.ui.on_info(f"{GRAY}[metacognition: nudge injected — {', '.join(types)}]{RESET}")
            self._pending_nudge.clear()
        new_system_messages.append({"role": "system", "content": "\n".join(dev_parts)})
        # Atomic swap — readers see either old or new, never partial
@@ -1069,6 +1112,9 @@ class ChatSession:
        Web search gating: ``web_search`` is removed when the model has
        no native search support and no search backend is available
        (Tavily, DDG, or MCP — see ``_resolve_search_client``).
+
+        MCP tool gating: ``read_resource`` is removed when no MCP servers
+        expose resources; ``use_prompt`` is removed when none expose prompts.
        """
        if self.creative_mode:
            return None
@@ -1088,6 +1134,12 @@ class ChatSession:
        if not caps.supports_web_search and not self._resolve_search_client():
            tools = _without_tool(tools, "web_search")

+        # Gate MCP tools: only include when relevant MCP servers are connected
+        if not self._mcp_client or not self._mcp_client.resource_count:
+            tools = _without_tool(tools, "read_resource")
+        if not self._mcp_client or not self._mcp_client.prompt_count:
+            tools = _without_tool(tools, "use_prompt")
+
        return tools

    def _get_deferred_names(self) -> frozenset[str] | None:
@@ -1154,6 +1206,8 @@ class ChatSession:
        prov = provider or self._provider
        last_err: Exception | None = None
        for attempt in range(self._MAX_RETRIES + 1):
+            self._check_cancelled()
+            self._cancel_ref.clear()  # discard stale handle from prior attempt
            try:
                return prov.create_streaming(
                    client=client,
@@ -1165,6 +1219,7 @@ class ChatSession:
                    reasoning_effort=self.reasoning_effort,
                    extra_params=self._provider_extra_params(provider=prov),
                    deferred_names=self._get_deferred_names(),
+                    cancel_ref=self._cancel_ref,
                )
            except Exception as e:
                ename = type(e).__name__
@@ -1186,11 +1241,36 @@ class ChatSession:
        while the worker thread is inside ``send()``.
        """
        self._cancel_event.set()
+        # Close the underlying SDK stream to unblock the iteration
+        # immediately.  Without this the worker thread stays blocked in
+        # ``for chunk in stream`` until the next SSE chunk arrives from
+        # the LLM provider (can be seconds during extended thinking).
+        s = self._cancel_stream
+        if s is not None:
+            with contextlib.suppress(Exception):
+                s.close()
+        # Kill all tracked subprocesses (bash tool).  This is the
+        # last line of defense — ensures destructive commands are
+        # stopped even if the worker thread is stuck.
+        with self._procs_lock:
+            procs = list(self._active_procs)
+        for proc in procs:
+            if proc.poll() is not None:
+                continue  # already exited
+            try:
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            except (OSError, ProcessLookupError):
+                with contextlib.suppress(OSError, ProcessLookupError):
+                    proc.kill()

-    def _check_cancelled(self) -> None:
-        """Raise ``GenerationCancelled`` if cancellation has been requested."""
+    def _check_cancelled(self, my_generation: int = 0) -> None:
+        """Raise ``GenerationCancelled`` if cancellation has been requested
+        or if this thread belongs to an orphaned generation (force cancel).
+        """
        if self._cancel_event.is_set():
            raise GenerationCancelled()
+        if my_generation and my_generation != self._generation:
+            raise GenerationCancelled()

    # -- Main generation loop ------------------------------------------------

@@ -1215,7 +1295,12 @@ class ChatSession:
            self._budget_exhausted = False
            self._budget_warned = False
        self._notify_count = 0
-        self._cancel_event.clear()
+        self._generation += 1
+        my_generation = self._generation
+        # Fresh cancel event per generation.  The old event object stays
+        # set for any abandoned thread — _exec_bash captures a local
+        # reference so subprocesses from old generations are still killed.
+        self._cancel_event = threading.Event()
        self._cancelled_partial_msg = None
        self.messages.append({"role": "user", "content": user_input})
        self._msg_tokens.append(max(1, int(len(user_input) / self._chars_per_token)))
@@ -1229,7 +1314,7 @@ class ChatSession:

        try:
            while True:
-                self._check_cancelled()
+                self._check_cancelled(my_generation)
                msgs = self._full_messages()

                if self.debug:
@@ -1239,10 +1324,19 @@ class ChatSession:
                self.ui.on_thinking_start()
                try:
                    stream = self._create_stream_with_retry(msgs)
-                    assistant_msg = self._stream_response(stream)
+                    assistant_msg = self._stream_response(stream, my_generation)
                finally:
+                    # Only clear if this generation is still active —
+                    # an orphaned thread must not clobber a newer stream.
+                    if self._generation == my_generation:
+                        self._cancel_stream = None
+                        self._cancel_ref.clear()
                    self.ui.on_thinking_stop()

+                # Bail if this generation was superseded (force cancel).
+                if self._generation != my_generation:
+                    return
+
                self._update_token_table(assistant_msg)
                self.messages.append(assistant_msg)
                self._msg_tokens.append(
@@ -1295,6 +1389,8 @@ class ChatSession:
                            f"\n[Auto-compacting: prompt exceeds {pct_display}% of context window]"
                        )
                        self._compact_messages(auto=True)
+                        # Update status bar with post-compaction token counts
+                        self._print_status_line()
                    # Auto-title session after first exchange
                    if not self._title_generated:
                        self._title_generated = True
@@ -1308,6 +1404,51 @@ class ChatSession:
                # Execute tool calls (potentially in parallel)
                self._emit_state("running")
                results, user_feedback = self._execute_tools(tool_calls)
+
+                # Bail if generation was superseded during tool execution.
+                if self._generation != my_generation:
+                    return
+
+                # Repeat detection: warn when a tool is called with identical args.
+                # Skip error outputs — retrying a failed tool is valid.
+                # Skip JSON outputs (MCP structured results) — appending
+                # text would corrupt the payload.
+                _tc_by_id = {c["id"]: c for c in tool_calls}
+                _repeat_detected = False
+                _error_prefixes = ("Error", "JSON parse error", "Unknown tool", "Command timed out")
+                for i, (tc_id, output) in enumerate(results):
+                    tc = _tc_by_id.get(tc_id)
+                    if tc and isinstance(output, str) and not output.startswith(_error_prefixes):
+                        raw = tc["function"]["name"] + ":" + tc["function"]["arguments"]
+                        sig = hashlib.sha256(raw.encode()).hexdigest()
+                        is_json = output.lstrip().startswith(("{", "["))
+                        if sig in self._recent_tool_sigs:
+                            _repeat_detected = True
+                            if not is_json:
+                                output += (
+                                    "\n\n⚠ Warning: this is an identical repeat of a "
+                                    "previous tool call. The result is the same. "
+                                    "Try a different approach."
+                                )
+                                results[i] = (tc_id, output)
+                            self.ui.on_info(
+                                f"{GRAY}[repeat: {tc['function']['name']}() "
+                                f"called with same arguments]{RESET}"
+                            )
+                        self._recent_tool_sigs.add(sig)
+                if _repeat_detected:
+                    # Reset so the model gets a clean slate after the warning.
+                    # If it repeats again, a new warning fires.
+                    self._recent_tool_sigs.clear()
+                    if self._mem_cfg.nudges and should_nudge(
+                        "repeat",
+                        self._metacog_state,
+                        message_count=len(self.messages),
+                        cooldown_secs=self._mem_cfg.nudge_cooldown,
+                    ):
+                        self._pending_nudge.append(("repeat", format_nudge("repeat")))
+                        self._init_system_messages()
+
                # Map tool_call_id → tool name for logging
                _tc_names = {c["id"]: c.get("function", {}).get("name", "") for c in tool_calls}
                for tc_id, output in results:
@@ -1390,13 +1531,17 @@ class ChatSession:
                        cooldown_secs=self._mem_cfg.nudge_cooldown,
                    )
                ):
-                    self._pending_nudge.append(format_nudge("tool_error"))
+                    self._pending_nudge.append(("tool_error", format_nudge("tool_error")))
                    self._init_system_messages()
                # Inject user feedback from approval prompt (e.g. "y, use full path")
                if user_feedback:
                    self.messages.append({"role": "user", "content": user_feedback})
                    self._msg_tokens.append(max(1, int(len(user_feedback) / self._chars_per_token)))
        except GenerationCancelled:
+            # If a newer send() has started (force cancel), this thread is
+            # orphaned — skip all message mutations and state changes.
+            if self._generation != my_generation:
+                return
            # Cooperative cancellation — preserve partial content if available.
            if self._cancelled_partial_msg:
                # _stream_response was interrupted — save partial assistant msg
@@ -1425,7 +1570,8 @@ class ChatSession:
                    self.messages.pop()
                    if self._msg_tokens:
                        self._msg_tokens.pop()
-            self._cancel_event.clear()
+            # No need to clear _cancel_event — it's replaced per-generation
+            # in send(), so this generation's event is simply discarded.
            self.ui.on_info("[Generation cancelled]")
            self._emit_state("idle")
            # Do NOT re-raise — return normally so server worker thread
@@ -1470,7 +1616,9 @@ class ChatSession:
    _THINK_CLOSE_TAGS = ("</think>", "</reasoning>")
    _MAX_TAG_LEN = max(len(t) for t in _THINK_OPEN_TAGS + _THINK_CLOSE_TAGS)

-    def _stream_response(self, stream: Iterator[StreamChunk]) -> dict[str, Any]:
+    def _stream_response(
+        self, stream: Iterator[StreamChunk], my_generation: int = 0
+    ) -> dict[str, Any]:
        """Stream response, dispatching tokens to the UI as they arrive.

        Handles two reasoning delivery mechanisms:
@@ -1561,7 +1709,13 @@ class ChatSession:
        finish_reason = None
        try:
            for chunk in stream:
-                self._check_cancelled()
+                # _cancel_stream is set eagerly by _CancelRef.append() when the
+                # provider creates the SDK stream handle (before the first chunk
+                # is returned).  This fallback handles providers that use a
+                # plain list for cancel_ref (e.g. some test fakes).
+                if self._cancel_ref and self._cancel_stream is None:
+                    self._cancel_stream = self._cancel_ref[0]
+                self._check_cancelled(my_generation)
                # Track finish_reason (e.g. "stop", "length", "tool_calls")
                if chunk.finish_reason:
                    finish_reason = chunk.finish_reason
@@ -1669,12 +1823,28 @@ class ChatSession:
            self.ui.on_stream_end()
            partial: dict[str, Any] = {"role": "assistant"}
            partial_content = "".join(content_parts)
-            partial["content"] = partial_content or None
+            partial["content"] = partial_content or ""
            # Deliberately omit tool_calls — they are incomplete
            if provider_blocks:
                partial["_provider_content"] = provider_blocks
            self._cancelled_partial_msg = partial
            raise
+        except Exception:
+            # cancel() closed the underlying SDK stream, aborting the HTTP
+            # connection.  The blocked next() call on the iterator raises a
+            # transport-level error (httpx, httpcore, etc.).  Convert to
+            # GenerationCancelled if a cancel was requested.
+            if self._cancel_event.is_set():
+                if pending:
+                    _flush_text(pending, in_think)
+                self.ui.on_stream_end()
+                partial = {"role": "assistant"}
+                partial["content"] = "".join(content_parts) or ""
+                if provider_blocks:
+                    partial["_provider_content"] = provider_blocks
+                self._cancelled_partial_msg = partial
+                raise GenerationCancelled() from None
+            raise

        # Flush any remaining buffered text
        if pending:
@@ -1700,12 +1870,10 @@ class ChatSession:
        msg: dict[str, Any] = {"role": "assistant"}

        content = "".join(content_parts)
-        if content:
-            msg["content"] = content
-        else:
-            msg["content"] = None
+        msg["content"] = content or ""

        if tool_calls_acc:
+            self._ensure_tool_call_ids(tool_calls_acc)
            msg["tool_calls"] = [tool_calls_acc[i] for i in sorted(tool_calls_acc)]

        # Store raw provider content blocks for multi-turn preservation
@@ -2023,6 +2191,7 @@ class ChatSession:
        self.messages = [summary_user, summary_asst]
        # File contents are gone after compaction — force re-read before edit_file
        self._read_files.clear()
+        self._recent_tool_sigs.clear()

        # Rebuild token table
        su_tok = max(1, int(self._msg_char_count(summary_user) / self._chars_per_token))
@@ -2030,6 +2199,14 @@ class ChatSession:
        self._msg_tokens = [su_tok, sa_tok]
        after_tokens = self._system_tokens + sum(self._msg_tokens)

+        # Update usage estimate so the status bar reflects post-compaction state
+        if self._last_usage:
+            self._last_usage = {
+                **self._last_usage,
+                "prompt_tokens": after_tokens,
+                "total_tokens": after_tokens,
+            }
+
        self.ui.on_info(f"[compacted: ~{before_tokens:,} -> ~{after_tokens:,} tokens]")
        separator = "\u2500" * 60
        lines = [separator]
@@ -2074,20 +2251,24 @@ class ChatSession:
    def _evaluate_intent(
        self,
        items: list[dict[str, Any]],
-    ) -> None:
+    ) -> threading.Event | None:
        """Run intent validation on pending approval items.

        Attaches heuristic verdicts to items immediately.  Spawns the
        async LLM judge that delivers final verdicts via UI callback.
+
+        Returns a cancel event that, when set, tells the daemon judge
+        thread to abandon remaining work.  Callers should set this
+        after the user has made an approval decision.
        """
        judge = self._ensure_judge()
        if not judge:
-            return
+            return None

        # Only evaluate items that need approval and aren't errors
        pending = [it for it in items if it.get("needs_approval") and not it.get("error")]
        if not pending:
-            return
+            return None

        # Build func_args from tool-specific item keys so the heuristic
        # engine can pattern-match on argument content.
@@ -2125,16 +2306,20 @@ class ChatSession:
            except Exception:
                log.debug("judge.verdict_delivery_failed", exc_info=True)

+        cancel_event = threading.Event()
        heuristic_verdicts = judge.evaluate(
            pending,
            list(self.messages),  # snapshot — daemon thread must not see mutations
            callback=_on_verdict,
+            cancel_event=cancel_event,
        )

        # Attach heuristic verdicts to items for the approval UI
        for item, verdict in zip(pending, heuristic_verdicts, strict=True):
            item["_heuristic_verdict"] = verdict.to_dict()

+        return cancel_event
+
    def _evaluate_output(self, call_id: str, output: str, func_name: str) -> str:
        """Run the output guard on tool result text.

@@ -2184,12 +2369,20 @@ class ChatSession:
        # Phase 1: prepare all tool calls
        items = [self._prepare_tool(tc) for tc in tool_calls]

-        # Intent validation (advisory, non-blocking)
-        self._evaluate_intent(items)
+        # Intent validation (advisory, non-blocking).
+        # Cancel any prior judge thread before spawning a new one.
+        if self._judge_cancel_event is not None:
+            self._judge_cancel_event.set()
+        judge_cancel = self._evaluate_intent(items)
+        self._judge_cancel_event = judge_cancel  # track for close()

        # Phase 2: approve via UI
        self._emit_state("attention")
-        approved, user_feedback = self.ui.approve_tools(items)
+        try:
+            approved, user_feedback = self.ui.approve_tools(items)
+        finally:
+            if judge_cancel:
+                judge_cancel.set()  # user decided (or disconnected) — stop judge
        self._emit_state("running")
        if not approved:
            # Mark all pending items as denied
@@ -2207,7 +2400,7 @@ class ChatSession:
                memory_count=self._visible_memory_count(),
                cooldown_secs=self._mem_cfg.nudge_cooldown,
            ):
-                self._pending_nudge.append(format_nudge("denial"))
+                self._pending_nudge.append(("denial", format_nudge("denial")))
                self._init_system_messages()

        # Phase 3: execute (check cancellation before starting)
@@ -2216,7 +2409,11 @@ class ChatSession:
        def run_one(
            item: dict[str, Any],
        ) -> tuple[str, str | list[dict[str, Any]]]:
+            self._check_cancelled()
            if item.get("error"):
+                self.ui.on_tool_result(
+                    item["call_id"], item.get("func_name", "unknown"), item["error"]
+                )
                return item["call_id"], item["error"]
            if item.get("denied"):
                return item["call_id"], item.get("denial_msg", "Denied by user")
@@ -2229,7 +2426,7 @@ class ChatSession:
                func = item.get("func_name", "unknown")
                msg = f"Error executing {func}: {e}"
                log.warning("tool_exec.failed", tool=func, error=str(e), exc_info=True)
-                self.ui.on_error(msg)
+                self.ui.on_tool_result(item["call_id"], func, msg)
                return item["call_id"], msg

        if len(items) == 1:
@@ -2308,10 +2505,23 @@ class ChatSession:

        return results, user_feedback

+    @staticmethod
+    def _ensure_tool_call_ids(tool_calls: list[dict[str, Any]] | dict[int, dict[str, Any]]) -> None:
+        """Fill in missing tool call IDs with synthetic UUIDs.
+
+        Some local servers (llama.cpp, older vLLM) omit or leave the id
+        blank; an empty tool_call_id corrupts subsequent turns because
+        the matching tool-result message can't reference the call.
+        """
+        items = tool_calls.values() if isinstance(tool_calls, dict) else tool_calls
+        for tc in items:
+            if not tc.get("id"):
+                tc["id"] = f"call_{uuid.uuid4().hex}"
+
    def _prepare_tool(self, tc: dict[str, Any]) -> dict[str, Any]:
        """Parse a tool call and prepare preview info for display."""
        call_id = tc["id"]
-        func_name = tc["function"]["name"]
+        func_name = tc["function"]["name"].strip()
        raw_args = tc["function"]["arguments"]

        try:
@@ -2347,13 +2557,32 @@ class ChatSession:
                    args = {pk: raw_args}
            if args is None:
                preview = raw_args[:4000] + ("..." if len(raw_args) > 4000 else "")
+                # Surface to user so they can see what the model produced
+                self.ui.on_error(
+                    f"Malformed tool call from model: {func_name}() — "
+                    f"could not parse arguments as JSON.\n"
+                    f"  Raw: {raw_args[:200]}"
+                )
+                # Build a hint for the model including expected parameter
+                # names so it can self-correct on retry.
+                expected = PRIMARY_KEY_MAP.get(func_name, "")
+                hint = (
+                    f' Expected valid JSON, e.g. {{"{expected}": "..."}}'
+                    if expected
+                    else " Arguments must be valid JSON."
+                )
                return {
                    "call_id": call_id,
                    "func_name": func_name,
                    "header": f"\u2717 {func_name}: {exc}",
                    "preview": f"    {RED}{preview}{RESET}",
                    "needs_approval": False,
-                    "error": f"JSON parse error: {exc}\nRaw arguments: {raw_args[:500]}",
+                    "error": (
+                        f"JSON parse error for tool '{func_name}': {exc}\n"
+                        f"Raw arguments: {raw_args[:500]}\n"
+                        f"{hint}\n"
+                        f"Please retry with correctly formatted JSON arguments."
+                    ),
                }

        preparers = {
@@ -2382,13 +2611,21 @@ class ChatSession:
            # Check if this is an MCP tool
            if self._mcp_client and self._mcp_client.is_mcp_tool(func_name):
                return self._prepare_mcp_tool(call_id, func_name, args)
+            self.ui.on_error(f"Model called unknown tool: {func_name!r}")
+            available = list(preparers)
+            if self._mcp_client:
+                available.extend(sorted(self._mcp_client._tool_map))
            return {
                "call_id": call_id,
                "func_name": func_name,
                "header": f"\u2717 Unknown tool: {func_name}",
                "preview": "",
                "needs_approval": False,
-                "error": f"Unknown tool: {func_name}",
+                "error": (
+                    f"Unknown tool: {func_name!r}. "
+                    f"Available tools: {', '.join(available)}. "
+                    f"Use one of the listed tool names exactly."
+                ),
            }
        assert args is not None  # guaranteed by the early return on args is None above
        return preparer(call_id, args)
@@ -2982,8 +3219,11 @@ class ChatSession:
            n += count_structured_memories(scope="user", scope_id=self._user_id)
        return n

-    def _check_metacognitive_nudge(self, user_message: str) -> str | None:
-        """Check if a metacognitive nudge should be injected."""
+    def _check_metacognitive_nudge(self, user_message: str) -> tuple[str, str] | None:
+        """Check if a metacognitive nudge should be injected.
+
+        Returns (nudge_type, nudge_text) or None.
+        """
        if not self._mem_cfg.nudges:
            return None
        mem_count = self._visible_memory_count()
@@ -2997,7 +3237,7 @@ class ChatSession:
            memory_count=mem_count,
            cooldown_secs=cd,
        ):
-            return format_nudge("start")
+            return ("start", format_nudge("start"))

        if detect_correction(user_message) and should_nudge(
            "correction",
@@ -3006,7 +3246,7 @@ class ChatSession:
            memory_count=mem_count,
            cooldown_secs=cd,
        ):
-            return format_nudge("correction")
+            return ("correction", format_nudge("correction"))

        if detect_completion(user_message) and should_nudge(
            "completion",
@@ -3015,7 +3255,7 @@ class ChatSession:
            memory_count=mem_count,
            cooldown_secs=cd,
        ):
-            return format_nudge("completion")
+            return ("completion", format_nudge("completion"))

        return None

@@ -3389,6 +3629,7 @@ class ChatSession:

    def _exec_mcp_tool(self, item: dict[str, Any]) -> tuple[str, str]:
        """Execute an MCP tool call via the MCPClientManager."""
+        self._check_cancelled()
        call_id: str = item["call_id"]
        func_name: str = item["mcp_func_name"]
        args: dict[str, Any] = item["mcp_args"]
@@ -3462,6 +3703,7 @@ class ChatSession:

    def _exec_read_resource(self, item: dict[str, Any]) -> tuple[str, str]:
        """Read an MCP resource by URI."""
+        self._check_cancelled()
        call_id: str = item["call_id"]
        uri: str = item["resource_uri"]

@@ -3539,6 +3781,7 @@ class ChatSession:

    def _exec_use_prompt(self, item: dict[str, Any]) -> tuple[str, str]:
        """Invoke an MCP prompt and return expanded messages."""
+        self._check_cancelled()
        call_id: str = item["call_id"]
        name: str = item["prompt_name"]
        arguments: dict[str, str] = item["prompt_arguments"]
@@ -3565,6 +3808,10 @@ class ChatSession:

    def _exec_bash(self, item: dict[str, Any]) -> tuple[str, str]:
        """Execute a bash command via temp script, streaming stdout."""
+        self._check_cancelled()
+        # Capture cancel event locally so force-cancel (which replaces
+        # _cancel_event with a fresh instance) doesn't disarm this check.
+        cancel = self._cancel_event
        call_id, command = item["call_id"], item["command"]
        try:
            with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
@@ -3581,6 +3828,8 @@ class ChatSession:
                    start_new_session=True,
                    env=scrubbed_env(),
                )
+                with self._procs_lock:
+                    self._active_procs.add(proc)
                # Drain stderr in background thread to avoid pipe deadlock
                stderr_lines: list[str] = []

@@ -3618,7 +3867,7 @@ class ChatSession:
                        except Exception:
                            log.debug("UI callback error during tool output", exc_info=True)
                        # Check cancellation during long-running commands
-                        if self._cancel_event.is_set():
+                        if cancel.is_set():
                            with contextlib.suppress(OSError, ProcessLookupError):
                                try:
                                    os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
@@ -3635,6 +3884,8 @@ class ChatSession:
                    log.warning("Process did not exit after SIGKILL, pid=%d", proc.pid)
                stderr_thread.join(timeout=5)
            finally:
+                with self._procs_lock:
+                    self._active_procs.discard(proc)
                os.unlink(script_path)

            if timed_out.is_set():
@@ -3655,11 +3906,11 @@ class ChatSession:

        except subprocess.TimeoutExpired:
            msg = f"Command timed out after {self.tool_timeout}s"
-            self.ui.on_error(msg)
+            self.ui.on_tool_result(call_id, "bash", msg)
            return call_id, msg
        except Exception as e:
            msg = f"Error executing command: {e}"
-            self.ui.on_error(msg)
+            self.ui.on_tool_result(call_id, "bash", msg)
            return call_id, msg

    def _exec_read_file(self, item: dict[str, Any]) -> tuple[str, str | list[dict[str, Any]]]:
@@ -3679,10 +3930,14 @@ class ChatSession:
                all_lines = f.readlines()
        except FileNotFoundError:
            self._read_files.discard(resolved)
-            return call_id, f"Error: {path} not found"
+            msg = f"Error: {path} not found"
+            self.ui.on_tool_result(call_id, "read_file", msg)
+            return call_id, msg
        except Exception as e:
            self._read_files.discard(resolved)
-            return call_id, f"Error reading {path}: {e}"
+            msg = f"Error reading {path}: {e}"
+            self.ui.on_tool_result(call_id, "read_file", msg)
+            return call_id, msg

        self._read_files.add(resolved)
        total_lines = len(all_lines)
@@ -3718,7 +3973,9 @@ class ChatSession:
                size = os.path.getsize(path)
            except OSError as e:
                self._read_files.discard(resolved)
-                return call_id, f"Error: {path}: {e}"
+                msg = f"Error: {path}: {e}"
+                self.ui.on_tool_result(call_id, "read_file", msg)
+                return call_id, msg
            self._read_files.add(resolved)
            desc = f"image (no vision, {size:,} bytes)"
            self.ui.on_tool_result(call_id, "read_file", desc)
@@ -3732,19 +3989,25 @@ class ChatSession:
                raw = f.read()
        except FileNotFoundError:
            self._read_files.discard(resolved)
-            return call_id, f"Error: {path} not found"
+            msg = f"Error: {path} not found"
+            self.ui.on_tool_result(call_id, "read_file", msg)
+            return call_id, msg
        except Exception as e:
            self._read_files.discard(resolved)
-            return call_id, f"Error reading {path}: {e}"
+            msg = f"Error reading {path}: {e}"
+            self.ui.on_tool_result(call_id, "read_file", msg)
+            return call_id, msg

        if len(raw) > _IMAGE_SIZE_CAP:
            self._read_files.discard(resolved)
            size_mb = len(raw) / (1024 * 1024)
            cap_mb = _IMAGE_SIZE_CAP / (1024 * 1024)
-            return call_id, (
+            msg = (
                f"Error: image {path} is {size_mb:.1f} MB, "
                f"exceeds {cap_mb:.0f} MB limit for vision."
            )
+            self.ui.on_tool_result(call_id, "read_file", msg)
+            return call_id, msg

        self._read_files.add(resolved)
        b64data = base64.b64encode(raw).decode("ascii")
@@ -3809,11 +4072,11 @@ class ChatSession:

        except subprocess.TimeoutExpired:
            msg = f"Search timed out after {self.tool_timeout}s"
-            self.ui.on_error(msg)
+            self.ui.on_tool_result(call_id, "search", msg)
            return call_id, msg
        except Exception as e:
-            msg = f"Search error: {e}"
-            self.ui.on_error(msg)
+            msg = f"Error: search failed: {e}"
+            self.ui.on_tool_result(call_id, "search", msg)
            return call_id, msg

    def _run_agent(
@@ -3927,6 +4190,7 @@ class ChatSession:
                "content": result.content or "",
            }
            if result.tool_calls:
+                self._ensure_tool_call_ids(result.tool_calls)
                msg_dict["tool_calls"] = result.tool_calls
            agent_messages.append(msg_dict)

@@ -3940,7 +4204,7 @@ class ChatSession:
            tool_names = {t["function"]["name"] for t in tools}
            for tc_dict in result.tool_calls:
                self._check_cancelled()
-                tool_name = tc_dict["function"]["name"]
+                tool_name = tc_dict["function"]["name"].strip()

                # Guard 1: block recursive agent calls.
                if tool_name in ("task_agent", "plan_agent"):
@@ -4234,7 +4498,7 @@ class ChatSession:
            {"role": "system", "content": self._plan_system_content()},
            {
                "role": "assistant",
-                "content": None,
+                "content": "",
                "tool_calls": [
                    {
                        "id": tc_id,
@@ -4361,9 +4625,13 @@ class ChatSession:
                return call_id, msg

        except Exception as e:
-            return call_id, f"Error: {e}"
+            msg = f"Error: {e}"
+            self.ui.on_tool_result(call_id, "memory", msg)
+            return call_id, msg

-        return call_id, "Error: unexpected action"
+        msg = "Error: unexpected action"
+        self.ui.on_tool_result(call_id, "memory", msg)
+        return call_id, msg

    def _exec_recall(self, item: dict[str, Any]) -> tuple[str, str]:
        """Search conversation history."""
@@ -4477,6 +4745,7 @@ class ChatSession:

    def _exec_notify(self, item: dict[str, Any]) -> tuple[str, str]:
        """Send a notification directly to the channel gateway via HTTP."""
+        self._check_cancelled()
        call_id = item["call_id"]

        if self._notify_count >= 5:
@@ -4861,6 +5130,7 @@ class ChatSession:

    def _exec_write_file(self, item: dict[str, Any]) -> tuple[str, str]:
        """Write content to a file, creating parent directories as needed."""
+        self._check_cancelled()
        call_id = item["call_id"]
        path, content, resolved = item["path"], item["content"], item["resolved"]
        try:
@@ -4872,7 +5142,9 @@ class ChatSession:
            self.ui.on_tool_result(call_id, "write_file", msg)
            return call_id, msg
        except Exception as e:
-            return call_id, f"Error writing {path}: {e}"
+            msg = f"Error writing {path}: {e}"
+            self.ui.on_tool_result(call_id, "write_file", msg)
+            return call_id, msg

    def _exec_edit_file(self, item: dict[str, Any]) -> tuple[str, str]:
        """Replace an exact string in a file (re-reads to avoid TOCTOU).
@@ -4880,6 +5152,7 @@ class ChatSession:
        When near_line is set, picks the occurrence nearest that line
        instead of requiring uniqueness.
        """
+        self._check_cancelled()
        call_id = item["call_id"]
        path, old_string, new_string = (
            item["path"],
@@ -4892,17 +5165,17 @@ class ChatSession:
                content = f.read()
            occurrences = find_occurrences(content, old_string)
            if len(occurrences) == 0:
-                return (
-                    call_id,
-                    f"Error: old_string no longer found in {path} (file changed)",
-                )
+                msg = f"Error: old_string no longer found in {path} (file changed)"
+                self.ui.on_tool_result(call_id, "edit_file", msg)
+                return call_id, msg
            if len(occurrences) > 1 and near_line is None:
                line_list = ", ".join(str(ln) for ln in occurrences)
-                return (
-                    call_id,
+                msg = (
                    f"Error: old_string found {len(occurrences)} times "
-                    f"at lines {line_list} (file changed)",
+                    f"at lines {line_list} (file changed)"
                )
+                self.ui.on_tool_result(call_id, "edit_file", msg)
+                return call_id, msg
            if near_line is not None and len(occurrences) > 1:
                # Replace only the occurrence nearest to near_line
                idx = pick_nearest(content, old_string, near_line)
@@ -4915,7 +5188,9 @@ class ChatSession:
            self.ui.on_tool_result(call_id, "edit_file", msg)
            return call_id, msg
        except Exception as e:
-            return call_id, f"Error writing {path}: {e}"
+            msg = f"Error writing {path}: {e}"
+            self.ui.on_tool_result(call_id, "edit_file", msg)
+            return call_id, msg

    def _exec_math(self, item: dict[str, Any]) -> tuple[str, str]:
        """Execute Python code in sandboxed subprocess."""
@@ -4923,14 +5198,13 @@ class ChatSession:
        output, is_error = execute_math_sandboxed(code, timeout=self.tool_timeout)
        output = self._truncate_output(output)

-        self.ui.on_tool_result(call_id, "math", output)
-
-        if is_error:
-            return call_id, f"Error:\n{output}"
-        return call_id, output if output else "(no output)"
+        result_msg = f"Error:\n{output}" if is_error else output if output else "(no output)"
+        self.ui.on_tool_result(call_id, "math", result_msg)
+        return call_id, result_msg

    def _exec_man(self, item: dict[str, Any]) -> tuple[str, str]:
        """Look up a man or info page."""
+        self._check_cancelled()
        call_id = item["call_id"]
        page = item["page"]
        section = item.get("section", "")
@@ -4972,9 +5246,13 @@ class ChatSession:
                    self.ui.on_tool_result(call_id, "man", msg)
                    return call_id, msg
        except FileNotFoundError:
-            return call_id, "Error: man command not available"
+            msg = "Error: man command not available"
+            self.ui.on_tool_result(call_id, "man", msg)
+            return call_id, msg
        except subprocess.TimeoutExpired:
-            return call_id, "Error: man page lookup timed out"
+            msg = "Error: man page lookup timed out"
+            self.ui.on_tool_result(call_id, "man", msg)
+            return call_id, msg

        text = self._truncate_output(text)

@@ -4984,6 +5262,7 @@ class ChatSession:

    def _exec_web_fetch(self, item: dict[str, Any]) -> tuple[str, str]:
        """Fetch a URL, then summarize/extract using an API call."""
+        self._check_cancelled()
        call_id, url = item["call_id"], item["url"]
        question = item.get("question", "Summarize the key content of this page.")

@@ -5005,16 +5284,16 @@ class ChatSession:
                text = text[: 10 * 1024 * 1024]

        except httpx.HTTPStatusError as e:
-            msg = f"Fetch failed: HTTP {e.response.status_code}"
-            self.ui.on_error(msg)
+            msg = f"Error: fetch failed: HTTP {e.response.status_code}"
+            self.ui.on_tool_result(call_id, "web_fetch", msg)
            return call_id, msg
        except (httpx.RequestError, ValueError) as e:
-            msg = f"Fetch failed: {e}"
-            self.ui.on_error(msg)
+            msg = f"Error: fetch failed: {e}"
+            self.ui.on_tool_result(call_id, "web_fetch", msg)
            return call_id, msg
        except Exception as e:
            msg = f"Error fetching URL: {e}"
-            self.ui.on_error(msg)
+            self.ui.on_tool_result(call_id, "web_fetch", msg)
            return call_id, msg

        if not text.strip():
@@ -5071,6 +5350,7 @@ class ChatSession:

    def _exec_web_search(self, item: dict[str, Any]) -> tuple[str, str]:
        """Search the web via the configured backend (Tavily, DDG, or MCP)."""
+        self._check_cancelled()
        call_id = item["call_id"]
        query = item["query"]
        max_results = item.get("max_results", 5)
@@ -5078,15 +5358,15 @@ class ChatSession:

        client = self._resolve_search_client()
        if not client:
-            msg = "Web search backend not available"
-            self.ui.on_error(msg)
+            msg = "Error: web search backend not available"
+            self.ui.on_tool_result(call_id, "web_search", msg)
            return call_id, msg

        try:
            output = client.search(query, max_results=max_results, topic=topic)
        except Exception as e:
-            msg = f"Web search failed: {e}"
-            self.ui.on_error(msg)
+            msg = f"Error: web search failed: {e}"
+            self.ui.on_tool_result(call_id, "web_search", msg)
            return call_id, msg

        self.ui.on_tool_result(call_id, "web_search", output)
@@ -5133,6 +5413,7 @@ class ChatSession:
        elif cmd == "/clear":
            self.messages.clear()
            self._read_files.clear()
+            self._recent_tool_sigs.clear()
            self._last_usage = None
            self._msg_tokens = []
            self.ui.on_info("Context cleared (messages preserved in database).")
@@ -5142,6 +5423,7 @@ class ChatSession:

            self.messages.clear()
            self._read_files.clear()
+            self._recent_tool_sigs.clear()
            self._last_usage = None
            self._msg_tokens = []
            self._ws_id = uuid.uuid4().hex
@@ -152,7 +152,7 @@ def reconstruct_messages(rows: list[Any], ws_id: str) -> list[dict[str, Any]]:
            messages.append({"role": "user", "content": content or ""})

        elif role == "assistant":
-            msg: dict[str, Any] = {"role": "assistant", "content": content}
+            msg: dict[str, Any] = {"role": "assistant", "content": content or ""}
            if provider_data:
                with contextlib.suppress(json.JSONDecodeError, TypeError):
                    msg["_provider_content"] = json.loads(provider_data)
@@ -79,7 +79,12 @@ class TLSClient:

            setup_metrics(self._event_dispatcher)
        except ImportError:
-            pass
+            pass  # prometheus_client or lacme.metrics missing
+        except ValueError as exc:
+            if "Duplicated timeseries" in str(exc):
+                log.debug("tls_metrics_already_registered")
+            else:
+                raise

    async def init(self) -> None:
        """Fetch CA root cert and request a service certificate.
@@ -220,7 +225,7 @@ class TLSClient:
        _require_lacme()
        from lacme.mtls import server_ssl_context

-        return server_ssl_context(  # type: ignore[no-any-return]
+        return server_ssl_context(  # type: ignore[no-any-return,unused-ignore]
            cert_pem=self._bundle.fullchain_pem,
            key_pem=self._bundle.key_pem,
            ca_cert_pem=self._ca_pem,
@@ -233,7 +238,7 @@ class TLSClient:
        _require_lacme()
        from lacme.mtls import client_ssl_context

-        return client_ssl_context(  # type: ignore[no-any-return]
+        return client_ssl_context(  # type: ignore[no-any-return,unused-ignore]
            cert_pem=self._bundle.cert_pem,
            key_pem=self._bundle.key_pem,
            ca_cert_pem=self._ca_pem,
@@ -50,6 +50,7 @@ from turnstone.api.schemas import (
    AuthLoginResponse,
    AuthSetupResponse,
    AuthStatusResponse,
+    DeleteSettingResponse,
    ListScheduleRunsResponse,
    ListSchedulesResponse,
    ScheduleInfo,
@@ -642,13 +643,16 @@ class AsyncTurnstoneConsole(_BaseClient):
            "PUT", f"/v1/api/admin/settings/{key}", json_body=body, response_model=SettingInfo
        )

-    async def delete_setting(self, key: str, *, node_id: str = "") -> StatusResponse:
+    async def delete_setting(self, key: str, *, node_id: str = "") -> DeleteSettingResponse:
        """Reset a setting to its default value."""
        params: dict[str, Any] = {}
        if node_id:
            params["node_id"] = node_id
        return await self._request(
-            "DELETE", f"/v1/api/admin/settings/{key}", params=params, response_model=StatusResponse
+            "DELETE",
+            f"/v1/api/admin/settings/{key}",
+            params=params,
+            response_model=DeleteSettingResponse,
        )

    # -- MCP servers -------------------------------------------------------
@@ -1205,7 +1209,7 @@ class TurnstoneConsole:
    def update_setting(self, key: str, value: Any, *, node_id: str = "") -> SettingInfo:
        return self._runner.run(self._async.update_setting(key, value, node_id=node_id))

-    def delete_setting(self, key: str, *, node_id: str = "") -> StatusResponse:
+    def delete_setting(self, key: str, *, node_id: str = "") -> DeleteSettingResponse:
        return self._runner.run(self._async.delete_setting(key, node_id=node_id))

    # -- MCP servers -------------------------------------------------------
@@ -162,11 +162,14 @@ class AsyncTurnstoneServer(_BaseClient):
            response_model=StatusResponse,
        )

-    async def cancel(self, ws_id: str) -> StatusResponse:
+    async def cancel(self, ws_id: str, *, force: bool = False) -> StatusResponse:
+        body: dict[str, object] = {"ws_id": ws_id}
+        if force:
+            body["force"] = True
        return await self._request(
            "POST",
            "/v1/api/cancel",
-            json_body={"ws_id": ws_id},
+            json_body=body,
            response_model=StatusResponse,
        )

@@ -473,8 +476,8 @@ class TurnstoneServer:
    def command(self, *, ws_id: str, command: str) -> StatusResponse:
        return self._runner.run(self._async.command(ws_id=ws_id, command=command))

-    def cancel(self, ws_id: str) -> StatusResponse:
-        return self._runner.run(self._async.cancel(ws_id))
+    def cancel(self, ws_id: str, *, force: bool = False) -> StatusResponse:
+        return self._runner.run(self._async.cancel(ws_id, force=force))

    # -- streaming -----------------------------------------------------------

@@ -389,7 +389,24 @@ class WebUI:
            self._ws_current_activity = ""
            self._ws_activity_state = ""
        self._broadcast_activity()
-        self._enqueue({"type": "tool_result", "call_id": call_id, "name": name, "output": output})
+        is_error = isinstance(output, str) and (
+            output.startswith("Error")
+            or output.startswith("Command timed out")
+            or output.startswith("Search timed out")
+            or output.startswith("Unknown tool:")
+            or output.startswith("JSON parse error:")
+            or output.startswith("MCP prompt timed out")
+            or output.startswith("MCP prompt error")
+        )
+        event: dict[str, Any] = {
+            "type": "tool_result",
+            "call_id": call_id,
+            "name": name,
+            "output": output,
+        }
+        if is_error:
+            event["is_error"] = True
+        self._enqueue(event)

    def on_tool_output_chunk(self, call_id: str, chunk: str) -> None:
        self._enqueue({"type": "tool_output_chunk", "call_id": call_id, "chunk": chunk})
@@ -624,13 +641,22 @@ def _build_history(
                }
                for tc in msg["tool_calls"]
            ]
-        # Detect denied/blocked tool results by their content prefix.
+        # Detect denied/blocked/errored tool results by their content prefix.
        if msg.get("role") == "tool":
            content = msg.get("content", "")
-            if isinstance(content, str) and (
-                content.startswith("Denied by user") or content.startswith("Blocked")
-            ):
-                entry["denied"] = True
+            if isinstance(content, str):
+                if content.startswith("Denied by user") or content.startswith("Blocked"):
+                    entry["denied"] = True
+                elif (
+                    content.startswith("Error")
+                    or content.startswith("Command timed out")
+                    or content.startswith("Search timed out")
+                    or content.startswith("Unknown tool:")
+                    or content.startswith("JSON parse error:")
+                    or content.startswith("MCP prompt timed out")
+                    or content.startswith("MCP prompt error")
+                ):
+                    entry["is_error"] = True
        history.append(entry)

    # Propagate denial from tool results to their parent assistant entry.
@@ -1116,6 +1142,15 @@ async def send_message(request: Request) -> JSONResponse:
        return JSONResponse({"error": "Unknown workstream"}, status_code=404)
    # Atomically check-and-start to prevent two concurrent workers on the
    # same session (ChatSession.send() is not thread-safe).
+    # If cancel was requested, poll briefly for the worker to exit before
+    # rejecting.  Snapshot the thread ref since force-cancel can set it to
+    # None concurrently.  Uses async sleep to avoid blocking the event loop.
+    worker = ws.worker_thread
+    if worker and worker.is_alive() and ws.session and ws.session._cancel_event.is_set():
+        for _ in range(30):  # up to 3s in 100ms steps
+            await asyncio.sleep(0.1)
+            if not worker.is_alive():
+                break
    with ws._lock:
        if ws.worker_thread and ws.worker_thread.is_alive():
            ui._enqueue(
@@ -1130,16 +1165,21 @@ async def send_message(request: Request) -> JSONResponse:

        def run() -> None:
            assert ui is not None
+            me = threading.current_thread()
            try:
                session.send(message)
            except GenerationCancelled:
                # Safety net — send() normally handles this internally.
-                ui._enqueue({"type": "stream_end"})
-                ui.on_state_change("idle")
+                # If this thread was force-abandoned, ws.worker_thread will
+                # have been set to None — don't emit spurious events.
+                if ws.worker_thread is me:
+                    ui._enqueue({"type": "stream_end"})
+                    ui.on_state_change("idle")
            except Exception as e:
-                ui.on_error(f"Error: {e}")
-                ui._enqueue({"type": "stream_end"})
-                ui.on_state_change("error")
+                if ws.worker_thread is me:
+                    ui.on_error(f"Error: {e}")
+                    ui._enqueue({"type": "stream_end"})
+                    ui.on_state_change("error")

        t = threading.Thread(target=run, daemon=True)
        ws.worker_thread = t
@@ -1211,6 +1251,7 @@ async def cancel_generation(request: Request) -> JSONResponse:
    session = ws.session
    if session is None:
        return JSONResponse({"error": "No session"}, status_code=400)
+    force = body.get("force", False) is True
    # Only act if generation is actually in progress
    if ws.worker_thread and ws.worker_thread.is_alive():
        # Set the cooperative cancel flag (worker thread checks at checkpoints)
@@ -1218,8 +1259,19 @@ async def cancel_generation(request: Request) -> JSONResponse:
        # Unblock any pending approval/plan review waits
        ui.resolve_approval(False, "Cancelled by user")
        ui.resolve_plan("reject")
-        # Emit cancelled SSE event so SDK consumers get a typed signal
-        ui._enqueue({"type": "cancelled"})
+        if force:
+            # Force cancel: abandon the stuck worker thread (daemon, will
+            # die on process exit or stream timeout) and emit stream_end
+            # so the UI and session recover immediately.  The per-generation
+            # cancel event stays set so the abandoned thread still kills
+            # subprocesses at its next checkpoint.
+            with ws._lock:
+                ws.worker_thread = None
+            ui._enqueue({"type": "stream_end"})
+            ui.on_state_change("idle")
+        else:
+            # Emit cancelled SSE event so SDK consumers get a typed signal
+            ui._enqueue({"type": "cancelled"})
    return JSONResponse({"status": "ok"})


--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Patrick Buckley	5e09940745	bump version to 0.9.1	2026-03-28 20:32:20 -07:00
renovate[bot]	72bd62d3d8	chore(deps): update dependency katex to v0.16.44 (#204 ) * chore(deps): update dependency katex to v0.16.44 * chore: download vendored JS files --------- Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-03-28 20:31:00 -07:00
Patrick Buckley	d31f89b2e3	ci: let Renovate rebase over github-actions[bot] commits	2026-03-28 20:30:23 -07:00
Patrick Buckley	9bae8f1a10	ci: auto-download vendored JS files on Renovate PRs Add vendor-js workflow that triggers on Renovate PRs touching pyproject.toml — detects version changes, runs update-vendored-js.sh, and commits the actual files back to the PR branch. Supports manual dispatch via pr_number input for one-off runs.	2026-03-28 20:28:06 -07:00
renovate[bot]	a012561195	chore(deps): lock file maintenance (#205 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-03-28 20:24:53 -07:00
Patrick Buckley	4198b59a0f	fix: eager cancel_ref registration, SDK type drift, force-cancel tests (#203 ) Providers now register the SDK stream handle eagerly (before returning the iterator) instead of lazily inside a generator body. This closes the window where cancel() couldn't abort a blocked HTTP read because the stream handle wasn't populated yet. - OpenAI: yield from → return (HTTP call + cancel_ref happen eagerly) - Anthropic: split into eager __enter__ + _iter_with_cleanup generator with defensive __exit__ on __enter__ failure - Console SDK: delete_setting() return type fixed from StatusResponse to DeleteSettingResponse (matching actual endpoint response) - 2 new threaded force-cancel integration tests verifying orphaned threads don't mutate messages and new generations succeed - Updated _CancelRef docstring, test robustness (assert on wait)	2026-03-28 20:05:57 -07:00
Patrick Buckley	4f6ef13ce9	fix: cancel button race condition with stream abort and force cancel (#202 ) The cancel endpoint emitted a 'cancelled' SSE event before the worker thread terminated. The frontend transitioned to "send" mode prematurely, so the next send got rejected with "Already processing a request." Backend: - Providers expose SDK stream handle via cancel_ref parameter so cancel() can close the HTTP connection and unblock iteration - Generation counter prevents orphaned threads from mutating messages or clearing cancel state after force cancel - _check_cancelled() added between retry attempts in _try_stream - Server polls (async, non-blocking) for cancelled worker to exit - Force cancel (force:true) abandons stuck worker, keeps cancel event set so subprocesses are killed, guards against spurious SSE events Frontend: - 'cancelled' shows "Cancelling..." then escalates to "Force Stop" after 2s for a harder cancel that abandons the worker immediately - 10s safety timeout auto-recovers if stream_end never arrives - busy_error re-enables stop button instead of showing send - Timeout cleanup in disconnectSSE, stream_end, and force .then() - Layout shift prevention (min-width, white-space: nowrap) - aria-label updates for accessibility Tests: - 7 new tests: stream close, error suppression, cancel_ref population, transport error conversion, non-cancel exception propagation, retry cancellation check	2026-03-28 19:26:37 -07:00
Patrick Buckley	52716ed611	feat: detect repeated tool calls and nudge model to try different approach (#201 ) When a model calls the same tool with identical arguments as a previous call, append a warning to the tool result and inject a metacognitive nudge. This breaks loops where small local models get stuck repeating the same action (e.g. running the same bash command 3+ times). The repeat signature set is cleared after a warning fires, giving the model a clean slate. Also cleared on conversation compaction. Ref: #186	2026-03-28 16:18:12 -07:00
Patrick Buckley	6c9a7d7351	fix: harden tool call handling for local model servers (#200 ) * fix: harden tool call handling for local model servers Local models (Qwen 3.5 9B, etc.) via llama.cpp produce tool calls with empty IDs, whitespace-padded names, and malformed JSON arguments. These defensive gaps caused cascading conversation corruption and silent failures. - Strip whitespace from tool names in both main and agent paths - Generate synthetic UUIDs when tool call IDs are empty/null - Surface malformed tool call errors to the user via on_error - Give the model actionable hints (expected JSON format, available tools) so it can self-correct on retry - Surface metacognition nudge types to UI via on_info Ref: #186, #117 * refactor: extract _ensure_tool_call_ids helper, include MCP tools in error Address Copilot review feedback on PR #200: - Extract duplicated ID fixup into _ensure_tool_call_ids() static method - Tests now exercise the actual helper instead of reimplementing the logic - Unknown tool error now includes MCP tool names alongside builtins	2026-03-28 15:48:11 -07:00
Patrick Buckley	3518f7953c	fix: prevent 100% CPU spin from unreachable HTTP MCP servers (#199 ) When an HTTP MCP server is unreachable and TCP connect fails immediately (ECONNREFUSED, DNS failure), the anyio task group inside streamablehttp_client produces a CancelledError that escapes asyncio.wait_for and leaves orphaned cancel-scope tasks in an infinite _deliver_cancellation loop (~800K callbacks/sec). Three-part fix: - TCP pre-flight probe (5s timeout) before entering the anyio transport context — fails fast on unreachable servers, avoiding the bug entirely - Catch CancelledError in _connect_one with current_task().cancelling() check to distinguish stray anyio cancels from real shutdown - _safe_close_stack helper with bounded timeout that never raises, preventing cleanup errors from masking the original exception	2026-03-28 15:19:04 -07:00
Patrick Buckley	48769e5a97	fix: gate read_resource and use_prompt tools on MCP server availability (#198 ) These built-in tools were always sent to the LLM even when no MCP servers were connected, wasting model turns on calls that would always return errors. Now gated per-request in _get_active_tools() — same pattern as the existing web_search gating — using resource_count and prompt_count for granular filtering.	2026-03-28 14:38:53 -07:00
Patrick Buckley	adb4ff6399	fix: resolve pre-existing test failures, stale type ignores, and warnings (#197 ) - TLS: suppress no-any-return + unused-ignore on lacme mtls helpers (lacme stubs typed locally but not in CI) - TLS: catch duplicate Prometheus metric registration specifically (not blanket ValueError) so real setup errors still propagate - Discord: add missing storage=None to _make_bot mock (policy evaluation path accesses self.storage) - Web search: patch _ddg_available in gating test so ddgs availability doesn't mask the Tavily-only test path - Bridge stress: close real httpx client before replacing with mock so daemon threads don't make real HTTP calls or leak connections - README: comment out tavily_key placeholder in example config	2026-03-28 14:24:53 -07:00
Patrick Buckley	131a1ec943	fix: stream tool errors in real-time with visual error indicator (#196 ) * fix: stream tool errors in real-time with visual error indicator Tool executors that hit errors (file not found, timeout, write failure, etc.) were returning error strings without calling ui.on_tool_result(), so no SSE event was emitted to the browser during streaming. Errors only appeared after page refresh via history rebuild. Now all error paths call on_tool_result() so errors stream in real-time. Added visual error state: tool blocks with errors get a red left border, red "✗ error" badge, and red error text — matching the existing denied state pattern but distinct from it. Error detection uses prefix matching ("Error", "Command timed out", "Search timed out") both server-side (is_error flag on SSE event + _build_history) and client-side (regex fallback). Affected tools: bash, read_file, write_file, edit_file, search, math, man, memory, web_fetch, web_search, plus the run_one catch-all and prepare-error paths. * review: expand error prefix detection per copilot feedback Add Unknown tool, JSON parse error, MCP prompt timed out, and MCP prompt error to the is_error prefix list in on_tool_result, _build_history, and the frontend regex. These error messages were confirmed in the codebase but missing from the detection heuristic.	2026-03-28 00:21:11 -07:00
Patrick Buckley	1cded9b430	chore: bump version to 0.9.0	2026-03-27 21:24:49 -07:00
Patrick Buckley	62c741eb8a	fix: prevent assistant messages with content=None from reaching OpenAI API (#195 ) Replayed or cancelled conversations could produce assistant messages with content=None and no tool_calls, which OpenAI-compatible APIs reject with a 400. Fix at three layers for defense in depth: - session.py: use empty string instead of None when building assistant messages (streaming + cancellation paths) - _utils.py: normalise content on DB load in reconstruct_messages() - _openai.py: add _sanitize_messages() catch-all at provider boundary Closes #194	2026-03-27 21:22:39 -07:00
Patrick Buckley	3362917e1e	chore(deps): update vendored KaTeX 0.16.42 → 0.16.43 (#193 )	2026-03-27 10:54:21 -07:00
renovate[bot]	698cbbf988	chore(deps): lock file maintenance (#192 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-03-26 20:55:46 -07:00
renovate[bot]	e47a08b7bc	chore(deps): update ghcr.io/astral-sh/uv docker tag to v0.11.2 (#191 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-03-26 20:55:00 -07:00
renovate[bot]	aaa427debd	chore(deps): update dependency vitest to v4.1.2 (#190 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-03-26 20:54:58 -07:00
renovate[bot]	611af76971	chore(deps): pin dependencies (#188 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-03-26 20:54:49 -07:00
Patrick Buckley	bbe28ecab3	fix: cancel LLM judge daemon when user approves/denies tools (#187 ) When the LLM judge is enabled and the user makes rapid approval decisions, judge daemon threads pile up competing for the inference server, causing timeouts. Pass a threading.Event from session to the judge — set on approval — so the daemon abandons remaining work within ~1s, including shutting down the executor to kill in-flight API calls.	2026-03-26 18:10:23 -07:00