@clawpump/claw-agent 0.1.5 → 0.1.6

package/agent/skills/domain/DESCRIPTION.md

@@ -1,24 +0,0 @@
----
-name: domain-intel
-description: Passive domain reconnaissance using Python stdlib. Use this skill for subdomain discovery, SSL certificate inspection, WHOIS lookups, DNS records, domain availability checks, and bulk multi-domain analysis. No API keys required. Triggers on requests like "find subdomains", "check ssl cert", "whois lookup", "is this domain available", "bulk check these domains".
-license: MIT
----
-
-Passive domain intelligence using only Python stdlib and public data sources.
-Zero dependencies. Zero API keys. Works out of the box.
-
-## Capabilities
-
-- Subdomain discovery via crt.sh certificate transparency logs
-- Live SSL/TLS certificate inspection (expiry, cipher, SANs, TLS version)
-- WHOIS lookup — supports 100+ TLDs via direct TCP queries
-- DNS records: A, AAAA, MX, NS, TXT, CNAME
-- Domain availability check (DNS + WHOIS + SSL signals)
-- Bulk multi-domain analysis in parallel (up to 20 domains)
-
-## Data Sources
-
-- crt.sh — Certificate Transparency logs
-- WHOIS servers — Direct TCP to 100+ authoritative TLD servers  
-- Google DNS-over-HTTPS — MX/NS/TXT/CNAME resolution
-- System DNS — A/AAAA records

package/agent/skills/gifs/DESCRIPTION.md

@@ -1,3 +0,0 @@
----
-description: Skills for searching, downloading, and working with GIFs and short-form animated media.
----

package/agent/skills/inference-sh/DESCRIPTION.md

@@ -1,19 +0,0 @@
-# inference.sh
-
-Run 150+ AI applications in the cloud via the [inference.sh](https://inference.sh) platform.
-
-**One API key for everything** — access image generation, video creation, LLMs, search, 3D, and more through a single account. No need to manage separate API keys for each provider.
-
-## Available Skills
-
-- **cli**: Use the inference.sh CLI (`infsh`) via the terminal tool
-
-## What's Included
-
-- **Image Generation**: FLUX, Reve, Seedream, Grok Imagine, Gemini
-- **Video Generation**: Veo, Wan, Seedance, OmniHuman, HunyuanVideo
-- **LLMs**: Claude, Gemini, Kimi, GLM-4 (via OpenRouter)
-- **Search**: Tavily, Exa
-- **3D**: Rodin
-- **Social**: Twitter/X automation
-- **Audio**: TTS, voice cloning

package/agent/skills/mcp/DESCRIPTION.md

@@ -1,3 +0,0 @@
----
-description: Skills for working with MCP (Model Context Protocol) servers, tools, and integrations. Documents the built-in native MCP client — configure servers in config.yaml for automatic tool discovery.
----

package/agent/skills/media/spotify/SKILL.md

@@ -1,135 +0,0 @@
----
-name: spotify
-description: "Spotify: play, search, queue, manage playlists and devices."
-version: 1.0.0
-author: Hermes Agent
-license: MIT
-platforms: [linux, macos, windows]
-prerequisites:
-  tools: [spotify_playback, spotify_devices, spotify_queue, spotify_search, spotify_playlists, spotify_albums, spotify_library]
-metadata:
-  hermes:
-    tags: [spotify, music, playback, playlists, media]
-    related_skills: [gif-search]
----
-
-# Spotify
-
-Control the user's Spotify account via the Hermes Spotify toolset (7 tools). Setup guide: https://hermes-agent.nousresearch.com/docs/user-guide/features/spotify
-
-## When to use this skill
-
-The user says something like "play X", "pause", "skip", "queue up X", "what's playing", "search for X", "add to my X playlist", "make a playlist", "save this to my library", etc.
-
-## The 7 tools
-
-- `spotify_playback` — play, pause, next, previous, seek, set_repeat, set_shuffle, set_volume, get_state, get_currently_playing, recently_played
-- `spotify_devices` — list, transfer
-- `spotify_queue` — get, add
-- `spotify_search` — search the catalog
-- `spotify_playlists` — list, get, create, add_items, remove_items, update_details
-- `spotify_albums` — get, tracks
-- `spotify_library` — list/save/remove with `kind: "tracks"|"albums"`
-
-Playback-mutating actions require Spotify Premium; search/library/playlist ops work on Free.
-
-## Canonical patterns (minimize tool calls)
-
-### "Play <artist/track/album>"
-One search, then play by URI. Do NOT loop through search results describing them unless the user asked for options.
-
-```
-spotify_search({"query": "miles davis kind of blue", "types": ["album"], "limit": 1})
-→ got album URI spotify:album:1weenld61qoidwYuZ1GESA
-spotify_playback({"action": "play", "context_uri": "spotify:album:1weenld61qoidwYuZ1GESA"})
-```
-
-For "play some <artist>" (no specific song), prefer `types: ["artist"]` and play the artist context URI — Spotify handles smart shuffle. If the user says "the song" or "that track", search `types: ["track"]` and pass `uris: [track_uri]` to play.
-
-### "What's playing?" / "What am I listening to?"
-Single call — don't chain get_state after get_currently_playing.
-
-```
-spotify_playback({"action": "get_currently_playing"})
-```
-
-If it returns 204/empty (`is_playing: false`), tell the user nothing is playing. Don't retry.
-
-### "Pause" / "Skip" / "Volume 50"
-Direct action, no preflight inspection needed.
-
-```
-spotify_playback({"action": "pause"})
-spotify_playback({"action": "next"})
-spotify_playback({"action": "set_volume", "volume_percent": 50})
-```
-
-### "Add to my <playlist name> playlist"
-1. `spotify_playlists list` to find the playlist ID by name
-2. Get the track URI (from currently playing, or search)
-3. `spotify_playlists add_items` with the playlist_id and URIs
-
-```
-spotify_playlists({"action": "list"})
-→ found "Late Night Jazz" = 37i9dQZF1DX4wta20PHgwo
-spotify_playback({"action": "get_currently_playing"})
-→ current track uri = spotify:track:0DiWol3AO6WpXZgp0goxAV
-spotify_playlists({"action": "add_items",
-                   "playlist_id": "37i9dQZF1DX4wta20PHgwo",
-                   "uris": ["spotify:track:0DiWol3AO6WpXZgp0goxAV"]})
-```
-
-### "Create a playlist called X and add the last 3 songs I played"
-```
-spotify_playback({"action": "recently_played", "limit": 3})
-spotify_playlists({"action": "create", "name": "Focus 2026"})
-→ got playlist_id back in response
-spotify_playlists({"action": "add_items", "playlist_id": <id>, "uris": [<3 uris>]})
-```
-
-### "Save / unsave / is this saved?"
-Use `spotify_library` with the right `kind`.
-
-```
-spotify_library({"kind": "tracks", "action": "save", "uris": ["spotify:track:..."]})
-spotify_library({"kind": "albums", "action": "list", "limit": 50})
-```
-
-### "Transfer playback to my <device>"
-```
-spotify_devices({"action": "list"})
-→ pick the device_id by matching name/type
-spotify_devices({"action": "transfer", "device_id": "<id>", "play": true})
-```
-
-## Critical failure modes
-
-**`403 Forbidden — No active device found`** on any playback action means Spotify isn't running anywhere. Tell the user: "Open Spotify on your phone/desktop/web player first, start any track for a second, then retry." Don't retry the tool call blindly — it will fail the same way. You can call `spotify_devices list` to confirm; an empty list means no active device.
-
-**`403 Forbidden — Premium required`** means the user is on Free and tried to mutate playback. Don't retry; tell them this action needs Premium. Reads still work (search, playlists, library, get_state).
-
-**`204 No Content` on `get_currently_playing`** is NOT an error — it means nothing is playing. The tool returns `is_playing: false`. Just report that to the user.
-
-**`429 Too Many Requests`** = rate limit. Wait and retry once. If it keeps happening, you're looping — stop.
-
-**`401 Unauthorized` after a retry** — refresh token revoked. Tell the user to run `hermes auth spotify` again.
-
-## URI and ID formats
-
-Spotify uses three interchangeable ID formats. The tools accept all three and normalize:
-
-- URI: `spotify:track:0DiWol3AO6WpXZgp0goxAV` (preferred)
-- URL: `https://open.spotify.com/track/0DiWol3AO6WpXZgp0goxAV`
-- Bare ID: `0DiWol3AO6WpXZgp0goxAV`
-
-When in doubt, use full URIs. Search results return URIs in the `uri` field — pass those directly.
-
-Entity types: `track`, `album`, `artist`, `playlist`, `show`, `episode`. Use the right type for the action — `spotify_playback.play` with a `context_uri` expects album/playlist/artist; `uris` expects an array of track URIs.
-
-## What NOT to do
-
-- **Don't call `get_state` before every action.** Spotify accepts play/pause/skip without preflight. Only inspect state when the user asked "what's playing" or you need to reason about device/track.
-- **Don't describe search results unless asked.** If the user said "play X", search, grab the top URI, play it. They'll hear it's wrong if it's wrong.
-- **Don't retry on `403 Premium required` or `403 No active device`.** Those are permanent until user action.
-- **Don't use `spotify_search` to find a playlist by name** — that searches the public Spotify catalog. User playlists come from `spotify_playlists list`.
-- **Don't mix `kind: "tracks"` with album URIs** in `spotify_library` (or vice versa). The tool normalizes IDs but the API endpoint differs.

package/agent/skills/mlops/training/DESCRIPTION.md

@@ -1,3 +0,0 @@
----
-description: Fine-tuning, RLHF/DPO/GRPO training, distributed training frameworks, and optimization tools for training LLMs and other models.
----

package/agent/skills/mlops/vector-databases/DESCRIPTION.md

@@ -1,3 +0,0 @@
----
-description: Vector similarity search and embedding databases for RAG, semantic search, and AI application backends.
----

package/agent/skills/productivity/linear/SKILL.md

@@ -1,380 +0,0 @@
----
-name: linear
-description: "Linear: manage issues, projects, teams via GraphQL + curl."
-version: 1.0.0
-author: Hermes Agent
-license: MIT
-platforms: [linux, macos, windows]
-prerequisites:
-  env_vars: [LINEAR_API_KEY]
-  commands: [curl]
-metadata:
-  hermes:
-    tags: [Linear, Project Management, Issues, GraphQL, API, Productivity]
----
-
-# Linear — Issue & Project Management
-
-Manage Linear issues, projects, and teams directly via the GraphQL API using `curl`. No MCP server, no OAuth flow, no extra dependencies.
-
-## Setup
-
-1. Get a personal API key from **Linear Settings > Account > Security & access > Personal API keys** (URL: https://linear.app/settings/account/security). Note: the org-level *Settings > API* page only shows OAuth apps and workspace-member keys, not personal keys.
-2. Set `LINEAR_API_KEY` in your environment (via `hermes setup` or your env config)
-
-## API Basics
-
-- **Endpoint:** `https://api.linear.app/graphql` (POST)
-- **Auth header:** `Authorization: $LINEAR_API_KEY` (no "Bearer" prefix for API keys)
-- **All requests are POST** with `Content-Type: application/json`
-- **Both UUIDs and short identifiers** (e.g., `ENG-123`) work for `issue(id:)`
-
-Base curl pattern:
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ viewer { id name } }"}' | python3 -m json.tool
-```
-
-## Python helper script (ergonomic alternative)
-
-For faster one-liners that don't need hand-written GraphQL, this skill ships a stdlib Python CLI at `scripts/linear_api.py`. Zero dependencies. Same auth (reads `LINEAR_API_KEY`).
-
-```bash
-SCRIPT=$(dirname "$(find ~/.hermes -path '*skills/productivity/linear/scripts/linear_api.py' 2>/dev/null | head -1)")/linear_api.py
-
-python3 "$SCRIPT" whoami
-python3 "$SCRIPT" list-teams
-python3 "$SCRIPT" get-issue ENG-42
-python3 "$SCRIPT" get-document 38359beef67c      # fetch a doc by slugId from the URL
-python3 "$SCRIPT" raw 'query { viewer { name } }'
-```
-
-All subcommands: `whoami`, `list-teams`, `list-projects`, `list-states`, `list-issues`, `get-issue`, `search-issues`, `create-issue`, `update-issue`, `update-status`, `add-comment`, `list-documents`, `get-document`, `search-documents`, `raw`. Run with `--help` for flags.
-
-Use the script when: you want a quick answer without crafting GraphQL. Use curl when: you need a query the script doesn't wrap, or you want to compose filters inline.
-
-## Workflow States
-
-Linear uses `WorkflowState` objects with a `type` field. **6 state types:**
-
-| Type | Description |
-|------|-------------|
-| `triage` | Incoming issues needing review |
-| `backlog` | Acknowledged but not yet planned |
-| `unstarted` | Planned/ready but not started |
-| `started` | Actively being worked on |
-| `completed` | Done |
-| `canceled` | Won't do |
-
-Each team has its own named states (e.g., "In Progress" is type `started`). To change an issue's status, you need the `stateId` (UUID) of the target state — query workflow states first.
-
-**Priority values:** 0 = None, 1 = Urgent, 2 = High, 3 = Medium, 4 = Low
-
-## Common Queries
-
-### Get current user
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ viewer { id name email } }"}' | python3 -m json.tool
-```
-
-### List teams
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ teams { nodes { id name key } } }"}' | python3 -m json.tool
-```
-
-### List workflow states for a team
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ workflowStates(filter: { team: { key: { eq: \"ENG\" } } }) { nodes { id name type } } }"}' | python3 -m json.tool
-```
-
-### List issues (first 20)
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issues(first: 20) { nodes { identifier title priority state { name type } assignee { name } team { key } url } pageInfo { hasNextPage endCursor } } }"}' | python3 -m json.tool
-```
-
-### List my assigned issues
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ viewer { assignedIssues(first: 25) { nodes { identifier title state { name type } priority url } } } }"}' | python3 -m json.tool
-```
-
-### Get a single issue (by identifier like ENG-123)
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issue(id: \"ENG-123\") { id identifier title description priority state { id name type } assignee { id name } team { key } project { name } labels { nodes { name } } comments { nodes { body user { name } createdAt } } url } }"}' | python3 -m json.tool
-```
-
-### Search issues by text
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issueSearch(query: \"bug login\", first: 10) { nodes { identifier title state { name } assignee { name } url } } }"}' | python3 -m json.tool
-```
-
-### Filter issues by state type
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issues(filter: { state: { type: { in: [\"started\"] } } }, first: 20) { nodes { identifier title state { name } assignee { name } } } }"}' | python3 -m json.tool
-```
-
-### Filter by team and assignee
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issues(filter: { team: { key: { eq: \"ENG\" } }, assignee: { email: { eq: \"user@example.com\" } } }, first: 20) { nodes { identifier title state { name } priority } } }"}' | python3 -m json.tool
-```
-
-### List projects
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ projects(first: 20) { nodes { id name description progress lead { name } teams { nodes { key } } url } } }"}' | python3 -m json.tool
-```
-
-### List team members
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ users { nodes { id name email active } } }"}' | python3 -m json.tool
-```
-
-### List labels
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issueLabels { nodes { id name color } } }"}' | python3 -m json.tool
-```
-
-## Common Mutations
-
-### Create an issue
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id identifier title url } } }",
-    "variables": {
-      "input": {
-        "teamId": "TEAM_UUID",
-        "title": "Fix login bug",
-        "description": "Users cannot login with SSO",
-        "priority": 2
-      }
-    }
-  }' | python3 -m json.tool
-```
-
-### Update issue status
-First get the target state UUID from the workflow states query above, then:
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { issueUpdate(id: \"ENG-123\", input: { stateId: \"STATE_UUID\" }) { success issue { identifier state { name type } } } }"}' | python3 -m json.tool
-```
-
-### Assign an issue
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { issueUpdate(id: \"ENG-123\", input: { assigneeId: \"USER_UUID\" }) { success issue { identifier assignee { name } } } }"}' | python3 -m json.tool
-```
-
-### Set priority
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { issueUpdate(id: \"ENG-123\", input: { priority: 1 }) { success issue { identifier priority } } }"}' | python3 -m json.tool
-```
-
-### Add a comment
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { commentCreate(input: { issueId: \"ISSUE_UUID\", body: \"Investigated. Root cause is X.\" }) { success comment { id body } } }"}' | python3 -m json.tool
-```
-
-### Set due date
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { issueUpdate(id: \"ENG-123\", input: { dueDate: \"2026-04-01\" }) { success issue { identifier dueDate } } }"}' | python3 -m json.tool
-```
-
-### Add labels to an issue
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { issueUpdate(id: \"ENG-123\", input: { labelIds: [\"LABEL_UUID_1\", \"LABEL_UUID_2\"] }) { success issue { identifier labels { nodes { name } } } } }"}' | python3 -m json.tool
-```
-
-### Add issue to a project
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "mutation { issueUpdate(id: \"ENG-123\", input: { projectId: \"PROJECT_UUID\" }) { success issue { identifier project { name } } } }"}' | python3 -m json.tool
-```
-
-### Create a project
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "mutation($input: ProjectCreateInput!) { projectCreate(input: $input) { success project { id name url } } }",
-    "variables": {
-      "input": {
-        "name": "Q2 Auth Overhaul",
-        "description": "Replace legacy auth with OAuth2 and PKCE",
-        "teamIds": ["TEAM_UUID"]
-      }
-    }
-  }' | python3 -m json.tool
-```
-
-## Documents
-
-Linear **Documents** are prose docs (RFCs, specs, notes) stored alongside issues. They have their own `documents` root query and `document(id:)` single-fetch.
-
-### Document URLs and `slugId`
-
-Document URLs look like:
-```
-https://linear.app/<workspace>/document/<slug>-<hexSlugId>
-```
-
-The trailing hex segment is the `slugId`. Example: `https://linear.app/nousresearch/document/rfc-hermes-permission-gateway-discord-38359beef67c` → `slugId` is `38359beef67c`.
-
-**Important schema detail:** the Markdown body is in the `content` field. The ProseMirror JSON is in `contentState` (not `contentData` — that field does not exist and the API returns 400).
-
-### Fetch a document by slugId
-
-`document(id:)` only accepts UUIDs. To fetch by the URL's hex slug, filter the collection:
-
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "query($s: String!) { documents(filter: { slugId: { eq: $s } }, first: 1) { nodes { id title content contentState slugId url creator { name } project { name } updatedAt } } }", "variables": {"s": "38359beef67c"}}' \
-  | python3 -m json.tool
-```
-
-Or via the Python helper:
-```bash
-python3 scripts/linear_api.py get-document 38359beef67c
-```
-
-### Fetch a document by UUID
-
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ document(id: \"11700cff-b514-4db3-afcc-3ed1afacba1c\") { title content url } }"}' \
-  | python3 -m json.tool
-```
-
-### List recent documents
-
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ documents(first: 25, orderBy: updatedAt) { nodes { id title slugId url updatedAt project { name } } } }"}' \
-  | python3 -m json.tool
-```
-
-### Search documents by title
-
-Linear's schema has no `searchDocuments` root. Use a title-substring filter instead:
-
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ documents(filter: { title: { containsIgnoreCase: \"RFC\" } }, first: 25) { nodes { title slugId url } } }"}' \
-  | python3 -m json.tool
-```
-
-## Pagination
-
-Linear uses Relay-style cursor pagination:
-
-```bash
-# First page
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issues(first: 20) { nodes { identifier title } pageInfo { hasNextPage endCursor } } }"}' | python3 -m json.tool
-
-# Next page — use endCursor from previous response
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "{ issues(first: 20, after: \"CURSOR_FROM_PREVIOUS\") { nodes { identifier title } pageInfo { hasNextPage endCursor } } }"}' | python3 -m json.tool
-```
-
-Default page size: 50. Max: 250. Always use `first: N` to limit results.
-
-## Filtering Reference
-
-Comparators: `eq`, `neq`, `in`, `nin`, `lt`, `lte`, `gt`, `gte`, `contains`, `startsWith`, `containsIgnoreCase`
-
-Combine filters with `or: [...]` for OR logic (default is AND within a filter object).
-
-## Typical Workflow
-
-1. **Query teams** to get team IDs and keys
-2. **Query workflow states** for target team to get state UUIDs
-3. **List or search issues** to find what needs work
-4. **Create issues** with team ID, title, description, priority
-5. **Update status** by setting `stateId` to the target workflow state
-6. **Add comments** to track progress
-7. **Mark complete** by setting `stateId` to the team's "completed" type state
-
-## Rate Limits
-
-- 5,000 requests/hour per API key
-- 3,000,000 complexity points/hour
-- Use `first: N` to limit results and reduce complexity cost
-- Monitor `X-RateLimit-Requests-Remaining` response header
-
-## Important Notes
-
-- Always use `terminal` tool with `curl` for API calls — do NOT use `web_extract` or `browser`
-- Always check the `errors` array in GraphQL responses — HTTP 200 can still contain errors
-- If `stateId` is omitted when creating issues, Linear defaults to the first backlog state
-- The `description` field supports Markdown
-- Use `python3 -m json.tool` or `jq` to format JSON responses for readability