@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/skills/openhue/SKILL.md

@@ -1,30 +1,112 @@
 ---
 name: openhue
-description: Control Philips Hue lights/scenes via the OpenHue CLI.
+description: Control Philips Hue lights and scenes via the OpenHue CLI.
 homepage: https://www.openhue.io/cli
-metadata: {"poolbot":{"emoji":"💡","requires":{"bins":["openhue"]},"install":[{"id":"brew","kind":"brew","formula":"openhue/cli/openhue-cli","bins":["openhue"],"label":"Install OpenHue CLI (brew)"}]}}
+metadata:
+  {
+    "poolbot":
+      {
+        "emoji": "💡",
+        "requires": { "bins": ["openhue"] },
+        "install":
+          [
+            {
+              "id": "brew",
+              "kind": "brew",
+              "formula": "openhue/cli/openhue-cli",
+              "bins": ["openhue"],
+              "label": "Install OpenHue CLI (brew)",
+            },
+          ],
+      },
+  }
 ---
 
 # OpenHue CLI
 
-Use `openhue` to control Hue lights and scenes via a Hue Bridge.
+Use `openhue` to control Philips Hue lights and scenes via a Hue Bridge.
 
-Setup
-- Discover bridges: `openhue discover`
-- Guided setup: `openhue setup`
+## When to Use
 
-Read
-- `openhue get light --json`
-- `openhue get room --json`
-- `openhue get scene --json`
+✅ **USE this skill when:**
 
-Write
-- Turn on: `openhue set light <id-or-name> --on`
-- Turn off: `openhue set light <id-or-name> --off`
-- Brightness: `openhue set light <id> --on --brightness 50`
-- Color: `openhue set light <id> --on --rgb #3399FF`
-- Scene: `openhue set scene <scene-id>`
+- "Turn on/off the lights"
+- "Dim the living room lights"
+- "Set a scene" or "movie mode"
+- Controlling specific Hue rooms or zones
+- Adjusting brightness, color, or color temperature
 
-Notes
-- You may need to press the Hue Bridge button during setup.
-- Use `--room "Room Name"` when light names are ambiguous.
+## When NOT to Use
+
+❌ **DON'T use this skill when:**
+
+- Non-Hue smart devices (other brands) → not supported
+- HomeKit scenes or Shortcuts → use Apple's ecosystem
+- TV or entertainment system control
+- Thermostat or HVAC
+- Smart plugs (unless Hue smart plugs)
+
+## Common Commands
+
+### List Resources
+
+```bash
+openhue get light       # List all lights
+openhue get room        # List all rooms
+openhue get scene       # List all scenes
+```
+
+### Control Lights
+
+```bash
+# Turn on/off
+openhue set light "Bedroom Lamp" --on
+openhue set light "Bedroom Lamp" --off
+
+# Brightness (0-100)
+openhue set light "Bedroom Lamp" --on --brightness 50
+
+# Color temperature (warm to cool: 153-500 mirek)
+openhue set light "Bedroom Lamp" --on --temperature 300
+
+# Color (by name or hex)
+openhue set light "Bedroom Lamp" --on --color red
+openhue set light "Bedroom Lamp" --on --rgb "#FF5500"
+```
+
+### Control Rooms
+
+```bash
+# Turn off entire room
+openhue set room "Bedroom" --off
+
+# Set room brightness
+openhue set room "Bedroom" --on --brightness 30
+```
+
+### Scenes
+
+```bash
+# Activate scene
+openhue set scene "Relax" --room "Bedroom"
+openhue set scene "Concentrate" --room "Office"
+```
+
+## Quick Presets
+
+```bash
+# Bedtime (dim warm)
+openhue set room "Bedroom" --on --brightness 20 --temperature 450
+
+# Work mode (bright cool)
+openhue set room "Office" --on --brightness 100 --temperature 250
+
+# Movie mode (dim)
+openhue set room "Living Room" --on --brightness 10
+```
+
+## Notes
+
+- Bridge must be on local network
+- First run requires button press on Hue bridge to pair
+- Colors only work on color-capable bulbs (not white-only)

package/skills/tmux/SKILL.md

@@ -1,121 +1,153 @@
 ---
 name: tmux
 description: Remote-control tmux sessions for interactive CLIs by sending keystrokes and scraping pane output.
-metadata: {"poolbot":{"emoji":"🧵","os":["darwin","linux"],"requires":{"bins":["tmux"]}}}
+metadata:
+  { "poolbot": { "emoji": "🧵", "os": ["darwin", "linux"], "requires": { "bins": ["tmux"] } } }
 ---
 
-# tmux Skill (Pool Bot)
+# tmux Session Control
 
-Use tmux only when you need an interactive TTY. Prefer exec background mode for long-running, non-interactive tasks.
+Control tmux sessions by sending keystrokes and reading output. Essential for managing Claude Code sessions.
 
-## Quickstart (isolated socket, exec tool)
+## When to Use
 
-```bash
-SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/poolbot-tmux-sockets}"
-mkdir -p "$SOCKET_DIR"
-SOCKET="$SOCKET_DIR/poolbot.sock"
-SESSION=poolbot-python
-
-tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
-tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- 'PYTHON_BASIC_REPL=1 python3 -q' Enter
-tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
-```
+✅ **USE this skill when:**
 
-After starting a session, always print monitor commands:
+- Monitoring Claude/Codex sessions in tmux
+- Sending input to interactive terminal applications
+- Scraping output from long-running processes in tmux
+- Navigating tmux panes/windows programmatically
+- Checking on background work in existing sessions
 
-```
-To monitor:
-  tmux -S "$SOCKET" attach -t "$SESSION"
-  tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
+## When NOT to Use
+
+❌ **DON'T use this skill when:**
+
+- Running one-off shell commands → use `exec` tool directly
+- Starting new background processes → use `exec` with `background:true`
+- Non-interactive scripts → use `exec` tool
+- The process isn't in tmux
+- You need to create a new tmux session → use `exec` with `tmux new-session`
+
+## Example Sessions
+
+| Session                 | Purpose                     |
+| ----------------------- | --------------------------- |
+| `shared`                | Primary interactive session |
+| `worker-2` - `worker-8` | Parallel worker sessions    |
+
+## Common Commands
+
+### List Sessions
+
+```bash
+tmux list-sessions
+tmux ls
 ```
 
-## Socket convention
+### Capture Output
 
-- Use `CLAWDBOT_TMUX_SOCKET_DIR` (default `${TMPDIR:-/tmp}/poolbot-tmux-sockets`).
-- Default socket path: `"$CLAWDBOT_TMUX_SOCKET_DIR/poolbot.sock"`.
+```bash
+# Last 20 lines of pane
+tmux capture-pane -t shared -p | tail -20
 
-## Targeting panes and naming
+# Entire scrollback
+tmux capture-pane -t shared -p -S -
 
-- Target format: `session:window.pane` (defaults to `:0.0`).
-- Keep names short; avoid spaces.
-- Inspect: `tmux -S "$SOCKET" list-sessions`, `tmux -S "$SOCKET" list-panes -a`.
+# Specific pane in window
+tmux capture-pane -t shared:0.0 -p
+```
 
-## Finding sessions
+### Send Keys
 
-- List sessions on your socket: `{baseDir}/scripts/find-sessions.sh -S "$SOCKET"`.
-- Scan all sockets: `{baseDir}/scripts/find-sessions.sh --all` (uses `CLAWDBOT_TMUX_SOCKET_DIR`).
+```bash
+# Send text (doesn't press Enter)
+tmux send-keys -t shared "hello"
+
+# Send text + Enter
+tmux send-keys -t shared "y" Enter
+
+# Send special keys
+tmux send-keys -t shared Enter
+tmux send-keys -t shared Escape
+tmux send-keys -t shared C-c          # Ctrl+C
+tmux send-keys -t shared C-d          # Ctrl+D (EOF)
+tmux send-keys -t shared C-z          # Ctrl+Z (suspend)
+```
 
-## Sending input safely
+### Window/Pane Navigation
 
-- Prefer literal sends: `tmux -S "$SOCKET" send-keys -t target -l -- "$cmd"`.
-- Control keys: `tmux -S "$SOCKET" send-keys -t target C-c`.
+```bash
+# Select window
+tmux select-window -t shared:0
 
-## Watching output
+# Select pane
+tmux select-pane -t shared:0.1
 
-- Capture recent history: `tmux -S "$SOCKET" capture-pane -p -J -t target -S -200`.
-- Wait for prompts: `{baseDir}/scripts/wait-for-text.sh -t session:0.0 -p 'pattern'`.
-- Attaching is OK; detach with `Ctrl+b d`.
+# List windows
+tmux list-windows -t shared
+```
 
-## Spawning processes
+### Session Management
 
-- For python REPLs, set `PYTHON_BASIC_REPL=1` (non-basic REPL breaks send-keys flows).
+```bash
+# Create new session
+tmux new-session -d -s newsession
 
-## Windows / WSL
+# Kill session
+tmux kill-session -t sessionname
 
-- tmux is supported on macOS/Linux. On Windows, use WSL and install tmux inside WSL.
-- This skill is gated to `darwin`/`linux` and requires `tmux` on PATH.
+# Rename session
+tmux rename-session -t old new
+```
 
-## Orchestrating Coding Agents (Codex, Claude Code)
+## Sending Input Safely
 
-tmux excels at running multiple coding agents in parallel:
+For interactive TUIs (Claude Code, Codex, etc.), split text and Enter into separate sends to avoid paste/multiline edge cases:
 
 ```bash
-SOCKET="${TMPDIR:-/tmp}/codex-army.sock"
+tmux send-keys -t shared -l -- "Please apply the patch in src/foo.ts"
+sleep 0.1
+tmux send-keys -t shared Enter
+```
 
-# Create multiple sessions
-for i in 1 2 3 4 5; do
-  tmux -S "$SOCKET" new-session -d -s "agent-$i"
-done
+## Claude Code Session Patterns
 
-# Launch agents in different workdirs
-tmux -S "$SOCKET" send-keys -t agent-1 "cd /tmp/project1 && codex --yolo 'Fix bug X'" Enter
-tmux -S "$SOCKET" send-keys -t agent-2 "cd /tmp/project2 && codex --yolo 'Fix bug Y'" Enter
-
-# Poll for completion (check if prompt returned)
-for sess in agent-1 agent-2; do
-  if tmux -S "$SOCKET" capture-pane -p -t "$sess" -S -3 | grep -q "❯"; then
-    echo "$sess: DONE"
-  else
-    echo "$sess: Running..."
-  fi
-done
+### Check if Session Needs Input
 
-# Get full output from completed session
-tmux -S "$SOCKET" capture-pane -p -t agent-1 -S -500
+```bash
+# Look for prompts
+tmux capture-pane -t worker-3 -p | tail -10 | grep -E "❯|Yes.*No|proceed|permission"
 ```
 
-**Tips:**
-- Use separate git worktrees for parallel fixes (no branch conflicts)
-- `pnpm install` first before running codex in fresh clones
-- Check for shell prompt (`❯` or `$`) to detect completion
-- Codex needs `--yolo` or `--full-auto` for non-interactive fixes
+### Approve Claude Code Prompt
 
-## Cleanup
+```bash
+# Send 'y' and Enter
+tmux send-keys -t worker-3 'y' Enter
 
-- Kill a session: `tmux -S "$SOCKET" kill-session -t "$SESSION"`.
-- Kill all sessions on a socket: `tmux -S "$SOCKET" list-sessions -F '#{session_name}' | xargs -r -n1 tmux -S "$SOCKET" kill-session -t`.
-- Remove everything on the private socket: `tmux -S "$SOCKET" kill-server`.
+# Or select numbered option
+tmux send-keys -t worker-3 '2' Enter
+```
 
-## Helper: wait-for-text.sh
+### Check All Sessions Status
 
-`{baseDir}/scripts/wait-for-text.sh` polls a pane for a regex (or fixed string) with a timeout.
+```bash
+for s in shared worker-2 worker-3 worker-4 worker-5 worker-6 worker-7 worker-8; do
+  echo "=== $s ==="
+  tmux capture-pane -t $s -p 2>/dev/null | tail -5
+done
+```
+
+### Send Task to Session
 
 ```bash
-{baseDir}/scripts/wait-for-text.sh -t session:0.0 -p 'pattern' [-F] [-T 20] [-i 0.5] [-l 2000]
+tmux send-keys -t worker-4 "Fix the bug in auth.js" Enter
 ```
 
-- `-t`/`--target` pane target (required)
-- `-p`/`--pattern` regex to match (required); add `-F` for fixed string
-- `-T` timeout seconds (integer, default 15)
-- `-i` poll interval seconds (default 0.5)
-- `-l` history lines to search (integer, default 1000)
+## Notes
+
+- Use `capture-pane -p` to print to stdout (essential for scripting)
+- `-S -` captures entire scrollback history
+- Target format: `session:window.pane` (e.g., `shared:0.0`)
+- Sessions persist across SSH disconnects

package/skills/weather/SKILL.md

@@ -1,49 +1,112 @@
 ---
 name: weather
-description: Get current weather and forecasts (no API key required).
+description: "Get current weather and forecasts via wttr.in or Open-Meteo. Use when: user asks about weather, temperature, or forecasts for any location. NOT for: historical weather data, severe weather alerts, or detailed meteorological analysis. No API key needed."
 homepage: https://wttr.in/:help
-metadata: {"poolbot":{"emoji":"🌤️","requires":{"bins":["curl"]}}}
+metadata: { "poolbot": { "emoji": "🌤️", "requires": { "bins": ["curl"] } } }
 ---
 
-# Weather
+# Weather Skill
 
-Two free services, no API keys needed.
+Get current weather conditions and forecasts.
 
-## wttr.in (primary)
+## When to Use
+
+✅ **USE this skill when:**
+
+- "What's the weather?"
+- "Will it rain today/tomorrow?"
+- "Temperature in [city]"
+- "Weather forecast for the week"
+- Travel planning weather checks
+
+## When NOT to Use
+
+❌ **DON'T use this skill when:**
+
+- Historical weather data → use weather archives/APIs
+- Climate analysis or trends → use specialized data sources
+- Hyper-local microclimate data → use local sensors
+- Severe weather alerts → check official NWS sources
+- Aviation/marine weather → use specialized services (METAR, etc.)
+
+## Location
+
+Always include a city, region, or airport code in weather queries.
+
+## Commands
+
+### Current Weather
+
+```bash
+# One-line summary
+curl "wttr.in/London?format=3"
+
+# Detailed current conditions
+curl "wttr.in/London?0"
+
+# Specific city
+curl "wttr.in/New+York?format=3"
+```
+
+### Forecasts
 
-Quick one-liner:
 ```bash
-curl -s "wttr.in/London?format=3"
-# Output: London: ⛅️ +8°C
+# 3-day forecast
+curl "wttr.in/London"
+
+# Week forecast
+curl "wttr.in/London?format=v2"
+
+# Specific day (0=today, 1=tomorrow, 2=day after)
+curl "wttr.in/London?1"
 ```
 
-Compact format:
+### Format Options
+
 ```bash
-curl -s "wttr.in/London?format=%l:+%c+%t+%h+%w"
-# Output: London: ⛅️ +8°C 71% ↙5km/h
+# One-liner
+curl "wttr.in/London?format=%l:+%c+%t+%w"
+
+# JSON output
+curl "wttr.in/London?format=j1"
+
+# PNG image
+curl "wttr.in/London.png"
 ```
 
-Full forecast:
+### Format Codes
+
+- `%c` — Weather condition emoji
+- `%t` — Temperature
+- `%f` — "Feels like"
+- `%w` — Wind
+- `%h` — Humidity
+- `%p` — Precipitation
+- `%l` — Location
+
+## Quick Responses
+
+**"What's the weather?"**
+
 ```bash
-curl -s "wttr.in/London?T"
+curl -s "wttr.in/London?format=%l:+%c+%t+(feels+like+%f),+%w+wind,+%h+humidity"
 ```
 
-Format codes: `%c` condition · `%t` temp · `%h` humidity · `%w` wind · `%l` location · `%m` moon
+**"Will it rain?"**
 
-Tips:
-- URL-encode spaces: `wttr.in/New+York`
-- Airport codes: `wttr.in/JFK`
-- Units: `?m` (metric) `?u` (USCS)
-- Today only: `?1` · Current only: `?0`
-- PNG: `curl -s "wttr.in/Berlin.png" -o /tmp/weather.png`
+```bash
+curl -s "wttr.in/London?format=%l:+%c+%p"
+```
 
-## Open-Meteo (fallback, JSON)
+**"Weekend forecast"**
 
-Free, no key, good for programmatic use:
 ```bash
-curl -s "https://api.open-meteo.com/v1/forecast?latitude=51.5&longitude=-0.12&current_weather=true"
+curl "wttr.in/London?format=v2"
 ```
 
-Find coordinates for a city, then query. Returns JSON with temp, windspeed, weathercode.
+## Notes
 
-Docs: https://open-meteo.com/en/docs
+- No API key needed (uses wttr.in)
+- Rate limited; don't spam requests
+- Works for most global cities
+- Supports airport codes: `curl wttr.in/ORD`

package/dist/agents/openclaw-tools.js

@@ -1,151 +0,0 @@
-import { resolvePluginTools } from "../plugins/tools.js";
-import { resolveSessionAgentId } from "./agent-scope.js";
-import { createAgentsListTool } from "./tools/agents-list-tool.js";
-import { createBrowserTool } from "./tools/browser-tool.js";
-import { createCanvasTool } from "./tools/canvas-tool.js";
-import { createCronTool } from "./tools/cron-tool.js";
-import { createGatewayTool } from "./tools/gateway-tool.js";
-import { createDeepResearchTool } from "./tools/deep-research-tool.js";
-import { createImageGenerateTool } from "./tools/image-generate-tool.js";
-import { createImageTool } from "./tools/image-tool.js";
-import { createMessageTool } from "./tools/message-tool.js";
-import { createNodesTool } from "./tools/nodes-tool.js";
-import { createSessionStatusTool } from "./tools/session-status-tool.js";
-import { createSessionsHistoryTool } from "./tools/sessions-history-tool.js";
-import { createSessionsListTool } from "./tools/sessions-list-tool.js";
-import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
-import { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
-import { createSubagentsTool } from "./tools/subagents-tool.js";
-import { createTtsTool } from "./tools/tts-tool.js";
-import { createWebFetchTool, createWebSearchTool } from "./tools/web-tools.js";
-import { resolveWorkspaceRoot } from "./workspace-dir.js";
-export function createOpenClawTools(options) {
-    const workspaceDir = resolveWorkspaceRoot(options?.workspaceDir);
-    const imageTool = options?.agentDir?.trim()
-        ? createImageTool({
-            config: options?.config,
-            agentDir: options.agentDir,
-            workspaceDir,
-            sandbox: options?.sandboxRoot && options?.sandboxFsBridge
-                ? { root: options.sandboxRoot, bridge: options.sandboxFsBridge }
-                : undefined,
-            modelHasVision: options?.modelHasVision,
-        })
-        : null;
-    const imageGenerateTool = createImageGenerateTool({
-        config: options?.config,
-        agentDir: options?.agentDir,
-        sandboxRoot: options?.sandboxRoot,
-    });
-    const webSearchTool = createWebSearchTool({
-        config: options?.config,
-        sandboxed: options?.sandboxed,
-    });
-    const webFetchTool = createWebFetchTool({
-        config: options?.config,
-        sandboxed: options?.sandboxed,
-    });
-    const messageTool = options?.disableMessageTool
-        ? null
-        : createMessageTool({
-            agentAccountId: options?.agentAccountId,
-            agentSessionKey: options?.agentSessionKey,
-            config: options?.config,
-            currentChannelId: options?.currentChannelId,
-            currentChannelProvider: options?.agentChannel,
-            currentThreadTs: options?.currentThreadTs,
-            replyToMode: options?.replyToMode,
-            hasRepliedRef: options?.hasRepliedRef,
-            sandboxRoot: options?.sandboxRoot,
-            requireExplicitTarget: options?.requireExplicitMessageTarget,
-        });
-    const tools = [
-        createBrowserTool({
-            sandboxBridgeUrl: options?.sandboxBrowserBridgeUrl,
-            allowHostControl: options?.allowHostBrowserControl,
-        }),
-        createCanvasTool(),
-        createNodesTool({
-            agentSessionKey: options?.agentSessionKey,
-            config: options?.config,
-        }),
-        createCronTool({
-            agentSessionKey: options?.agentSessionKey,
-        }),
-        ...(messageTool ? [messageTool] : []),
-        createTtsTool({
-            agentChannel: options?.agentChannel,
-            config: options?.config,
-        }),
-        createGatewayTool({
-            agentSessionKey: options?.agentSessionKey,
-            config: options?.config,
-        }),
-        createAgentsListTool({
-            agentSessionKey: options?.agentSessionKey,
-            requesterAgentIdOverride: options?.requesterAgentIdOverride,
-        }),
-        createSessionsListTool({
-            agentSessionKey: options?.agentSessionKey,
-            sandboxed: options?.sandboxed,
-        }),
-        createSessionsHistoryTool({
-            agentSessionKey: options?.agentSessionKey,
-            sandboxed: options?.sandboxed,
-        }),
-        createSessionsSendTool({
-            agentSessionKey: options?.agentSessionKey,
-            agentChannel: options?.agentChannel,
-            sandboxed: options?.sandboxed,
-        }),
-        createSessionsSpawnTool({
-            agentSessionKey: options?.agentSessionKey,
-            agentChannel: options?.agentChannel,
-            agentAccountId: options?.agentAccountId,
-            agentTo: options?.agentTo,
-            agentThreadId: options?.agentThreadId,
-            agentGroupId: options?.agentGroupId,
-            agentGroupChannel: options?.agentGroupChannel,
-            agentGroupSpace: options?.agentGroupSpace,
-            sandboxed: options?.sandboxed,
-            requesterAgentIdOverride: options?.requesterAgentIdOverride,
-        }),
-        createSubagentsTool({
-            agentSessionKey: options?.agentSessionKey,
-        }),
-        createSessionStatusTool({
-            agentSessionKey: options?.agentSessionKey,
-            config: options?.config,
-        }),
-        ...(webSearchTool ? [webSearchTool] : []),
-        ...(webFetchTool ? [webFetchTool] : []),
-        ...(imageTool ? [imageTool] : []),
-        ...(imageGenerateTool ? [imageGenerateTool] : []),
-    ];
-    // Z.AI-powered research tool (gracefully absent when no key configured)
-    const deepResearchTool = createDeepResearchTool({
-        config: options?.config,
-        agentDir: options?.agentDir,
-        sandboxRoot: options?.sandboxRoot,
-    });
-    if (deepResearchTool)
-        tools.push(deepResearchTool);
-    const pluginTools = resolvePluginTools({
-        context: {
-            config: options?.config,
-            workspaceDir,
-            agentDir: options?.agentDir,
-            agentId: resolveSessionAgentId({
-                sessionKey: options?.agentSessionKey,
-                config: options?.config,
-            }),
-            sessionKey: options?.agentSessionKey,
-            messageChannel: options?.agentChannel,
-            agentAccountId: options?.agentAccountId,
-            sandboxed: options?.sandboxed,
-        },
-        existingToolNames: new Set(tools.map((tool) => tool.name)),
-        toolAllowlist: options?.pluginToolAllowlist,
-    });
-    return [...tools, ...pluginTools];
-}