cfsa-antigravity 3.0.2 → 3.1.0

package/template/.codex/skill-library/meta/product-marketing-context/SKILL.md

@@ -0,0 +1,241 @@
+---
+name: product-marketing-context
+description: "When the user wants to create or update their product marketing context document. Also use when the user mentions 'product context,' 'marketing context,' 'set up context,' 'positioning,' or wants to avoid repeating foundational information across marketing tasks. Creates `.agents/product-marketing-context.md` that other marketing skills reference."
+metadata:
+  version: 1.1.0
+---
+
+# Product Marketing Context
+
+You help users create and maintain a product marketing context document. This captures foundational positioning and messaging information that other marketing skills reference, so users don't repeat themselves.
+
+The document is stored at `.agents/product-marketing-context.md`.
+
+## Workflow
+
+### Step 1: Check for Existing Context
+
+First, check if `.agents/product-marketing-context.md` already exists. Also check `.codex/product-marketing-context.md` for older setups — if found there but not in `.agents/`, offer to move it.
+
+**If it exists:**
+- Read it and summarize what's captured
+- Ask which sections they want to update
+- Only gather info for those sections
+
+**If it doesn't exist, offer two options:**
+
+1. **Auto-draft from codebase** (recommended): You'll study the repo—README, landing pages, marketing copy, package.json, etc.—and draft a V1 of the context document. The user then reviews, corrects, and fills gaps. This is faster than starting from scratch.
+
+2. **Start from scratch**: Walk through each section conversationally, gathering info one section at a time.
+
+Most users prefer option 1. After presenting the draft, ask: "What needs correcting? What's missing?"
+
+### Step 2: Gather Information
+
+**If auto-drafting:**
+1. Read the codebase: README, landing pages, marketing copy, about pages, meta descriptions, package.json, any existing docs
+2. Draft all sections based on what you find
+3. Present the draft and ask what needs correcting or is missing
+4. Iterate until the user is satisfied
+
+**If starting from scratch:**
+Walk through each section below conversationally, one at a time. Don't dump all questions at once.
+
+For each section:
+1. Briefly explain what you're capturing
+2. Ask relevant questions
+3. Confirm accuracy
+4. Move to the next
+
+**Important:** Push for verbatim customer language. Exact phrases are more valuable than polished descriptions.
+
+---
+
+## Sections to Capture
+
+### 1. Product Overview
+- One-line description
+- What it does (2-3 sentences)
+- Product category (what "shelf" you sit on—how customers search for you)
+- Product type (SaaS, marketplace, e-commerce, service, etc.)
+- Business model and pricing
+
+### 2. Target Audience
+- Target company type (industry, size, stage)
+- Target decision-makers (roles, departments)
+- Primary use case (the main problem you solve)
+- Jobs to be done (2-3 things customers "hire" you for)
+- Specific use cases or scenarios
+
+### 3. Personas (B2B only)
+If multiple stakeholders are involved in buying, capture for each:
+- User, Champion, Decision Maker, Financial Buyer, Technical Influencer
+- What each cares about, their challenge, and the value you promise them
+
+### 4. Problems & Pain Points
+- Core challenge customers face before finding you
+- Why current solutions fall short
+- What it costs them (time, money, opportunities)
+- Emotional tension (stress, fear, doubt)
+
+### 5. Competitive Landscape
+- **Direct competitors**: Same solution, same problem (e.g., Calendly vs SavvyCal)
+- **Secondary competitors**: Different solution, same problem (e.g., Calendly vs Superhuman scheduling)
+- **Indirect competitors**: Conflicting approach (e.g., Calendly vs personal assistant)
+- How each falls short for customers
+
+### 6. Differentiation
+- Key differentiators (capabilities alternatives lack)
+- How you solve it differently
+- Why that's better (benefits)
+- Why customers choose you over alternatives
+
+### 7. Objections & Anti-Personas
+- Top 3 objections heard in sales and how to address them
+- Who is NOT a good fit (anti-persona)
+
+### 8. Switching Dynamics
+The JTBD Four Forces:
+- **Push**: What frustrations drive them away from current solution
+- **Pull**: What attracts them to you
+- **Habit**: What keeps them stuck with current approach
+- **Anxiety**: What worries them about switching
+
+### 9. Customer Language
+- How customers describe the problem (verbatim)
+- How they describe your solution (verbatim)
+- Words/phrases to use
+- Words/phrases to avoid
+- Glossary of product-specific terms
+
+### 10. Brand Voice
+- Tone (professional, casual, playful, etc.)
+- Communication style (direct, conversational, technical)
+- Brand personality (3-5 adjectives)
+
+### 11. Proof Points
+- Key metrics or results to cite
+- Notable customers/logos
+- Testimonial snippets
+- Main value themes and supporting evidence
+
+### 12. Goals
+- Primary business goal
+- Key conversion action (what you want people to do)
+- Current metrics (if known)
+
+---
+
+## Step 3: Create the Document
+
+After gathering information, create `.agents/product-marketing-context.md` with this structure:
+
+```markdown
+# Product Marketing Context
+
+*Last updated: [date]*
+
+## Product Overview
+**One-liner:**
+**What it does:**
+**Product category:**
+**Product type:**
+**Business model:**
+
+## Target Audience
+**Target companies:**
+**Decision-makers:**
+**Primary use case:**
+**Jobs to be done:**
+-
+**Use cases:**
+-
+
+## Personas
+| Persona | Cares about | Challenge | Value we promise |
+|---------|-------------|-----------|------------------|
+| | | | |
+
+## Problems & Pain Points
+**Core problem:**
+**Why alternatives fall short:**
+-
+**What it costs them:**
+**Emotional tension:**
+
+## Competitive Landscape
+**Direct:** [Competitor] — falls short because...
+**Secondary:** [Approach] — falls short because...
+**Indirect:** [Alternative] — falls short because...
+
+## Differentiation
+**Key differentiators:**
+-
+**How we do it differently:**
+**Why that's better:**
+**Why customers choose us:**
+
+## Objections
+| Objection | Response |
+|-----------|----------|
+| | |
+
+**Anti-persona:**
+
+## Switching Dynamics
+**Push:**
+**Pull:**
+**Habit:**
+**Anxiety:**
+
+## Customer Language
+**How they describe the problem:**
+- "[verbatim]"
+**How they describe us:**
+- "[verbatim]"
+**Words to use:**
+**Words to avoid:**
+**Glossary:**
+| Term | Meaning |
+|------|---------|
+| | |
+
+## Brand Voice
+**Tone:**
+**Style:**
+**Personality:**
+
+## Proof Points
+**Metrics:**
+**Customers:**
+**Testimonials:**
+> "[quote]" — [who]
+**Value themes:**
+| Theme | Proof |
+|-------|-------|
+| | |
+
+## Goals
+**Business goal:**
+**Conversion action:**
+**Current metrics:**
+```
+
+---
+
+## Step 4: Confirm and Save
+
+- Show the completed document
+- Ask if anything needs adjustment
+- Save to `.agents/product-marketing-context.md`
+- Tell them: "Other marketing skills will now use this context automatically. Run `/product-marketing-context` anytime to update it."
+
+---
+
+## Tips
+
+- **Be specific**: Ask "What's the #1 frustration that brings them to you?" not "What problem do they solve?"
+- **Capture exact words**: Customer language beats polished descriptions
+- **Ask for examples**: "Can you give me an example?" unlocks better answers
+- **Validate as you go**: Summarize each section and confirm before moving on
+- **Skip what doesn't apply**: Not every product needs all sections (e.g., Personas for B2C)

package/template/.codex/skill-library/meta/tmux-processes/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: tmux-processes
+description: Patterns for running long-lived processes in tmux. Use when starting dev servers, watchers, tilt, or any process expected to outlive the conversation.
+---
+
+# tmux Process Management
+
+## Interactive Shell Requirement
+
+**Use send-keys pattern for reliable shell initialization.** Creating a session spawns an interactive shell automatically. Use `send-keys` to run commands within that shell, ensuring PATH, direnv, and other initialization runs properly.
+
+```bash
+# WRONG - inline command bypasses shell init, breaks PATH/direnv
+tmux new-session -d -s "$SESSION" -n main 'tilt up'
+
+# CORRECT - create session, then send command to interactive shell
+tmux new-session -d -s "$SESSION" -n main
+tmux send-keys -t "$SESSION:main" 'tilt up' Enter
+```
+
+## Session Naming Convention
+
+Always derive session name from the project:
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+```
+
+For multiple processes in one project, use windows not separate sessions:
+- Session: `myapp`
+- Windows: `server`, `tests`, `logs`
+
+## Starting Processes
+
+### Single Process
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Create session with named window, then send command
+tmux new-session -d -s "$SESSION" -n main
+tmux send-keys -t "$SESSION:main" '<command>' Enter
+```
+
+### Idempotent Start
+
+Check if already running before starting:
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+if ! tmux has-session -t "$SESSION" 2>/dev/null; then
+  tmux new-session -d -s "$SESSION" -n main
+  tmux send-keys -t "$SESSION:main" '<command>' Enter
+else
+  echo "Session $SESSION already exists"
+fi
+```
+
+### Adding Windows to Existing Session
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Add a new window if it doesn't exist
+if ! tmux list-windows -t "$SESSION" -F '#{window_name}' | grep -q "^server$"; then
+  tmux new-window -t "$SESSION" -n server
+  tmux send-keys -t "$SESSION:server" 'npm run dev' Enter
+else
+  echo "Window 'server' already exists"
+fi
+```
+
+### Multiple Processes (Windows)
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Create session with first process
+tmux new-session -d -s "$SESSION" -n server
+tmux send-keys -t "$SESSION:server" 'npm run dev' Enter
+
+# Add more windows
+tmux new-window -t "$SESSION" -n tests
+tmux send-keys -t "$SESSION:tests" 'npm run test:watch' Enter
+
+tmux new-window -t "$SESSION" -n logs
+tmux send-keys -t "$SESSION:logs" 'tail -f logs/app.log' Enter
+```
+
+## Monitoring Output
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Last 50 lines from first window
+tmux capture-pane -p -t "$SESSION" -S -50
+
+# From specific window
+tmux capture-pane -p -t "$SESSION:server" -S -50
+
+# Check for errors
+tmux capture-pane -p -t "$SESSION" -S -100 | rg -i "error|fail|exception"
+
+# Check for ready indicators
+tmux capture-pane -p -t "$SESSION:server" -S -50 | rg -i "listening|ready|started"
+```
+
+## Lifecycle Management
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# List all sessions (see what exists)
+tmux ls
+
+# List windows in current session
+tmux list-windows -t "$SESSION"
+
+# Kill only this project's session
+tmux kill-session -t "$SESSION"
+
+# Kill specific window
+tmux kill-window -t "$SESSION:tests"
+
+# Send keys to a window (e.g., Ctrl+C to stop)
+tmux send-keys -t "$SESSION:server" C-c
+```
+
+## Isolation Rules
+
+- **Never** use `tmux kill-server`
+- **Never** kill sessions not matching current project
+- **Always** derive session name from git root or pwd
+- **Always** verify session name before kill operations
+- Other Claude Code instances may have their own sessions running
+
+## When to Use tmux
+
+| Scenario | Use tmux? |
+|----------|-----------|
+| `tilt up` | Yes, always |
+| Dev server (`npm run dev`, `rails s`) | Yes |
+| File watcher (`npm run watch`) | Yes |
+| Test watcher (`npm run test:watch`) | Yes |
+| Database server | Yes |
+| One-shot build (`npm run build`) | No |
+| Quick command (<10s) | No |
+| Need stdout directly in conversation | No |
+
+## Checking Process Status
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Check session exists
+tmux has-session -t "$SESSION" 2>/dev/null && echo "session exists" || echo "no session"
+
+# List windows and their status
+tmux list-windows -t "$SESSION" -F '#{window_name}: #{pane_current_command}'
+
+# Check if specific window exists
+tmux list-windows -t "$SESSION" -F '#{window_name}' | grep -q "^server$" && echo "server window exists"
+```
+
+## Restarting a Process
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Send Ctrl+C then restart command
+tmux send-keys -t "$SESSION:server" C-c
+sleep 1
+tmux send-keys -t "$SESSION:server" 'npm run dev' Enter
+```
+
+## Common Patterns
+
+### Start dev server if not running
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+if ! tmux has-session -t "$SESSION" 2>/dev/null; then
+  tmux new-session -d -s "$SESSION" -n server
+  tmux send-keys -t "$SESSION:server" 'npm run dev' Enter
+  echo "Started dev server in tmux session: $SESSION"
+elif ! tmux list-windows -t "$SESSION" -F '#{window_name}' | grep -q "^server$"; then
+  tmux new-window -t "$SESSION" -n server
+  tmux send-keys -t "$SESSION:server" 'npm run dev' Enter
+  echo "Added server window to session: $SESSION"
+else
+  echo "Server already running in session: $SESSION"
+fi
+```
+
+### Wait for server ready
+
+```bash
+SESSION=$(basename $(git rev-parse --show-toplevel 2>/dev/null) || basename $PWD)
+
+# Poll for ready message
+for i in {1..30}; do
+  if tmux capture-pane -p -t "$SESSION:server" -S -20 | rg -q "listening|ready"; then
+    echo "Server ready"
+    break
+  fi
+  sleep 1
+done
+```

package/template/.codex/skill-library/meta/using-tmux-for-interactive-commands/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: using-tmux-for-interactive-commands
+description: Use when you need to run interactive CLI tools (vim, git rebase -i, Python REPL, etc.) that require real-time input/output - provides tmux-based approach for controlling interactive sessions through detached sessions and send-keys
+---
+
+# Using tmux for Interactive Commands
+
+## Overview
+
+Interactive CLI tools (vim, interactive git rebase, REPLs, etc.) cannot be controlled through standard bash because they require a real terminal. tmux provides detached sessions that can be controlled programmatically via `send-keys` and `capture-pane`.
+
+## When to Use
+
+**Use tmux when:**
+- Running vim, nano, or other text editors programmatically
+- Controlling interactive REPLs (Python, Node, etc.)
+- Handling interactive git commands (`git rebase -i`, `git add -p`)
+- Working with full-screen terminal apps (htop, etc.)
+- Commands that require terminal control codes or readline
+
+**Don't use for:**
+- Simple non-interactive commands (use regular Bash tool)
+- Commands that accept input via stdin redirection
+- One-shot commands that don't need interaction
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Start session | `tmux new-session -d -s <name> <command>` |
+| Send input | `tmux send-keys -t <name> 'text' Enter` |
+| Capture output | `tmux capture-pane -t <name> -p` |
+| Stop session | `tmux kill-session -t <name>` |
+| List sessions | `tmux list-sessions` |
+
+## Core Pattern
+
+### Before (Won't Work)
+```bash
+# This hangs because vim expects interactive terminal
+bash -c "vim file.txt"
+```
+
+### After (Works)
+```bash
+# Create detached tmux session
+tmux new-session -d -s edit_session vim file.txt
+
+# Send commands (Enter, Escape are tmux key names)
+tmux send-keys -t edit_session 'i' 'Hello World' Escape ':wq' Enter
+
+# Capture what's on screen
+tmux capture-pane -t edit_session -p
+
+# Clean up
+tmux kill-session -t edit_session
+```
+
+## Implementation
+
+### Basic Workflow
+
+1. **Create detached session** with the interactive command
+2. **Wait briefly** for initialization (100-500ms depending on command)
+3. **Send input** using `send-keys` (can send special keys like Enter, Escape)
+4. **Capture output** using `capture-pane -p` to see current screen state
+5. **Repeat** steps 3-4 as needed
+6. **Terminate** session when done
+
+### Special Keys
+
+Common tmux key names:
+- `Enter` - Return/newline
+- `Escape` - ESC key
+- `C-c` - Ctrl+C
+- `C-x` - Ctrl+X
+- `Up`, `Down`, `Left`, `Right` - Arrow keys
+- `Space` - Space bar
+- `BSpace` - Backspace
+
+### Working Directory
+
+Specify working directory when creating session:
+```bash
+tmux new-session -d -s git_session -c /path/to/repo git rebase -i HEAD~3
+```
+
+### Helper Wrapper
+
+For easier use, see `/home/jesse/git/interactive-command/tmux-wrapper.sh`:
+```bash
+# Start session
+/path/to/tmux-wrapper.sh start <session-name> <command> [args...]
+
+# Send input
+/path/to/tmux-wrapper.sh send <session-name> 'text' Enter
+
+# Capture current state
+/path/to/tmux-wrapper.sh capture <session-name>
+
+# Stop
+/path/to/tmux-wrapper.sh stop <session-name>
+```
+
+## Common Patterns
+
+### Python REPL
+```bash
+tmux new-session -d -s python python3 -i
+tmux send-keys -t python 'import math' Enter
+tmux send-keys -t python 'print(math.pi)' Enter
+tmux capture-pane -t python -p  # See output
+tmux kill-session -t python
+```
+
+### Vim Editing
+```bash
+tmux new-session -d -s vim vim /tmp/file.txt
+sleep 0.3  # Wait for vim to start
+tmux send-keys -t vim 'i' 'New content' Escape ':wq' Enter
+# File is now saved
+```
+
+### Interactive Git Rebase
+```bash
+tmux new-session -d -s rebase -c /repo/path git rebase -i HEAD~3
+sleep 0.5
+tmux capture-pane -t rebase -p  # See rebase editor
+# Send commands to modify rebase instructions
+tmux send-keys -t rebase 'Down' 'Home' 'squash' Escape
+tmux send-keys -t rebase ':wq' Enter
+```
+
+## Common Mistakes
+
+### Not Waiting After Session Start
+**Problem:** Capturing immediately after `new-session` shows blank screen
+
+**Fix:** Add brief sleep (100-500ms) before first capture
+```bash
+tmux new-session -d -s sess command
+sleep 0.3  # Let command initialize
+tmux capture-pane -t sess -p
+```
+
+### Forgetting Enter Key
+**Problem:** Commands typed but not executed
+
+**Fix:** Explicitly send Enter
+```bash
+tmux send-keys -t sess 'print("hello")' Enter  # Note: Enter is separate argument
+```
+
+### Using Wrong Key Names
+**Problem:** `tmux send-keys -t sess '\n'` doesn't work
+
+**Fix:** Use tmux key names: `Enter`, not `\n`
+```bash
+tmux send-keys -t sess 'text' Enter  # ✓
+tmux send-keys -t sess 'text\n'      # ✗
+```
+
+### Not Cleaning Up Sessions
+**Problem:** Orphaned tmux sessions accumulate
+
+**Fix:** Always kill sessions when done
+```bash
+tmux kill-session -t session_name
+# Or check for existing: tmux has-session -t name 2>/dev/null
+```
+
+## Real-World Impact
+
+- Enables programmatic control of vim/nano for file editing
+- Allows automation of interactive git workflows (rebase, add -p)
+- Makes REPL-based testing/debugging possible
+- Unblocks any tool that requires terminal interaction
+- No need to build custom PTY management - tmux handles it all