cue-ai 0.3.0 → 0.4.0

package/resources/skills/skills/design/headless-gif-demo/SKILL.md

@@ -0,0 +1,168 @@
+---
+description: "When user asks to record a high-quality CLI demo GIF that needs Kitty graphics protocol (real PNG icons inline) — use this headless Xvfb + Kitty + tmux + ffmpeg pipeline instead of vhs/asciinema which don't speak the Kitty protocol"
+requires_mcps: []
+allowed-tools: Bash(Xvfb:*), Bash(kitty:*), Bash(tmux:*), Bash(xdotool:*), Bash(ffmpeg:*), Bash(/usr/bin/ffmpeg:*), Read(*), Write(*)
+---
+
+# Headless GIF demos with Kitty + tmux + Xvfb + ffmpeg
+
+When you need a demo GIF of a CLI tool that uses **Kitty graphics protocol** (e.g. cue's brand-logo PNGs in `cue optimizer`), `vhs` and `asciinema` won't work — they render in `ttyd` which doesn't speak the protocol. Logos show as garbled placeholder boxes or fall back to emoji.
+
+This skill captures the working pipeline: spin up a virtual X display, run real Kitty inside it (no monitor needed), drive the demo with `tmux send-keys`, and screen-record with `ffmpeg x11grab`.
+
+## When to use
+
+- ✅ Demo of a CLI that uses Kitty graphics (inline images, brand logos, plots)
+- ✅ Demo of a TUI that depends on truecolor + Unicode + Nerd Font glyphs
+- ✅ Demo that must show interactive prompts (pickers, confirmations)
+- ❌ Plain shell-output demos → use `vhs` (simpler, no X needed)
+- ❌ Real session recordings → use `asciinema` (escape-sequence based)
+
+## Required tools
+
+| Tool | Install (apt) | Install (nix) |
+|---|---|---|
+| `Xvfb` | `sudo apt install xvfb` | `nix profile install nixpkgs#xorg.xorgserver` |
+| `xdotool` | `sudo apt install xdotool` | `nix profile install nixpkgs#xdotool` |
+| `ffmpeg` with `x11grab` | `sudo apt install ffmpeg` (**not** nix-pure ffmpeg — that one lacks x11grab) | `nix profile install nixpkgs#ffmpeg-full` |
+| `kitty` | already on your box | — |
+| `tmux` | already on your box | — |
+
+**Gotcha:** verify ffmpeg has x11grab with `ffmpeg -devices | grep x11`. nix's stock `ffmpeg` doesn't ship it — use `/usr/bin/ffmpeg` (apt) or `ffmpeg-full` (nix).
+
+## The pipeline
+
+```
+Xvfb :99 → kitty (--start-as=fullscreen, attached to tmux session)
+              ↓
+        tmux send-keys (drives demo non-interactively)
+              ↓
+        ffmpeg x11grab :99 (records the virtual display to mp4)
+              ↓
+        ffmpeg palettegen + paletteuse (2-pass → sharp gif)
+```
+
+## Key parameters that matter
+
+1. **Strip cue/claude env vars before launching the inner shell** — `unset CUE_LAUNCHING CLAUDE_CONFIG_DIR CLAUDECODE CLAUDE_CODE_SESSION_ID CLAUDE_EFFORT AI_AGENT CODEX_HOME`. Otherwise the shim's recursion guard fires the moment you type `claude`.
+
+2. **PATH ordering inside the inner shell.** `~/.local/bin` (shim) must come first so `claude` resolves to the shim; the real binary (e.g. `~/.nvm/versions/node/<v>/bin`) must come next so `cue launch` can `exec` it. nvm-installed binaries are NOT inherited by ttyd's bash — set PATH explicitly.
+
+3. **tmux passthrough for Kitty graphics.** Inner tmux config needs:
+   ```
+   set -g allow-passthrough on
+   set -g default-terminal "xterm-kitty"
+   set -as terminal-features ",xterm-kitty:RGB"
+   ```
+   Plus `export TERM=xterm-kitty` and `export CUE_KITTY=1` inside the tmux pane so cue uses the kitty path through tmux.
+
+4. **Kitty must fill the Xvfb display.** Use `--start-as=fullscreen` (no WM needed). If that fails on a minimal Xvfb, `xdotool search --class <cls> windowsize <W> <H>` as a fallback. Without this, kitty opens at 80×24 in a corner and ffmpeg captures mostly blank pixels — the GIF comes out ~20 KB instead of ~1 MB.
+
+5. **Kitty option values are raw — never `px`.** `--override initial_window_width=1500`, not `1500px`. The parser rejects the suffix and kitty silently fails to start; xdotool then finds no window and ffmpeg records the empty Xvfb root.
+
+6. **Verify before recording.** After kitty launches, grab a single frame:
+   ```bash
+   DISPLAY=:99 xwd -root | convert xwd:- /tmp/preflight.png
+   ```
+   If `/tmp/preflight.png` is solid color → kitty isn't on Xvfb. If it shows your terminal → start ffmpeg.
+
+7. **Pickers ask twice.** After Enter selects a profile, cue's picker shows a second "Pin to this directory? Yes/No" prompt. Need a second Enter to confirm or your demo hangs.
+
+## Skeleton script
+
+See [`scripts/record-demo-kitty.sh`](../../../../../scripts/record-demo-kitty.sh) for the complete working version. Structure:
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+DISPLAY_NUM=:99
+WIDTH=1500; HEIGHT=900
+FFMPEG=/usr/bin/ffmpeg            # the apt build — has x11grab
+
+# 1. virtual display
+Xvfb $DISPLAY_NUM -screen 0 ${WIDTH}x${HEIGHT}x24 &
+XVFB_PID=$!
+trap "kill $XVFB_PID 2>/dev/null" EXIT
+sleep 1.5
+
+# 2. tmux config + detached session
+cat > /tmp/tmux.conf <<'EOF'
+set -g allow-passthrough on
+set -g default-terminal "xterm-kitty"
+set -g status off
+EOF
+DISPLAY=$DISPLAY_NUM tmux -L demo -f /tmp/tmux.conf \
+  new-session -d -s d -x $((WIDTH/10)) -y $((HEIGHT/22)) \
+  "cd /tmp/cue-demo && bash --noprofile --norc -i"
+
+SEND() { tmux -L demo send-keys -t d "$@"; }
+SEND 'unset CUE_LAUNCHING CLAUDE_CONFIG_DIR CLAUDECODE' Enter
+SEND 'export PATH="$HOME/.local/bin:$HOME/.nvm/versions/node/v22.22.0/bin:$PATH"' Enter
+SEND 'export TERM=xterm-kitty CUE_KITTY=1' Enter
+SEND 'clear' Enter
+sleep 0.5
+
+# 3. real kitty on the virtual display
+DISPLAY=$DISPLAY_NUM kitty \
+  --class cue-demo --start-as=fullscreen \
+  --override font_family="JetBrainsMono Nerd Font" \
+  --override font_size=14 \
+  --override initial_window_width=$WIDTH \
+  --override initial_window_height=$HEIGHT \
+  -- tmux -L demo attach -t d &
+sleep 2.5
+
+# 4. preflight
+DISPLAY=$DISPLAY_NUM xwd -root | convert xwd:- /tmp/preflight.png
+echo "preflight: $(identify -format '%[mean]' /tmp/preflight.png) mean intensity"
+
+# 5. record
+$FFMPEG -y -f x11grab -video_size ${WIDTH}x${HEIGHT} -framerate 15 \
+  -i $DISPLAY_NUM -t 40 -c:v libx264 -preset ultrafast -pix_fmt yuv420p \
+  /tmp/raw.mp4 &
+FFMPEG_PID=$!
+sleep 1
+
+# 6. drive the demo
+SEND 'cue optimizer readme-writer' Enter
+sleep 7
+SEND 'claude' Enter
+sleep 3
+for i in $(seq 1 14); do SEND Down; sleep 0.08; done
+sleep 0.7
+SEND Enter           # selects profile
+sleep 1.6
+SEND Enter           # answers "Pin to this directory? Yes" prompt
+sleep 7
+
+wait $FFMPEG_PID
+
+# 7. 2-pass mp4 → gif (sharp colors)
+$FFMPEG -y -i /tmp/raw.mp4 \
+  -vf "fps=12,scale=1200:-1:flags=lanczos,palettegen=stats_mode=diff" \
+  /tmp/palette.png
+$FFMPEG -y -i /tmp/raw.mp4 -i /tmp/palette.png \
+  -lavfi "fps=12,scale=1200:-1:flags=lanczos [x]; [x][1:v] paletteuse=dither=bayer:bayer_scale=4" \
+  docs/assets/demo.gif
+```
+
+## Sanity check the output
+
+Healthy capture:
+- raw mp4 ≥ 500 KB for ~30 s recording
+- output gif 400 KB – 2 MB
+- `ffmpeg -i raw.mp4` reports bitrate in the hundreds of kbps, not single digits
+
+Pathological capture (means kitty didn't render to Xvfb):
+- raw mp4 < 50 KB (4 kbps bitrate is the smoking gun)
+- gif comes out 10–20 KB
+- single extracted frame compresses to a few KB (solid color)
+
+## Workflow
+
+1. Verify tools: `which Xvfb xdotool kitty tmux && /usr/bin/ffmpeg -devices | grep x11`
+2. Copy the skeleton from [`scripts/record-demo-kitty.sh`](../../../../../scripts/record-demo-kitty.sh) — adapt the demo commands
+3. Test-run; check the preflight screenshot is non-empty
+4. Iterate on timing — pickers and Claude Code splash both need 2–3 s headroom
+5. Commit both the script and the resulting GIF — re-running gives byte-identical output for a fixed tape

package/resources/skills/skills/meta/kiro-powers/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: kiro-powers
+description: >-
+  When user says "import kiro power", "add power to profile", or "use X power" —
+  import a Kiro Power (POWER.md + MCP config) from GitHub into a cue profile as
+  a skill + MCP entry. Bridges the Kiro Powers ecosystem into cue.
+tags: [meta, cue, kiro, powers, interop]
+category: meta
+version: 1.0.0
+requires_mcps: []
+allowed-tools: Bash(curl:*), Bash(gh:*), Bash(git:*), Read(*), Write(*)
+---
+
+# Kiro Powers → cue Profile Importer
+
+Import Kiro Powers (from kiro.dev or GitHub) into cue profiles. A Kiro Power is:
+- `POWER.md` — steering file with activation keywords + workflow instructions
+- MCP server configuration
+- Optional hooks and slash commands
+
+cue can use these directly by converting them to skill + MCP entries.
+
+## When to activate
+
+- User says "import kiro power X" or "add the Stripe power"
+- User says "use kiro powers" or "convert power to skill"
+- User mentions a known Kiro power partner (Supabase, Stripe, Neon, Netlify, Figma, Postman, Datadog)
+
+## Power → cue Mapping
+
+| Kiro Power component | cue equivalent |
+|---------------------|----------------|
+| `POWER.md` | Skill `SKILL.md` (rename + adapt frontmatter) |
+| MCP server config | Entry in `resources/mcps/configs/` |
+| Activation keywords | Skill `description` field (triggers matching) |
+| Hooks | Skill body instructions |
+| Slash commands | Skill body sections |
+
+## Workflow
+
+### 1. Find the Power
+
+```bash
+# From GitHub URL
+git clone --depth 1 <power-repo-url> /tmp/power-import
+
+# Or from known partners
+# Supabase: github.com/supabase/kiro-power
+# Stripe: github.com/stripe/kiro-power
+# Neon: github.com/neondatabase/kiro-power
+```
+
+Check for `POWER.md` at the root or in a `power/` subdirectory.
+
+### 2. Parse the Power
+
+Read `POWER.md` and extract:
+
+```
+---
+name: supabase
+keywords: [database, postgres, supabase, rls, edge-functions]
+mcp:
+  command: npx
+  args: ["-y", "@supabase/mcp-server"]
+  env:
+    SUPABASE_ACCESS_TOKEN: "${SUPABASE_ACCESS_TOKEN}"
+---
+
+# Supabase Power
+
+## Onboarding
+...
+
+## Workflows
+...
+```
+
+### 3. Convert to cue skill
+
+Create `resources/skills/skills/kiro/<power-name>/SKILL.md`:
+
+```markdown
+---
+name: <power-name>
+description: "<keywords joined as natural language trigger>"
+tags: [kiro-power, <power-name>]
+category: kiro
+version: 1.0.0
+requires_mcps: [<power-name>]
+allowed-tools: mcp__<power-name>__*
+---
+
+<POWER.md body content here>
+```
+
+### 4. Add MCP config
+
+Add to `resources/mcps/configs/claude_runtime.sanitized.json`:
+
+```json
+{
+  "servers": {
+    "<power-name>": {
+      "command": "npx",
+      "args": ["-y", "@supabase/mcp-server"],
+      "env": {
+        "SUPABASE_ACCESS_TOKEN": "${SUPABASE_ACCESS_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+### 5. Add to profile
+
+```yaml
+# In profiles/<target>/profile.yaml
+skills:
+  local:
+    - kiro/<power-name>
+mcps:
+  - <power-name>
+```
+
+### 6. Verify
+
+```bash
+cue validate <profile>
+cue doctor --profile <profile>
+```
+
+## Known Kiro Power Partners
+
+| Power | MCP Package | Keywords |
+|-------|------------|----------|
+| Supabase | `@supabase/mcp-server` | database, postgres, supabase, rls |
+| Stripe | `@stripe/mcp` | payment, checkout, billing, stripe |
+| Neon | `@neondatabase/mcp-server` | postgres, neon, serverless-db |
+| Netlify | `@netlify/mcp-server` | deploy, netlify, hosting |
+| Figma | `@figma/mcp-server` | design, figma, ui, components |
+| Postman | `@postman/mcp-server` | api, testing, postman, collections |
+| Datadog | `@datadog/mcp-server` | monitoring, datadog, observability |
+
+## Rules
+
+- Always preserve the original POWER.md content — it contains the expertise
+- Map `keywords` to the skill `description` for cue's matching
+- Add `requires_mcps` so cue warns if the MCP isn't configured
+- Keep the MCP env vars as `${PLACEHOLDER}` — user fills them in
+- If the power has multiple steering files, create one skill per workflow OR bundle them as references/
+- Confirm with user before writing to the MCP registry

package/resources/skills/skills/research/find-skills/SKILL.md

@@ -1,143 +1,168 @@
 ---
 name: find-skills
 description: >-
-  Use when user says "find skills", "available skills", or "skill search". Catalog search, matching, install suggestions.
+  When user says "find skills for X", "search for skills", "what skills exist for Y",
+  or "add SVG/diagram/testing/etc skills to my profile" — search GitHub for open-source
+  Claude Code skills, evaluate them, and add the best ones to the active profile.
+tags: [meta, cue, research, skills]
+category: research
+version: 1.0.0
+requires_mcps: []
+allowed-tools: Bash(curl:*), Bash(gh:*), WebFetch, WebSearch, Read(*), Write(*)
 ---
 
-# Find Skills
+# Find & Install Open-Source Skills
 
-This skill helps you discover and install skills from the open agent skills ecosystem.
+Search GitHub for Claude Code / Codex skills that match a user's need, evaluate quality, and add them to the active cue profile.
 
-## When to Use This Skill
+## When to activate
 
-Use this skill when the user:
+- User says "find skills for X" or "search for X skills"
+- User says "what open-source skills exist for Y?"
+- User says "add diagram/testing/deployment/etc skills to my profile"
+- User describes a capability gap and you think a public skill could fill it
 
-- Asks "how do I do X" where X might be a common task with an existing skill
-- Says "find a skill for X" or "is there a skill for X"
-- Asks "can you do X" where X is a specialized capability
-- Expresses interest in extending agent capabilities
-- Wants to search for tools, templates, or workflows
-- Mentions they wish they had help with a specific domain (design, testing, deployment, etc.)
+## Workflow
 
-## What is the Skills CLI?
+### 1. Search GitHub for skills
 
-The Skills CLI (`npx skills`) is the package manager for the open agent skills ecosystem. Skills are modular packages that extend agent capabilities with specialized knowledge, workflows, and tools.
+Use multiple search strategies:
 
-**Key commands:**
-
-- `npx skills find [query]` - Search for skills interactively or by keyword
-- `npx skills add <package>` - Install a skill from GitHub or other sources
-- `npx skills check` - Check for skill updates
-- `npx skills update` - Update all installed skills
-
-**Browse skills at:** https://skills.sh/
-
-## How to Help Users Find Skills
-
-### Step 1: Understand What They Need
-
-When a user asks for help with something, identify:
-
-1. The domain (e.g., React, testing, design, deployment)
-2. The specific task (e.g., writing tests, creating animations, reviewing PRs)
-3. Whether this is a common enough task that a skill likely exists
-
-### Step 2: Check the Leaderboard First
-
-Before running a CLI search, check the [skills.sh leaderboard](https://skills.sh/) to see if a well-known skill already exists for the domain. The leaderboard ranks skills by total installs, surfacing the most popular and battle-tested options.
-
-For example, top skills for web development include:
-- `vercel-labs/agent-skills` — React, Next.js, web design (100K+ installs each)
-- `anthropics/skills` — Frontend design, document processing (100K+ installs)
-
-### Step 3: Search for Skills
+```bash
+# Strategy A: GitHub topic search (most reliable)
+curl -sL "https://api.github.com/search/repositories?q=topic:claude-code-skill+topic:$TOPIC&sort=stars&per_page=10" \
+  -H "Accept: application/vnd.github.v3+json" | jq '.items[] | {name: .full_name, stars: .stargazers_count, desc: .description, url: .html_url}'
 
-If the leaderboard doesn't cover the user's need, run the find command:
+# Strategy B: Search for SKILL.md files (catches skills not tagged)
+curl -sL "https://api.github.com/search/code?q=filename:SKILL.md+$KEYWORD&per_page=10" \
+  -H "Accept: application/vnd.github.v3+json" | jq '.items[] | {repo: .repository.full_name, path: .path}'
 
-```bash
-npx skills find [query]
+# Strategy C: Topic-based discovery
+curl -sL "https://api.github.com/search/repositories?q=$KEYWORD+claude+skill+in:name,description,readme&sort=stars&per_page=10" \
+  -H "Accept: application/vnd.github.v3+json" | jq '.items[] | {name: .full_name, stars: .stargazers_count, desc: .description}'
 ```
 
-For example:
-
-- User asks "how do I make my React app faster?" → `npx skills find react performance`
-- User asks "can you help me with PR reviews?" → `npx skills find pr review`
-- User asks "I need to create a changelog" → `npx skills find changelog`
+Also search for known high-quality skill collections:
+- `anthropics/skills` — official Anthropic skills
+- `daymade/claude-code-skills` — curated collection
+- `levnikolaevich/claude-code-skills` — delivery workflow skills
+- `yizhiyanhua-ai/fireworks-tech-graph` — SVG diagram generation
+- `cathrynlavery/diagram-design` — editorial diagrams
+- `oh-my-mermaid/oh-my-mermaid` — architecture diagrams from code
 
-### Step 4: Verify Quality Before Recommending
+### 2. Evaluate each candidate
 
-**Do not recommend a skill based solely on search results.** Always verify:
+For each promising repo, check:
 
-1. **Install count** — Prefer skills with 1K+ installs. Be cautious with anything under 100.
-2. **Source reputation** — Official sources (`vercel-labs`, `anthropics`, `microsoft`) are more trustworthy than unknown authors.
-3. **GitHub stars** — Check the source repository. A skill from a repo with <100 stars should be treated with skepticism.
+```bash
+# Check if it has a SKILL.md (required for cue compatibility)
+curl -sL "https://api.github.com/repos/$REPO/contents/" \
+  -H "Accept: application/vnd.github.v3+json" | jq '.[].name' | grep -i "skill"
 
-### Step 5: Present Options to the User
+# Check stars, last commit, license
+curl -sL "https://api.github.com/repos/$REPO" \
+  -H "Accept: application/vnd.github.v3+json" | jq '{stars: .stargazers_count, updated: .updated_at, license: .license.spdx_id, archived: .archived}'
+```
 
-When you find relevant skills, present them to the user with:
+**Quality criteria (score 1-5):**
+- ⭐ Stars: >1k = 5, >500 = 4, >100 = 3, >20 = 2, <20 = 1
+- 📅 Last updated: <1 month = 5, <3 months = 4, <6 months = 3, <1 year = 2, >1 year = 1
+- 📄 Has SKILL.md: required (skip if missing)
+- 📜 License: MIT/Apache/ISC = ✓, no license = ⚠️ warn user
+- 🏗️ Structure: has references/, templates/, or examples/ = bonus
 
-1. The skill name and what it does
-2. The install count and source
-3. The install command they can run
-4. A link to learn more at skills.sh
+### 3. Present findings to user
 
-Example response:
+Format results as a ranked table:
 
 ```
-I found a skill that might help! The "react-best-practices" skill provides
-React and Next.js performance optimization guidelines from Vercel Engineering.
-(185K installs)
-
-To install it:
-npx skills add vercel-labs/agent-skills@react-best-practices
-
-Learn more: https://skills.sh/vercel-labs/agent-skills/react-best-practices
+🔍 Found 4 skills for "SVG diagrams":
+
+  ⭐⭐⭐⭐⭐ yizhiyanhua-ai/fireworks-tech-graph (7k stars)
+  "Generate production-quality SVG+PNG technical diagrams from natural language"
+  7 styles, 14 diagram types, AI/Agent patterns
+  License: MIT | Updated: 2 weeks ago
+  Install: npx ref → yizhiyanhua-ai/fireworks-tech-graph
+
+  ⭐⭐⭐⭐ cathrynlavery/diagram-design (2.4k stars)
+  "Thirteen editorial diagram types for Claude Code. Self-contained HTML+SVG."
+  Brand-aware, no Mermaid, editorial quality
+  License: MIT | Updated: 1 month ago
+  Install: npx ref → cathrynlavery/diagram-design
+
+  ⭐⭐⭐ oh-my-mermaid/oh-my-mermaid (800 stars)
+  "Turn complex codebases into clear architecture diagrams"
+  Mermaid-based, auto-generates from code
+  License: MIT | Updated: 3 weeks ago
+  Install: npx ref → oh-my-mermaid/oh-my-mermaid
+
+  ⚠️ some-user/svg-tool (15 stars)
+  Skipped: too few stars, no SKILL.md found
 ```
 
-### Step 6: Offer to Install
+### 4. Add to profile (with user confirmation)
 
-If the user wants to proceed, you can install the skill for them:
+After user picks which skills to add:
 
 ```bash
-npx skills add <owner/repo@skill> -g -y
+# Check current profile
+PROFILE=$(cat .cue-profile 2>/dev/null || cue current --json 2>/dev/null | jq -r '.profile')
+
+# Show what will be added
+echo "Adding to profile: $PROFILE"
+echo "  npx:"
+echo "    - repo: yizhiyanhua-ai/fireworks-tech-graph"
+echo "      skills: [fireworks-tech-graph]"
 ```
 
-The `-g` flag installs globally (user-level) and `-y` skips confirmation prompts.
-
-## Common Skill Categories
-
-When searching, consider these common categories:
-
-| Category        | Example Queries                          |
-| --------------- | ---------------------------------------- |
-| Web Development | react, nextjs, typescript, css, tailwind |
-| Testing         | testing, jest, playwright, e2e           |
-| DevOps          | deploy, docker, kubernetes, ci-cd        |
-| Documentation   | docs, readme, changelog, api-docs        |
-| Code Quality    | review, lint, refactor, best-practices   |
-| Design          | ui, ux, design-system, accessibility     |
-| Productivity    | workflow, automation, git                |
+Then edit the profile YAML:
 
-## Tips for Effective Searches
+```bash
+# Read current profile
+cat profiles/$PROFILE/profile.yaml
 
-1. **Use specific keywords**: "react testing" is better than just "testing"
-2. **Try alternative terms**: If "deploy" doesn't work, try "deployment" or "ci-cd"
-3. **Check popular sources**: Many skills come from `vercel-labs/agent-skills` or `ComposioHQ/awesome-claude-skills`
+# Add the npx entry under skills.npx
+# (use the agent to edit the YAML properly)
+```
 
-## When No Skills Are Found
+Or use the cue CLI if available:
 
-If no relevant skills exist:
+```bash
+cue skills add-to-profile --npx "yizhiyanhua-ai/fireworks-tech-graph:fireworks-tech-graph" --profile $PROFILE
+```
 
-1. Acknowledge that no existing skill was found
-2. Offer to help with the task directly using your general capabilities
-3. Suggest the user could create their own skill with `npx skills init`
+### 5. Verify installation
 
-Example:
+```bash
+# Validate the updated profile
+cue validate $PROFILE
 
+# Show the updated skill count
+cue current
 ```
-I searched for skills related to "xyz" but didn't find any matches.
-I can still help you with this task directly! Would you like me to proceed?
 
-If this is something you do often, you could create your own skill:
-npx skills init my-xyz-skill
-```
+## Search Shortcuts
+
+Common searches the user might ask for:
+
+| User says | Search terms |
+|-----------|-------------|
+| "diagram skills" | `svg diagram architecture claude-code-skill` |
+| "testing skills" | `testing test-runner claude skill` |
+| "deployment skills" | `deploy docker kubernetes claude skill` |
+| "documentation skills" | `readme docs markdown claude skill` |
+| "security skills" | `security audit owasp claude skill` |
+| "API skills" | `api rest graphql openapi claude skill` |
+| "database skills" | `database postgres migration claude skill` |
+| "frontend skills" | `react nextjs frontend ui claude skill` |
+
+## Rules
+
+- Always show stars, last update, and license before recommending
+- Never add a skill without user confirmation
+- Prefer skills with >100 stars and recent activity
+- Warn if a skill has no license (legal risk)
+- Warn if a skill is archived or >1 year stale
+- Show max 5 results, ranked by quality score
+- If no good skills found, suggest creating one with `cue skills-new`
+- Always verify the skill has a SKILL.md — repos without one won't work with cue

package/src/commands/_index.ts

@@ -49,6 +49,10 @@ export const COMMANDS = {
     summary: "Resolve+materialize a profile then exec claude/codex (hot path)",
     load: () => import("./launch"),
   },
+  materialize: {
+    summary: "Write skills + MCPs for any agent (cursor, cline, gemini, copilot, etc.)",
+    load: () => import("./materialize"),
+  },
   quick: {
     summary: "One-shot bare launch — no profile, no skills, fastest cold start",
     load: () => import("./quick"),
@@ -161,6 +165,10 @@ export const COMMANDS = {
     summary: "Export a profile as portable YAML",
     load: () => import("./import-profile"),
   },
+  share: {
+    summary: "Publish & browse community profiles on the marketplace",
+    load: () => import("./share"),
+  },
   "colony-dispatch": {
     summary: "Resolve profile for a Colony task based on keywords",
     load: () => import("./colony-dispatch"),

package/src/commands/launch.ts

@@ -586,6 +586,17 @@ export async function run(args: string[]): Promise<number> {
         const duration_s = Math.round((Date.now() - new Date(startTs).getTime()) / 1000);
         recordEvent({ ts: new Date().toISOString(), event: "end", profile: profileName, agent: agentKind, cwd: process.cwd(), duration_s });
       } catch { /* best-effort */ }
+      // Sync refreshed credentials back to source so next launch has valid tokens
+      if (credentialsSource) {
+        try {
+          const { copyFileSync, existsSync: ex } = require("node:fs");
+          const runtimeCreds = join(runtime.runtimeDir, ".credentials.json");
+          const sourceCreds = join(credentialsSource, ".credentials.json");
+          if (ex(runtimeCreds)) {
+            copyFileSync(runtimeCreds, sourceCreds);
+          }
+        } catch { /* best-effort */ }
+      }
     });
   } catch { /* analytics non-fatal */ }