thinkpool-pair 0.7.327 → 0.7.328

package/README.md

@@ -1,235 +1,272 @@
-# thinkpool-pair — the ThinkPool Code bridge
+# `thinkpool-pair`
 
-Pair two people on one live **coding agent** — running **any model you choose**
-(Claude, GPT, Gemini, Llama, or a local model) — in a ThinkPool Code room. Both
-people see the live stream and can both drive it, no copy/paste.
+`thinkpool-pair` connects coding agents running on a machine you control to a
+Thinkpool Code room. Both people in the room can watch and steer the visible
+agent lanes from a browser or phone.
 
-> A web page can't read your terminal directly (browser security). This tiny
-> helper is the bridge: it runs CLIs in PTYs and streams them to the room.
+The bridge makes outbound connections to Thinkpool’s Supabase project. It does
+not require an inbound port, tunnel, or public IP.
 
-> **Don't want it tied to your laptop?** Run this same bridge on an always-on box
-> you control (a cheap VM, a home server, a Raspberry Pi) so the agent stays live
-> with your laptop closed. It's outbound-only — no ports, no public IP. See
-> [**Run it in the cloud**](#run-it-in-the-cloud-remote-host--vm--container) below.
+## Requirements
 
-## Run it (one command)
+- Node.js 18 or newer
+- A Thinkpool account and Code session
+- At least one supported runtime available on the host:
+  - Claude
+  - Codex
+  - Hermes
+- The provider login or API credentials required by that runtime
+
+## Start the bridge
+
+Run the launcher from the project directory the agents should use:
 
 ```bash
-cd bridge && npm i        # one-time (builds node-pty — needs Xcode CLT / build-essential)
-node bridge.mjs <ROOM>    # picks an installed agent, shared into room <ROOM>
+npx thinkpool-pair@latest
 ```
 
-- `<ROOM>` is the 5-char room code from the ThinkPool Code web UI (`/code`).
-- Share a specific CLI: `node bridge.mjs <ROOM> -- aider`  /  `… -- bash`.
-- Pure relay (no local terminal): `node bridge.mjs <ROOM> --headless`.
-
-## Keep it stable (auto-restart)
-
-The bridge self-heals at three levels — all cross-platform (macOS / Linux / Windows):
-
-- **`--supervise`** — wrap it so a crash respawns automatically (exponential
-  backoff). Zero-dependency. Combined with session restore (below), a crash is
-  invisible — the room reconnects and the Claude session resumes where it left off.
-  ```bash
-  npx thinkpool-pair@latest <ROOM> --supervise -- claude
-  ```
-- **Boot-persistent service** — survive reboot/logout too. Installs the right
-  native service for your OS (launchd on macOS, systemd `--user` on Linux, a
-  Startup-folder script on Windows):
-  ```bash
-  npx thinkpool-pair@latest install-service <ROOM> -- claude   # set and forget
-  npx thinkpool-pair@latest uninstall-service <ROOM>           # remove it
-  ```
-  The service runs `npx thinkpool-pair@latest`, so it **auto-updates** — new
-  versions apply on the next restart, no re-install. (Linux: run
-  `loginctl enable-linger $USER` once to keep it running after logout.)
-- **Watchdog** — if the realtime channel wedges for >60s, the bridge exits so the
-  supervisor/service restarts a clean process. Brief network blips reconnect on
-  their own.
-
-Structured Claude sessions persist their scrollback + session id to
-`~/.thinkpool-pair/<ROOM>/` and **resume on restart** (live context if recent),
-so none of the above loses your place.
-
-### Codex App Server driver
-
-Structured Codex lanes use the long-lived App Server transport (streaming prose,
-mid-turn steering, shared approval and question cards, and native image inputs)
-when the installed Codex CLI is in the bridge's tested protocol range. To force
-the stable `codex exec --json` fallback, set the kill switch before starting the
-bridge:
-
-```bash
-export TP_CODEX_APP_SERVER=0
-```
-
-The bridge performs the initialize handshake before creating a thread and falls
-back to `codex exec` when App Server is disabled, outside the tested version
-range, or cannot initialize before a turn. It never retries a prompt via the
-fallback after `turn/start` has been accepted, preventing duplicate work.
-
-Your first agent runs **attached** — use it exactly like your normal terminal,
-every byte mirrors to the web. The web's **"+ New terminal"** spawns additional
-**headless** terminals here (same directory, same env), driven entirely from
-the room. One bridge, many terminals.
-
-### Built-in viewport capture
-
-Structured Claude and Codex lanes have bridge-owned visual QA tools, even when
-their own sandbox cannot bind localhost or launch Chrome:
-
-- `preview_start` serves a built directory inside that lane's workspace
-  (`dist` by default; it must contain `index.html`).
-- `preview_capture` returns exact desktop (1440×900) and mobile (390×844)
-  screenshots to the agent as verification evidence. It creates no transcript
-  artifact by default. Pass `card: true` only for an intentional user-facing
-  mockup/Design deliverable; a settled complete pair is then queued after the
-  agent's final response. Loading, empty, and public-auth fallback shells are
-  rejected before a card can be created.
-- `preview_inspect` returns rendered DOM text, document size, and optional
-  selector geometry at either viewport.
-- `preview_stop` releases the preview port.
-
-The bridge launches the host's Chrome/Chromium lazily. Set `TP_BROWSER_PATH`
-if it is installed somewhere non-standard. Preview files are read-only, roots
-cannot escape the lane workspace (including through symlinks), and page network
-requests are restricted to the preview server's exact loopback origin. The
-tools never execute a caller-supplied command or open an arbitrary URL.
-
-## Run it in the cloud (remote host / VM / container)
-
-The bridge connects **outbound** to Supabase — no inbound ports, no public IP, no
-tunnel. So a cloud VM, container, devcontainer, or remote dev box can stream its
-Claude Code into the room exactly like a laptop. Run the same command there:
-
-```bash
-export ANTHROPIC_API_KEY=sk-ant-...                  # headless auth (no Keychain login)
-cd /path/to/your/repo
-npx thinkpool-pair@latest <ROOM> -- claude           # structured Claude, no TTY needed
-```
-
-- **Auth** — two ways to sign in on a box with no browser. Both are your own
-  account on your own hardware, so both are fine:
-  - **API key** — `export ANTHROPIC_API_KEY=sk-ant-...` from your Anthropic
-    Console. Simplest, pay-per-token, cleanest cost tracking.
-  - **Your Claude subscription** — a server has no browser, so mint a long-lived
-    token *on a machine that does*: run `claude setup-token` there (prints a
-    ~1-year `CLAUDE_CODE_OAUTH_TOKEN`), then `export CLAUDE_CODE_OAUTH_TOKEN=...`
-    on the box. Uses your existing Pro/Max plan — no per-token bill.
-
-  The Agent SDK reads either one automatically and runs its bundled `claude`, so
-  you don't need Claude Code installed separately. (Note: this is *you* running
-  *your* login on *your* machine. Handing a subscription token to a third-party
-  host to run for you is what Anthropic's terms forbid — that's why a future
-  "we host it for you" option would require an API key, not your subscription.)
-- **Use `@latest`**: a bare `npx thinkpool-pair` reuses npx's local cache and can
-  run a stale version across restarts. `@latest` (and the service below) always
-  re-resolve the newest publish.
-- **No TTY required**: the agent picker auto-selects and raw-mode is skipped when
-  there's no terminal, so it runs fine under CI / a service / `nohup`.
-- **Always-on + auto-update**: `npx thinkpool-pair@latest install-service <ROOM> -- claude`
-  installs a systemd `--user` unit (auto-restart + boot-persistent). The bridge
-  polls npm for new publishes and **self-restarts at the next idle moment** into
-  the new version — the structured session resumes, so an away/unattended box
-  upgrades itself with nobody losing their place. On a server, also run
-  `loginctl enable-linger $USER` so it survives logout.
-  Tune with `THINKPOOL_PAIR_UPDATE_INTERVAL` (poll seconds, default 1800) and
-  `THINKPOOL_PAIR_UPDATE_IDLE` (idle seconds before restart, default 90). Live
-  auto-update applies to the launchd/systemd service tiers; bare `--supervise`
-  respawns the same version, so it updates only on the next manual/boot restart.
-- **Security**: anyone with the room code can drive the agent (shell-trust by
-  design) — on a server that's a real shell, so treat the room code like a secret.
-
-## How it works
-
-`bridge.mjs` ⇄ **Supabase realtime** (`tpcode:<ROOM>`) ⇄ web `xterm`:
-- `bridge` — announce: installed agents + live terminals.
-- `pty-out` — terminal bytes (base64, per-terminal) → web clients render them.
-- `pty-in` — keystrokes/prompts from the web → written to that terminal's PTY.
-- `term-open` / `term-close` / `term-exit` — web-driven terminal lifecycle.
-- `replay-request` / `pty-replay` — each terminal keeps a rolling ~120 KB
-  scrollback buffer for live recovery. Thinkpool also stores the cleaned reader
-  transcript and room events so members can reopen the room. It does not store
-  a copy of the repository or the raw PTY byte stream.
-- `resize` — web viewport size → headless PTYs only (the attached terminal
-  follows your own TTY).
-
-## Inspect the privacy boundary
-
-Run a local report before pairing a repository:
+The launcher shows the linked account, detected runtimes, current directory,
+and background-service state. On first use it asks to link the machine in a
+browser. Then choose one of:
+
+- **Serve all my sessions** — runs in the current terminal until `Ctrl-C`.
+- **Always-on background service** — starts at login/reboot and restarts after a
+  crash. The normal install is pinned to the confirmed package version; use the
+  launcher’s **Restart & update bridge** action when a new version should land.
+
+Back in the room, open the runtime/model you want for each terminal.
+
+## Account and service commands
+
+Link the machine without opening the full launcher:
 
 ```bash
-npx thinkpool-pair@latest privacy-report
+npx thinkpool-pair@latest login
+```
+
+Install or remove the account-wide background service:
+
+```bash
+npx thinkpool-pair@latest install-service
+npx thinkpool-pair@latest restart-service
+npx thinkpool-pair@latest uninstall-service
+```
+
+`install-service` is pinned by default so a later bad npm publish cannot
+silently replace a working unattended bridge. Opt into tracking `@latest` only
+when that trade-off is intentional:
+
+```bash
+npx thinkpool-pair@latest install-service --auto-update
 ```
 
-It lists the project directories configured for this bridge, the local records
-present under `~/.thinkpool-pair`, known outbound service domains, what
-Thinkpool stores remotely, and the limits of the report. It never prints a
-provider key, refresh token, or bridge private key.
+Service implementation by platform:
 
-## Run any model
+- macOS: LaunchAgent
+- Linux: systemd user service; run `loginctl enable-linger "$USER"` once if it
+  must survive logout
+- Windows: Startup-folder command file
 
-ThinkPool Code runs **any model you choose** — not just Anthropic. The agent
-talks the Anthropic Messages API, so you point it at any endpoint that speaks
-that format:
+On Windows the startup entry launches at login; update it from the launcher and
+relaunch the bridge window to apply the new version.
 
-- **Anthropic-compatible endpoints directly** — Z.ai GLM, Moonshot Kimi, OpenRouter, your own proxy.
-- **Any other model via a translating gateway** — put **LiteLLM** (or a proxy of
-  your own) in front and run **GPT, Gemini, Llama, DeepSeek, or a local model**;
-  it presents the Anthropic Messages API while calling whatever you pick.
+## Project directories
 
-> OpenRouter is the exception worth knowing: its `/v1/messages` surface is a
-> pass-through for **Anthropic models only**. Per OpenRouter's own docs, "Claude
-> Code expects Anthropic request semantics, so non-Anthropic models aren't
-> supported through the native endpoint" — and this bridge spawns the `claude`
-> CLI. To reach a non-Anthropic model, use a translating gateway (LiteLLM),
-> not OpenRouter's Anthropic endpoint.
+The account bridge serves sessions from their bound project directories. Set a
+default for new/unbound sessions:
 
 ```bash
-npx thinkpool-pair@latest provider custom --base <url> --token <key> [--model <name>]
+npx thinkpool-pair@latest set-default-dir /path/to/project
 ```
 
-Common base urls (the agent appends `/v1/messages`):
+Bind one room explicitly when needed:
 
-| Provider / gateway | Base url                          | Models                       |
-|--------------------|-----------------------------------|------------------------------|
-| Z.ai GLM           | `https://api.z.ai/api/anthropic`  | GLM                          |
-| Moonshot Kimi      | `https://api.moonshot.ai/anthropic` | Kimi                       |
-| OpenRouter         | `https://openrouter.ai/api`       | Anthropic models only        |
-| LiteLLM (your own) | `http://localhost:4000`           | GPT, Gemini, Llama, local, … |
+```bash
+npx thinkpool-pair@latest bind <ROOM> /path/to/project
+```
+
+Room codes are treated as secrets because room members can drive agents that
+have access to the bound project and the host permissions granted to that lane.
 
-> The endpoint must serve the Anthropic Messages API (`/v1/messages`). A raw
-> OpenAI-style `/v1/chat/completions` won't work directly — that's exactly what a
-> gateway is for. Avoid LiteLLM 1.82.7 / 1.82.8 (compromised releases); use a
-> current version.
+## Runtimes and providers
 
-Show the current provider (`npx thinkpool-pair@latest provider`), or reset back to your
-regular Claude login:
+| Runtime | Authentication/provider behavior |
+|---|---|
+| Claude | Uses the host’s normal Anthropic login by default. A registered Anthropic-compatible provider can be selected for a lane. |
+| Codex | Uses the host’s Codex/OpenAI login. Custom bridge providers are not wired to Codex lanes. |
+| Hermes | Uses an isolated Thinkpool ACP profile. Set it up explicitly before the first Hermes lane. |
+
+The launcher’s **Settings → Provider** flow configures the host default for
+Claude-compatible lanes. The equivalent CLI commands are:
 
 ```bash
+npx thinkpool-pair@latest provider
 npx thinkpool-pair@latest provider anthropic
+npx thinkpool-pair@latest provider custom --base <url> --token <key> --model <id>
 ```
 
-Provider config is stored in `~/.thinkpool-pair/provider.json` (mode 0600) and
-applies to every bridge on the machine. Restart the bridge (or its launchd
-service) after changing it — the choice is read once at startup.
+The custom endpoint must implement the Anthropic Messages API. A raw
+OpenAI-compatible chat-completions endpoint is not enough; place a translating
+gateway in front of it or use the runtime that natively owns that provider.
 
-### Context meter for non-Claude models
+Set up an isolated Hermes profile with one of:
 
-The context-usage meter (`ctx N%` in the room) is computed by the Agent SDK from
-the model id it thinks it's talking to — for a non-Claude model bridged in over
-an Anthropic-compatible endpoint, that assumed window is wrong, so the meter can
-run past 100%. The bridge corrects it for common models automatically (GLM-4.5/4.6,
-DeepSeek V3.x, Kimi K2, Qwen3-Coder — matched by model id).
+```bash
+npx thinkpool-pair@latest setup-hermes --clone
+npx thinkpool-pair@latest setup-hermes --clean
+```
+
+`--clone` copies the active Hermes provider/configuration into the isolated
+profile. `--clean` creates the isolation boundary without copying credentials.
+
+## Direct single-room mode
+
+The account-wide launcher is the normal path. A direct room process is still
+available for debugging or a deliberately single-room host:
+
+```bash
+npx thinkpool-pair@latest <ROOM> -- claude
+npx thinkpool-pair@latest <ROOM> -- codex
+npx thinkpool-pair@latest <ROOM> -- hermes
+```
 
-For any model not in that list, set the real window explicitly per bridge:
+Add `--headless` when the process should be driven only from the room. Direct
+room services use the same command with the room code:
 
 ```bash
-export TP_CONTEXT_MAX=131072   # your model's context window, in tokens
+npx thinkpool-pair@latest install-service <ROOM> -- claude
+npx thinkpool-pair@latest uninstall-service <ROOM>
 ```
 
-`TP_CONTEXT_MAX` overrides the built-in map (and applies even to Claude ids if
-you set it). Unset it to fall back to the automatic correction.
+## Cloud or always-on host
+
+The bridge can run on a VM, dev box, home server, or container because its room
+connection is outbound-only. Use the same launcher/service commands and provide
+the runtime’s headless credentials through the host’s secret manager.
+
+For Claude, either an Anthropic API key or a valid Claude Code OAuth token can
+authenticate the runtime. Treat subscription/OAuth tokens as personal secrets;
+do not hand them to a third-party host.
+
+## What crosses the boundary
+
+The bridge and web app deliberately split responsibility:
+
+- Agent processes, repository access, provider credentials, and raw terminal
+  bytes remain on the bridge machine.
+- Thinkpool relays room events and terminal output to authorized room members.
+- Thinkpool stores the cleaned reader transcript and room events so members can
+  reopen the room.
+- Thinkpool does not store a copy of the repository or a second copy of the raw
+  PTY byte stream.
+- Voice dictation is an application API path and uses the configured
+  transcription service; it is not a local-only bridge operation.
+
+Inspect the host-side boundary before pairing a sensitive repository:
+
+```bash
+npx thinkpool-pair@latest privacy-report
+```
+
+The report lists configured project directories, local bridge records, known
+outbound domains, remote storage categories, and the report’s limits. It does
+not print provider keys, refresh tokens, or bridge private keys.
+
+Structured session state is stored below `~/.thinkpool-pair/` so an agent lane
+can resume after a bridge restart. Protect that directory like other local
+developer credentials and session state.
+
+## Visual verification tools
+
+Structured Claude and Codex lanes can use bridge-owned preview tools even when
+their own sandbox cannot bind a port or launch a browser:
+
+- `preview_start` serves a built directory inside the lane worktree.
+- `preview_capture` records exact desktop and mobile renders.
+- `preview_inspect` reads rendered DOM text and geometry.
+- `preview_stop` releases the preview server.
+
+Preview roots are read-only, cannot escape the lane worktree, and accept only
+the preview server’s loopback origin for page requests.
+
+## Optional bridge environment variables
+
+| Variable | Purpose |
+|---|---|
+| `TP_NAME` | Label this bridge in the room |
+| `TP_PAIR_ROOT` | Override the local state directory |
+| `TP_SUPABASE_URL` / `TP_SUPABASE_ANON` | Override the built-in Thinkpool project endpoint/public key |
+| `TP_ANTHROPIC_BASE_URL` / `TP_ANTHROPIC_AUTH_TOKEN` / `TP_ANTHROPIC_MODEL` | Override the Claude-compatible provider without writing provider config |
+| `TP_CONTEXT_MAX` | Override the context-window size used by the room meter |
+| `TP_BROWSER_PATH` | Point preview capture at a non-standard Chrome/Chromium binary |
+| `TP_FLOW_OFF=1` | Disable Flow dispatch on this bridge |
+| `TP_SPAWN_OFF=1` | Disable agent-spawned worker lanes |
+| `TP_PAIRBUS_OFF=1` | Disable the paired-room bus |
+| `TP_CROSSROOM_OFF=1` | Disable cross-session reach |
+
+Provider and account configuration written by the launcher is preferred for a
+managed service because shell startup files are not guaranteed to be sourced.
+
+## Troubleshooting
+
+### The room cannot see the bridge
+
+Run the launcher and check its account/runtime/service header. If the account
+link is missing or expired, rerun:
+
+```bash
+npx thinkpool-pair@latest login
+```
+
+### A service is installed but not serving
+
+Use the launcher’s restart/update action or:
+
+```bash
+npx thinkpool-pair@latest restart-service
+```
+
+The install command prints the platform-specific log directory. Inspect that
+log before reinstalling; repeated installation can hide the original failure.
+
+### No runtimes are available
+
+Install/sign in to Claude, Codex, or Hermes on the host, then restart the
+launcher. Runtime availability is detected from the host; the web room cannot
+install a missing CLI for you.
+
+### A custom model fails immediately
+
+Check that the endpoint implements Anthropic Messages semantics and that the
+model ID exists on that provider. Codex lanes ignore the bridge’s custom Claude
+provider configuration and use the Codex/OpenAI login.
+
+### Preview capture cannot find Chrome
+
+Install Chrome/Chromium on the bridge host or set `TP_BROWSER_PATH` to its
+executable.
+
+## Develop the bridge package
+
+From the repository root:
+
+```bash
+npm --prefix bridge ci
+npm run test:bridge
+node bridge/test-packed-artifact.mjs
+```
+
+Run the checked-out launcher with:
+
+```bash
+node bridge/bridge.mjs
+```
+
+Publishing is separate from the web-app deploy:
+
+```bash
+npm --prefix bridge run release
+```
 
-Public anon creds are embedded (the same ones the web app ships). Override with
-`TP_SUPABASE_URL` / `TP_SUPABASE_ANON` if needed. Set `TP_NAME` to label yourself.
+The release command has external side effects and requires npm publish
+authority. Do not use it as a local verification command.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.327",
+  "version": "0.7.328",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {

package/terminal-name.mjs

@@ -7,7 +7,8 @@ const SKIP = new Set([
   'do', 'much', 'better', 'really', 'need', 'want', 'your', 'their', 'its',
   'also', 'all', 'away', 'before', 'cause', 'does', 'dont', "don't", 'fully', 'has',
   'have', 'now', 'occasionally', 'return', 'second', 'so', 'sometimes', 'still',
-  'than', 'then', 'there', 'whenever', 'why', 'working',
+  'than', 'then', 'there', 'what', 'when', 'where', 'which', 'who', 'whenever',
+  'why', 'working',
 ])
 
 const GENERIC = /^(?:new )?(?:agent |coding )?(?:terminal|task|lane|session|work)$/i
@@ -16,6 +17,8 @@ const ANY_HEADING = /^(?:#{1,6}\s+|(?:context|background|constraints?|inputs?|ou
 const NOISE = /^(?:context|background|for reference|here(?:'s| is)|note|current(?:ly)?|example|environment|room now|constraints?|acceptance|success criteria)\b/i
 const EXPLANATION = /^(?:because|cause|since|so that|this is because)\b/i
 const CONSTRAINT = /^(?:users? can still|keep|must|never|should|without)\b/i
+const INFORMATION_REQUEST = /^(?:which|what|who|where|when|why|how)\b/i
+const NEGATIVE_PREFERENCE = /^(?:(?:i|we)\s+)?(?:do not|don't|dont|would not|wouldn't|won't|wont)\s+(?:(?:want|wanna|need)(?:\s+to)?|use|include|choose)\b|^(?:(?:i|we)\s+)?(?:want|wanna|need)(?:\s+to)?\s+avoid\b/i
 const ISSUE = /\b(?:broken|buggy|crash(?:es|ed|ing)?|duplicate|error|fail(?:s|ed|ing|ure)?|flash(?:es|ed|ing)?|missing|no animation|not working|out of (?:scrollable )?view|stuck|wrong)\b/i
 const REQUEST = /^(?:please\s+)?(?:can|could|would|will)\s+(?:we|you)\b|^(?:please\s+)?(?:how about|let's|let us|we need to|i want you to)\b/i
 const SECRET = /(?<![\p{L}\p{N}])(?:sk-(?:proj-)?[a-z0-9_-]{8,}|gsk_[a-z0-9_-]{8,}|xox[baprs]-[a-z0-9_-]{8,}|gh[pousr]_[a-z0-9_-]{8,}|glpat-[a-z0-9_-]{8,}|npm_[a-z0-9]{24,}|(?:sk|rk)_(?:live|test)_[a-z0-9]{8,}|whsec_[a-z0-9]{8,}|AIza[a-z0-9_-]{8,}|AKIA[A-Z0-9]{12,}|bearer\s+[a-z0-9._-]{8,}|eyJ[a-z0-9_-]{8,}\.[a-z0-9_-]{8,}\.[a-z0-9_-]{8,})(?![\p{L}\p{N}])/giu
@@ -125,12 +128,14 @@ const bestIntentClause = (text) => {
     const action = bestAction(clause)
     let score = action?.score || 0
     if (REQUEST.test(clause)) score += 18
+    if (INFORMATION_REQUEST.test(clause)) score += 36
     if (ISSUE.test(clause)) score += /\b(?:crash|fail|flash|stuck|wrong)\w*\b/i.test(clause) ? 36 : 26
     if (words.length >= 3 && words.length <= 24) score += 10
     else if (words.length > 40) score -= 14
     if (NOISE.test(clause)) score -= 30
     if (EXPLANATION.test(clause)) score -= 34
     if (CONSTRAINT.test(clause)) score -= 45
+    if (NEGATIVE_PREFERENCE.test(clause)) score -= 70
     score += Math.round((i / Math.max(1, clauses.length - 1)) * 4)
     if (!best || score > best.score) best = { clause, score }
   }
@@ -163,7 +168,7 @@ export function cleanTerminalName(value) {
 
 const titleWord = (word) => {
   const lower = word.toLowerCase()
-  if (lower === 'thinkpool') return 'ThinkPool'
+  if (lower === 'thinkpool' || lower === 'thinkpool.io') return 'ThinkPool'
   if (lower === 'serverside') return 'Server-Side'
   if (/^(?:api|ci|css|db|html|llm|mcp|npm|sdk|ui|ux)$/i.test(word)) return lower.toUpperCase()
   if (/^[A-Z\d+#.-]{2,}$/.test(word) || /\d/.test(word)) return word
@@ -194,6 +199,9 @@ const taskTitle = (value) => {
     .replace(/^\s*(?:how about|i (?:do not|don't) know|i guess|i want you to|we need to|your task is to|let(?:'s| us))\s+/i, '')
     .trim()
   if (!body) return null
+  if (NEGATIVE_PREFERENCE.test(body)) return null
+  const informationRequest = INFORMATION_REQUEST.test(body)
+  if (informationRequest) body = body.replace(/^\s*(?:which|what)\s+/i, '').trim()
   const signalText = body
   body = body
     .replace(/\s*,?\s+(?:so (?:that|you|we|it)\b|because\b|cause\b|if you know what i mean\b)[\s\S]*$/i, '')
@@ -205,7 +213,6 @@ const taskTitle = (value) => {
   let verb = issue ? 'Fix' : action?.title
   if (!verb && /\bclos(?:e|es|ed|ing)\b/i.test(body)) verb = 'Close'
   if (!verb && /\bopen(?:s|ed|ing)?\b/i.test(body)) verb = 'Open'
-  if (!verb) verb = 'Work On'
 
   if (/\bautomatic(?:ally)?\b[\s\S]{0,24}\bnam(?:e|ing)\b/i.test(signalText) && /\bterminals?\b/i.test(signalText)) {
     if (/\bcontext\b[\s\S]{0,24}\broom\b|\broom\b[\s\S]{0,24}\bcontext\b/i.test(signalText)) return 'Auto-Name Terminals From Room Context'
@@ -226,9 +233,13 @@ const taskTitle = (value) => {
   }
   let object = contentWords(objectText)
   if (!object.length) object = contentWords(body)
+  if (informationRequest) {
+    const available = object.findIndex((word) => /^available$/i.test(word))
+    if (available > 0) object = [object[available], ...object.slice(0, available), ...object.slice(available + 1)]
+  }
   const picked = [...domain, ...object].filter((word, index, all) => all.findIndex((other) => other.toLowerCase() === word.toLowerCase()) === index).slice(0, 4)
   if (!picked.length) return null
-  return cleanTerminalName([verb, ...picked.map(titleWord)].join(' '))
+  return cleanTerminalName([verb, ...picked.map(titleWord)].filter(Boolean).join(' '))
 }
 
 export function fallbackTerminalName(text) {