Add community skills, agents, system prompts from 22+ sources

Community Skills (32): - jat: jat-start, jat-verify, jat-complete - pi-mono: codex-cli, codex-5.3-prompting, interactive-shell - picoclaw: github, weather, tmux, summarize, skill-creator - dyad: 18 skills (swarm-to-plan, multi-pr-review, fix-issue, lint, etc.) - dexter: dcf valuation skill Agents (23): - pi-mono subagents: scout, planner, reviewer, worker - toad: 19 agent configs (Claude, Codex, Gemini, Copilot, OpenCode, etc.) System Prompts (91): - Anthropic: 15 Claude prompts (opus-4.6, code, cowork, etc.) - OpenAI: 49 GPT prompts (gpt-5 series, o3, o4-mini, tools) - Google: 13 Gemini prompts (2.5-pro, 3-pro, workspace, cli) - xAI: 5 Grok prompts - Other: 9 misc prompts (Notion, Raycast, Warp, Kagi, etc.) Hooks (9): - JAT hooks for session management, signal tracking, activity logging Prompts (6): - pi-mono templates for PR review, issue analysis, changelog audit Sources analyzed: jat, ralph-desktop, toad, pi-mono, cmux, pi-interactive-shell, craft-agents-oss, dexter, picoclaw, dyad, system_prompts_leaks, Prometheus, zed, clawdbot, OS-Copilot, and more
2026-02-13 10:58:17 +00:00
parent 5889d3428b
commit b60638f0a3
186 changed files with 38926 additions and 325 deletions
--- a/skills/community/jat/jat-complete/SKILL.md
+++ b/skills/community/jat/jat-complete/SKILL.md
@@ -0,0 +1,248 @@
+---
+name: jat-complete
+description: Complete current JAT task with full verification. Verifies work (tests/lint), commits changes, writes memory entry, closes task, releases file reservations, and emits final signal. Session ends after completion.
+metadata:
+  author: jat
+  version: "1.0"
+---
+
+# /skill:jat-complete - Finish Task Properly
+
+Complete current task with full verification protocol. Session ends after completion.
+
+## Usage
+
+```
+/skill:jat-complete         # Complete task, show completion block
+/skill:jat-complete --kill  # Complete and auto-kill session
+```
+
+## What This Does
+
+1. **Verify task** (tests, lint, security)
+2. **Commit changes** with proper message
+3. **Write memory entry** - Save context for future agents
+4. **Mark task complete** (`jt close`)
+5. **Release file reservations**
+6. **Emit completion signal** to IDE
+
+## Prerequisites
+
+You MUST have emitted a `review` signal before running this:
+
+```bash
+jat-signal review '{
+  "taskId": "TASK_ID",
+  "taskTitle": "TASK_TITLE",
+  "summary": ["What you accomplished"],
+  "filesModified": [
+    {"path": "src/file.ts", "changeType": "modified", "linesAdded": 50, "linesRemoved": 10}
+  ]
+}'
+```
+
+## Step-by-Step Instructions
+
+### STEP 1: Get Current Task and Agent Identity
+
+#### 1A: Get Agent Name
+
+Check the tmux session name or identity file:
+
+```bash
+TMUX_SESSION=$(tmux display-message -p '#S' 2>/dev/null)
+# Agent name is the tmux session without "jat-" prefix
+AGENT_NAME="${TMUX_SESSION#jat-}"
+```
+
+#### 1B: Get Current Task
+
+Find your in-progress task:
+
+```bash
+jt list --json | jq -r '.[] | select(.assignee == "AGENT_NAME" and .status == "in_progress") | .id'
+```
+
+If no task found, check for spontaneous work (uncommitted changes without a formal task).
+
+### STEP 1D: Spontaneous Work Detection
+
+**Only if no in_progress task was found.**
+
+Check git status and conversation context for work that was done without a formal task:
+
+```bash
+git status --porcelain
+git diff --stat
+git log --oneline -5
+```
+
+If work is detected, propose creating a backfill task record:
+
+```bash
+jt create "INFERRED_TITLE" \
+  --type INFERRED_TYPE \
+  --description "INFERRED_DESCRIPTION" \
+  --assignee "$AGENT_NAME" \
+  --status in_progress
+```
+
+If no work detected, exit the completion flow.
+
+### STEP 2: Verify Task
+
+Run verification checks appropriate to the project:
+
+```bash
+# Emit verifying signal
+jat-step verifying --task "$TASK_ID" --title "$TASK_TITLE" --agent "$AGENT_NAME"
+
+# Then run checks:
+# - Tests (npm test, pytest, etc.)
+# - Lint (eslint, ruff, etc.)
+# - Type check (tsc --noEmit, etc.)
+# - Build (npm run build, etc.)
+```
+
+If verification fails, stop and fix issues before continuing.
+
+### STEP 2.5: Update Documentation (If Appropriate)
+
+Only update docs when changes affect how others use the codebase:
+- New tool/command added
+- New API endpoint
+- Breaking change
+- New configuration option
+
+Most tasks do NOT need doc updates.
+
+### STEP 3: Commit Changes
+
+```bash
+# Get task type for commit prefix
+TASK_TYPE=$(jt show "$TASK_ID" --json | jq -r '.[0].issue_type // "task"')
+
+# Commit with proper message format
+jat-step committing --task "$TASK_ID" --title "$TASK_TITLE" --agent "$AGENT_NAME" --type "$TASK_TYPE"
+```
+
+If `jat-step` is not available, commit manually:
+
+```bash
+git add -A
+git commit -m "TASK_TYPE($TASK_ID): TASK_TITLE
+
+Co-Authored-By: Pi Agent <noreply@pi.dev>"
+```
+
+### STEP 3.5: Write Memory Entry
+
+Save context from this session for future agents. Use the Write tool to create:
+
+```
+.jat/memory/{YYYY-MM-DD}-{taskId}-{slug}.md
+```
+
+Include YAML frontmatter (task, agent, project, completed, files, tags, labels, priority, type) and sections: Summary, Approach, Decisions (if notable), Key Files, Lessons (if any).
+
+Then trigger incremental index:
+
+```bash
+jat-memory index --project "$(pwd)"
+```
+
+If indexing fails, log the error but continue. Memory is non-blocking.
+
+### STEP 4: Mark Task Complete
+
+```bash
+jat-step closing --task "$TASK_ID" --title "$TASK_TITLE" --agent "$AGENT_NAME"
+```
+
+Or manually:
+
+```bash
+jt close "$TASK_ID" --reason "Completed by $AGENT_NAME"
+```
+
+### STEP 4.5: Auto-Close Eligible Epics
+
+```bash
+jt epic close-eligible
+```
+
+### STEP 5: Release File Reservations
+
+```bash
+jat-step releasing --task "$TASK_ID" --title "$TASK_TITLE" --agent "$AGENT_NAME"
+```
+
+Or manually:
+
+```bash
+am-reservations --agent "$AGENT_NAME" --json | jq -r '.[].pattern' | while read pattern; do
+  am-release "$pattern" --agent "$AGENT_NAME"
+done
+```
+
+### STEP 6: Emit Completion Signal
+
+```bash
+jat-step complete --task "$TASK_ID" --title "$TASK_TITLE" --agent "$AGENT_NAME"
+```
+
+This generates a structured completion bundle and emits the final `complete` signal.
+
+Then output the completion banner:
+
+```
+TASK COMPLETED: $TASK_ID
+Agent: $AGENT_NAME
+
+Summary:
+  - [accomplishment 1]
+  - [accomplishment 2]
+
+Quality: tests passing, build clean
+
+Session complete. Spawn a new agent for the next task.
+```
+
+## "Ready for Review" vs "Complete"
+
+| State | Meaning | Task Status |
+|-------|---------|--------------|
+| Ready for Review | Code done, awaiting user decision | in_progress |
+| Complete | Closed, reservations released | closed |
+
+**Never say "Task Complete" until jt close has run.**
+
+## Error Handling
+
+**No task in progress:**
+```
+No task in progress. Run /skill:jat-start to pick a task.
+```
+
+**Verification failed:**
+```
+Verification failed:
+  - 2 tests failing
+  - 5 lint errors
+Fix issues and try again.
+```
+
+## Step Summary
+
+| Step | Name | Tool |
+|------|------|------|
+| 1 | Get Task and Agent Identity | jt list, tmux |
+| 1D | Spontaneous Work Detection | git status |
+| 2 | Verify Task | jat-step verifying |
+| 2.5 | Update Documentation | (if appropriate) |
+| 3 | Commit Changes | jat-step committing |
+| 3.5 | Write Memory Entry | Write tool + jat-memory index |
+| 4 | Mark Task Complete | jat-step closing |
+| 4.5 | Auto-Close Epics | jt epic close-eligible |
+| 5 | Release Reservations | jat-step releasing |
+| 6 | Emit Completion Signal | jat-step complete |
--- a/skills/community/jat/jat-start/SKILL.md
+++ b/skills/community/jat/jat-start/SKILL.md
@@ -0,0 +1,232 @@
+---
+name: jat-start
+description: Begin working on a JAT task. Registers agent identity, selects a task, searches memory, detects conflicts, reserves files, emits IDE signals, and starts work. Use this at the beginning of every JAT session.
+metadata:
+  author: jat
+  version: "1.0"
+---
+
+# /skill:jat-start - Begin Working
+
+**One agent = one session = one task.** Each session handles exactly one task from start to completion.
+
+## Usage
+
+```
+/skill:jat-start                    # Show available tasks
+/skill:jat-start task-id            # Start specific task
+/skill:jat-start AgentName          # Resume as AgentName
+/skill:jat-start AgentName task-id  # Resume as AgentName on task
+```
+
+Add `quick` to skip conflict checks.
+
+## What This Does
+
+1. **Establish identity** - Register or resume agent in Agent Registry
+2. **Select task** - From parameter or show recommendations
+3. **Search memory** - Surface context from past sessions
+4. **Review prior tasks** - Check for duplicates and related work
+5. **Start work** - Reserve files, update task status
+6. **Emit signals** - IDE tracks state through jat-signal
+
+## Step-by-Step Instructions
+
+### STEP 1: Parse Arguments
+
+Check what was passed: `$ARGUMENTS` may contain agent-name, task-id, both, or nothing.
+
+```bash
+# Test if a param is a valid task ID
+jt show "$PARAM" --json >/dev/null 2>&1 && echo "task-id" || echo "agent-name"
+```
+
+### STEP 2: Get/Create Agent Identity
+
+#### 2A: Check for IDE Pre-Registration
+
+If spawned by the IDE, your identity file already exists:
+
+```bash
+TMUX_SESSION=$(tmux display-message -p '#S' 2>/dev/null)
+PRE_REG_FILE=".claude/sessions/.tmux-agent-${TMUX_SESSION}"
+test -f "$PRE_REG_FILE" && cat "$PRE_REG_FILE"
+```
+
+If found, use that name and skip to Step 3.
+
+#### 2B: Register Manually (CLI only)
+
+If no pre-registration file exists, pick a name and register:
+
+```bash
+# Generate or use provided name
+am-register --name "$AGENT_NAME" --program pi --model "$MODEL_ID"
+tmux rename-session "jat-${AGENT_NAME}" 2>/dev/null
+```
+
+#### 2C: Write Session Identity
+
+For manual sessions, write the identity file so the IDE can track you:
+
+```bash
+mkdir -p .claude/sessions
+echo "$AGENT_NAME" > ".claude/sessions/agent-${SESSION_ID}.txt"
+```
+
+### STEP 3: Select Task
+
+If a task-id was provided, use it. Otherwise, show available work:
+
+```bash
+jt ready --json | jq -r '.[] | "  [P\(.priority)] \(.id) - \(.title)"'
+```
+
+If no task-id provided, display recommendations and stop here.
+
+### STEP 4: Search Memory
+
+Search project memory for relevant context from past sessions:
+
+```bash
+jat-memory search "key terms from task title" --limit 5
+```
+
+Returns JSON with matching chunks (taskId, section, snippet, score). Use results to:
+- Incorporate lessons and gotchas into your approach
+- Avoid repeating documented mistakes
+- Build on established patterns
+
+If no memory index exists, skip silently.
+
+### STEP 5: Review Prior Tasks
+
+Search for related or duplicate work from the last 7 days:
+
+```bash
+DATE_7D=$(date -d '7 days ago' +%Y-%m-%d 2>/dev/null || date -v-7d +%Y-%m-%d)
+jt search "$SEARCH_TERM" --updated-after "$DATE_7D" --limit 20 --json
+```
+
+Look for:
+- **Duplicates** (closed tasks with nearly identical titles) - ask user before proceeding
+- **Related work** (same files/features) - note for context
+- **In-progress** by other agents - coordinate to avoid conflicts
+
+### STEP 6: Conflict Detection
+
+```bash
+am-reservations --json          # Check file locks
+git diff-index --quiet HEAD --  # Check uncommitted changes
+```
+
+### STEP 7: Start the Task
+
+```bash
+# Update task status
+jt update "$TASK_ID" --status in_progress --assignee "$AGENT_NAME"
+
+# Reserve files you'll edit
+am-reserve "relevant/files/**" --agent "$AGENT_NAME" --ttl 3600 --reason "$TASK_ID"
+```
+
+### STEP 8: Emit Signals
+
+**Both signals are required before starting actual work.**
+
+#### 8A: Starting Signal
+
+```bash
+jat-signal starting '{
+  "agentName": "AGENT_NAME",
+  "sessionId": "SESSION_ID",
+  "taskId": "TASK_ID",
+  "taskTitle": "TASK_TITLE",
+  "project": "PROJECT",
+  "model": "MODEL_ID",
+  "tools": ["bash", "read", "write", "edit"],
+  "gitBranch": "BRANCH",
+  "gitStatus": "clean",
+  "uncommittedFiles": []
+}'
+```
+
+#### 8B: Working Signal
+
+After reading the task and planning your approach:
+
+```bash
+jat-signal working '{
+  "taskId": "TASK_ID",
+  "taskTitle": "TASK_TITLE",
+  "approach": "Brief description of implementation plan",
+  "expectedFiles": ["src/**/*.ts"],
+  "baselineCommit": "COMMIT_HASH"
+}'
+```
+
+#### 8C: Output Banner
+
+```
+╔════════════════════════════════════════════════════════════╗
+║         STARTING WORK: {TASK_ID}                           ║
+╚════════════════════════════════════════════════════════════╝
+
+Agent: {AGENT_NAME}
+Task: {TASK_TITLE}
+Priority: P{X}
+
+Approach:
+  {YOUR_APPROACH_DESCRIPTION}
+```
+
+## Asking Questions During Work
+
+**Always emit `needs_input` signal BEFORE asking questions:**
+
+```bash
+jat-signal needs_input '{
+  "taskId": "TASK_ID",
+  "question": "Brief description of what you need",
+  "questionType": "clarification"
+}'
+```
+
+Question types: `clarification`, `decision`, `approval`, `blocker`, `duplicate_check`
+
+After getting a response, emit `working` signal to resume.
+
+## When You Finish Working
+
+**Emit `review` signal BEFORE presenting results:**
+
+```bash
+jat-signal review '{
+  "taskId": "TASK_ID",
+  "taskTitle": "TASK_TITLE",
+  "summary": ["What you accomplished", "Key changes"],
+  "filesModified": [
+    {"path": "src/file.ts", "changeType": "modified", "linesAdded": 50, "linesRemoved": 10}
+  ]
+}'
+```
+
+Then output:
+```
+READY FOR REVIEW: {TASK_ID}
+
+Summary:
+  - [accomplishment 1]
+  - [accomplishment 2]
+
+Run /skill:jat-complete when ready to close this task.
+```
+
+## Signal Reference
+
+| Signal | When | Required Fields |
+|--------|------|-----------------|
+| `starting` | After registration | agentName, sessionId, project, model, gitBranch, gitStatus, tools |
+| `working` | Before coding | taskId, taskTitle, approach |
+| `needs_input` | Before asking questions | taskId, question, questionType |
+| `review` | When work complete | taskId, taskTitle, summary |
--- a/skills/community/jat/jat-verify/SKILL.md
+++ b/skills/community/jat/jat-verify/SKILL.md
@@ -0,0 +1,113 @@
+---
+name: jat-verify
+description: Escalatory browser verification - open the app in a real browser and test the feature you built. Use after showing "READY FOR REVIEW" when the user asks you to verify in a browser.
+metadata:
+  author: jat
+  version: "1.0"
+---
+
+# /skill:jat-verify - Browser Verification
+
+Test your work in a real browser using JAT's browser automation tools.
+
+## Usage
+
+```
+/skill:jat-verify                           # Auto-detect what to test
+/skill:jat-verify http://localhost:5173/tasks  # Test specific URL
+/skill:jat-verify /tasks                     # Test specific path
+```
+
+## When to Use
+
+- User asks to "verify in browser" or "actually test this"
+- After showing "READY FOR REVIEW"
+- NOT for static checks (tests, lint) - those are in `/skill:jat-complete`
+
+## Browser Tools
+
+JAT includes browser automation tools in `~/.local/bin/`:
+
+| Tool | Purpose |
+|------|---------|
+| `browser-start.js` | Launch Chrome with DevTools port |
+| `browser-nav.js` | Navigate to URL |
+| `browser-screenshot.js` | Capture screenshot |
+| `browser-eval.js` | Execute JavaScript in page |
+| `browser-pick.js` | Click element by selector |
+| `browser-cookies.js` | Get/set cookies |
+| `browser-wait.js` | Wait for condition |
+
+## Steps
+
+### STEP 1: Determine What to Test
+
+Based on your recent work, identify:
+- **URL**: What page to open
+- **Feature**: What to test
+- **Success criteria**: How to know it works
+
+If unclear, ask the user.
+
+### STEP 2: Open Browser and Navigate
+
+```bash
+browser-start.js
+browser-nav.js --url "http://localhost:5173/tasks"
+browser-screenshot.js --output /tmp/verify-initial.png
+```
+
+Show the screenshot and describe what you see.
+
+### STEP 3: Test the Feature
+
+Interact with what you built:
+
+```bash
+# Click elements
+browser-pick.js --selector "button.create-task"
+
+# Fill form fields
+browser-eval.js "document.querySelector('input[name=title]').value = 'Test'"
+
+# Check for elements
+browser-eval.js "!!document.querySelector('.success-message')"
+
+# Wait for content
+browser-wait.js --text "Task created"
+```
+
+Take screenshots after each significant action.
+
+### STEP 4: Check Console for Errors
+
+```bash
+browser-eval.js "window.__errors = []; const orig = console.error; console.error = (...a) => { window.__errors.push(a.join(' ')); orig.apply(console, a); }"
+# ... test the feature ...
+browser-eval.js "window.__errors"
+```
+
+### STEP 5: Report Findings
+
+```
+BROWSER VERIFICATION: {TASK_ID}
+
+URL: http://localhost:5173/tasks
+Feature: Task creation drawer
+
+  [pass] Page loaded successfully
+  [pass] Button visible and clickable
+  [pass] Form renders correctly
+  [pass] No console errors
+
+Screenshots:
+  /tmp/verify-initial.png
+  /tmp/verify-after-action.png
+```
+
+If issues found, fix them and re-verify.
+
+## After Verification
+
+- **Passed**: Return to "READY FOR REVIEW" state
+- **Failed**: Fix issues, re-verify, then return to review state