opencode-skills-collection 3.1.14 → 3.1.16

package/bundled-skills/folder-specific-claude-and-agents-md/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: folder-specific-claude-and-agents-md
+description: "Create folder-scoped CLAUDE.md and AGENTS.md guidance for future agents working in that area."
+category: development
+risk: critical
+source: community
+source_repo: davidondrej/skills
+source_type: community
+date_added: "2026-07-07"
+author: davidondrej
+tags: [agents-md, claude-md, documentation]
+tools: [claude, codex]
+license: "MIT"
+license_source: "https://github.com/davidondrej/skills/blob/main/LICENSE"
+user-invocable: true
+---
+
+# Folder CLAUDE.md Creation
+
+## When to Use
+
+- Use when the user asks for folder-specific agent instructions or local context files.
+- Use when a subdirectory needs a CLAUDE.md and AGENTS.md handoff for future agents.
+
+Generate a focused `CLAUDE.md` inside a target folder, plus an `AGENTS.md` symlink pointing at it. The file gives any future agent (Claude Code, Codex, etc.) the folder-specific context the global `CLAUDE.md` doesn't cover.
+
+Background reference: `library/claude-code/claude-and-agents-md.md`.
+
+## Process
+
+### Step 1: Confirm the target folder + sanity-check it deserves a file
+Ask the user which folder. Use absolute path under `~/Documents/code/workspace/`.
+
+**Only create a file if the folder has context needed across multiple sessions** — active evolving work, specific conventions, ongoing decisions. A folder of static reference files does NOT need one (agents can read on demand). If unsure, ask the user.
+
+### Step 2: Read every file in the folder IN FULL
+- Use `ls -la` first to enumerate files and subfolders.
+- Read every markdown, config, and key source file.
+- For large tldraw/Vite subprojects: read `package.json`, `src/App.tsx`, one representative module file, and the folder's own `module-details.md`-style files.
+- Do NOT skim. Do NOT skip. The user's later edits depend on you having full context.
+
+### Step 3: Draft a bullet list of candidate content
+Before writing the file, give the user a bullet list grouped by section — let them react first. Candidate sections (skip any that don't apply):
+
+- **Product / Purpose** — what this folder/project is, current state, key metrics
+- **Avatar / Audience** — who it's for (if applicable)
+- **Essential Files** — one-line role for each important file, including cross-folder references (use `@path/file.md` import syntax)
+- **Constraints (MUST NOT)** — explicit hard negatives. Highest-ROI content in the file.
+- **Conventions** — the user's lingo, status emojis (✅ 🟡), naming patterns, "usually do" patterns
+- **Locked Decisions** — things agreed + dated, must not re-litigate
+- **Context** — history, authority, credibility that frames the work
+- **How to work with the user** — collaboration style for this specific folder
+- **Marketing Angles / Positioning** — if public-facing
+- **Top Insights** — 3-5 most glaring signals from research (if research exists)
+
+### Step 4: Iterate with the user
+- Keep answers short. The user will edit directly in the IDE.
+- When they edit the file, RE-READ it and flag: contradictions, typos, missing rules, wrong categorization.
+- Do not revert their edits unless asked.
+
+### Step 5: Write the file
+- Path: `<folder>/CLAUDE.md`
+- Start with a one-line header explaining the file's purpose.
+- **Subdir file marker:** if this is a subdirectory file (parent folder already has its own CLAUDE.md), open with `Apply root CLAUDE.md first, then this file.`
+- Use `##` section headers matching the sections the user approved.
+- Bullets over prose. Short bullets.
+- **Cross-folder references:** use `@relative/path/file.md` import syntax, not prose mentions.
+- **Heavy reference docs:** annotate with `**Read when:**` triggers (e.g. "Read when: writing offer copy"). Prevents loading every session.
+
+### Step 6: Create the AGENTS.md symlink
+```
+cd <folder> && ln -s CLAUDE.md AGENTS.md
+```
+Verify with `ls -la CLAUDE.md AGENTS.md`.
+
+### Step 7: Commit only when asked
+Do NOT stage or push unless the user says to. When they do: `git add -A`, commit with a `Day N:` style message, push.
+
+## Rules
+
+- **Never invent content.** Every bullet must trace back to something you read in the folder or something the user said. No generic boilerplate.
+- **Brevity wins.** The user edits aggressively to make things shorter. Start tight.
+- **Folder-scoped only.** Don't duplicate the global `CLAUDE.md` (personality, dates, ports, etc.). Only include what's specific to this folder.
+- **No file trees, no directory dumps, no stack details the code already shows.** Anything an agent can derive from `ls` or `grep` rots fast and wastes tokens. Pin decisions, rules, and context — not structure.
+- **Constraints vs Conventions.** Hard "MUST NOT" rules go in Constraints (explicit negatives). "Usually do X" patterns go in Conventions. Splitting these improves adherence.
+- **No absolute ALWAYS/NEVER without explicit exceptions.** Edge cases make absolute rules get ignored. "Never commit secrets EXCEPT `.env.example`" beats "never commit secrets."
+- **Never summarize or auto-shorten the file.** Context collapse degrades it. Grow deliberately, prune manually. If the user asks to trim, do it by hand.
+- **Maintenance loop.** When the user corrects the agent on something this file should have prevented, add the rule to the file immediately. Don't wait.
+- **No emojis unless the user uses them** (status markers ✅ 🟡 are the exception — they're already conventions).
+- **Symlink, not copy.** `AGENTS.md` must be a symlink so edits stay in sync.
+- **Flag gaps honestly.** If the user's edits introduce contradictions (e.g. "sell X" in one section and "never sell X" in another), call it out before they ask.
+
+## Limitations
+
+- Adapted from `davidondrej/skills`; verify local paths, tools, credentials, and agent features before acting.
+- For commands, remote access, scheduling, browser automation, or file-changing workflows, get explicit user approval and confirm the target environment first.

package/bundled-skills/frontend-slides/scripts/extract-pptx.py

@@ -13,6 +13,20 @@ import json
 import os
 import sys
 from pptx import Presentation
+from pathlib import Path
+
+
+def safe_user_path(path_value, base_dir="."):
+    """Resolve a CLI path under the current workspace."""
+    if base_dir != ".":
+        raise ValueError("Custom base directories are not supported for CLI paths")
+    base_path = Path.cwd().resolve()
+    resolved_path = Path(path_value).expanduser().resolve()
+    try:
+        resolved_path.relative_to(base_path)
+    except ValueError as exc:
+        raise ValueError(f"Path escapes allowed directory: {path_value}") from exc
+    return resolved_path
 
 
 def extract_pptx(file_path, output_dir="."):
@@ -54,7 +68,7 @@ def extract_pptx(file_path, output_dir="."):
                 image_name = f"slide{slide_num + 1}_img{len(slide_data['images']) + 1}.{image_ext}"
                 image_path = os.path.join(assets_dir, image_name)
 
-                with open(image_path, "wb") as f:
+                with safe_user_path(image_path).open("wb") as f:
                     f.write(image_bytes)
 
                 slide_data["images"].append(
@@ -81,14 +95,14 @@ if __name__ == "__main__":
         sys.exit(1)
 
     input_file = sys.argv[1]
-    output_dir = sys.argv[2] if len(sys.argv) > 2 else "."
+    output_dir = safe_user_path(sys.argv[2]) if len(sys.argv) > 2 else "."
 
     slides = extract_pptx(input_file, output_dir)
 
     # Write extracted data as JSON
     output_path = os.path.join(output_dir, "extracted-slides.json")
-    with open(output_path, "w") as f:
-        json.dump(slides, f, indent=2)
+    with safe_user_path(output_path).open("w") as f:
+        f.write(json.dumps(slides, indent=2))
 
     print(f"Extracted {len(slides)} slides to {output_path}")
     for s in slides:

package/bundled-skills/gcp-cloud-run/SKILL.md

@@ -948,6 +948,7 @@ cloud-sql-python-connector[pg8000]
 ```
 
 ```python
+import os
 from google.cloud.sql.connector import Connector
 import sqlalchemy
 
@@ -958,7 +959,7 @@ def getconn():
         "project:region:instance",
         "pg8000",
         user="user",
-        password="password",
+        password=os.environ["DB_PASSWORD"],
         db="database"
     )
 

package/bundled-skills/gemini-api-integration/SKILL.md

@@ -37,7 +37,9 @@ pip install google-generativeai
 
 Set your API key securely:
 ```bash
-export GEMINI_API_KEY="your-api-key-here"
+read -rsp "Gemini API key: " GEMINI_API_KEY
+echo
+export GEMINI_API_KEY
 ```
 
 ### 2. Basic Text Generation

package/bundled-skills/gemini-live-api-dev/SKILL.md

@@ -85,9 +85,10 @@ To streamline real-time audio/video app development, use a third-party integrati
 #### Python
 
 ```python
+import os
 from google import genai
 
-client = genai.Client(api_key="YOUR_API_KEY")
+client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
 ```
 
 #### JavaScript

package/bundled-skills/gemini-omni-flash-api/scripts/video/generate_video.py

@@ -15,12 +15,27 @@ import sys
 import time
 import urllib.request
 import urllib.error
+import urllib.parse
 import uuid
 from google import genai
 
 # Load local upload helper logic inline to prevent dependency issues
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from upload_file import upload_file, wait_for_active
+from pathlib import Path
+
+
+def safe_user_path(path_value, base_dir="."):
+    """Resolve a CLI path under the current workspace."""
+    if base_dir != ".":
+        raise ValueError("Custom base directories are not supported for CLI paths")
+    base_path = Path.cwd().resolve()
+    resolved_path = Path(path_value).expanduser().resolve()
+    try:
+        resolved_path.relative_to(base_path)
+    except ValueError as exc:
+        raise ValueError(f"Path escapes allowed directory: {path_value}") from exc
+    return resolved_path
 
 def get_api_key(args):
     """Retrieves API key from command args or environment."""
@@ -28,22 +43,43 @@ def get_api_key(args):
         return args.api_key
     return os.environ.get("GEMINI_API_KEY")
 
+FILE_ID_RE = re.compile(r'^[A-Za-z0-9_-]+$')
+
+
+def extract_file_id(uri):
+    """Returns a Gemini File API id from a local reference or trusted API URL."""
+    if not uri:
+        return None
+    if uri.startswith("files/"):
+        file_id = uri.removeprefix("files/")
+        return file_id if FILE_ID_RE.fullmatch(file_id) else None
+
+    parsed = urllib.parse.urlparse(uri)
+    if parsed.scheme != "https" or parsed.netloc != "generativelanguage.googleapis.com":
+        return None
+    path_match = re.fullmatch(r'/files/([A-Za-z0-9_-]+)', parsed.path)
+    return path_match.group(1) if path_match else None
+
+
 def is_file_uri(uri):
     """Returns True if the string is a standard Gemini File URI."""
-    if not uri:
-        return False
-    return "files/" in uri and ("generativelanguage.googleapis.com" in uri or uri.startswith("files/"))
+    return extract_file_id(uri) is not None
 
 def normalize_file_uri(uri):
     """Normalizes any File API URI/reference to the standard https://generativelanguage.googleapis.com/files/{id} format."""
-    if not uri:
-        return None
-    match = re.search(r'files/([a-zA-Z0-9]+)', uri)
-    if match:
-        file_id = match.group(1)
+    file_id = extract_file_id(uri)
+    if file_id:
         return f"https://generativelanguage.googleapis.com/files/{file_id}"
     return uri
 
+
+def media_download_url(file_uri):
+    """Build a media URL only for validated Gemini File API references."""
+    file_id = extract_file_id(file_uri)
+    if not file_id:
+        raise ValueError("Generated video URI must be a Gemini File API reference.")
+    return f"https://generativelanguage.googleapis.com/files/{file_id}?alt=media"
+
 def slugify(text):
     """Converts a text prompt into a safe, descriptive filename slug."""
     text = text.lower()
@@ -144,7 +180,7 @@ def resolve_or_upload_asset(asset_path, mime_type, api_key, strip_audio=False):
         # Clean up temporary stripped file if we created one
         if temp_stripped_path and os.path.exists(temp_stripped_path):
             try:
-                os.remove(temp_stripped_path)
+                safe_user_path(temp_stripped_path).unlink()
                 print(f"Cleaned up temporary video file: {temp_stripped_path}")
             except Exception as e:
                 print(f"Warning: Failed to remove temporary file {temp_stripped_path}: {e}", file=sys.stderr)
@@ -157,8 +193,7 @@ def resolve_or_upload_asset(asset_path, mime_type, api_key, strip_audio=False):
 
 def download_video_file(file_uri, output_path, api_key):
     """Downloads generated video file from URI using alt=media standard in a memory-safe, chunked manner."""
-    separator = "&" if "?" in file_uri else "?"
-    download_url = f"{file_uri}{separator}alt=media"
+    download_url = media_download_url(file_uri)
 
     print(f"Downloading video from {file_uri} to {output_path} in chunked mode...")
     req = urllib.request.Request(download_url)
@@ -170,7 +205,7 @@ def download_video_file(file_uri, output_path, api_key):
             if parent_dir:
                 os.makedirs(parent_dir, exist_ok=True)
 
-            with open(output_path, "wb") as f:
+            with safe_user_path(output_path).open("wb") as f:
                 while True:
                     chunk = resp.read(8192)
                     if not chunk:
@@ -343,7 +378,7 @@ def main():
             print(f"Error: Batch JSON file '{args.batch}' not found.", file=sys.stderr)
             sys.exit(1)
         try:
-            with open(args.batch, "r", encoding="utf-8") as f:
+            with safe_user_path(args.batch).open("r", encoding="utf-8") as f:
                 jobs = json.load(f)
             if not isinstance(jobs, list):
                 print("Error: Batch JSON file must contain a list/array of job objects.", file=sys.stderr)
@@ -361,7 +396,7 @@ def main():
             sys.exit(1)
 
         jobs = []
-        with open(args.prompts_file, "r", encoding="utf-8") as f:
+        with safe_user_path(args.prompts_file).open("r", encoding="utf-8") as f:
             for line in f:
                 line = line.strip()
                 if line and not line.startswith("#"):

package/bundled-skills/goal-loop/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: goal-loop
+description: "Draft and explain persistent goal-loop prompts for long-running agent work with clear stop conditions."
+category: agent-orchestration
+risk: safe
+source: community
+source_repo: davidondrej/skills
+source_type: community
+date_added: "2026-07-07"
+author: davidondrej
+tags: [goals, autonomy, planning]
+tools: [claude, codex]
+license: "MIT"
+license_source: "https://github.com/davidondrej/skills/blob/main/LICENSE"
+---
+
+# Agent `/goal` Loop
+
+## What `/goal` is
+
+`/goal` is a slash command that turns an agent prompt into a **persistent agent** looping `plan → act → test → review → iterate` until a stop condition is met, the user pauses, or the token budget runs out. Internally called the "Ralph loop."
+
+Agents with the `/goal` feature right now: **Codex, Claude Code, and Hermes Agent**.
+
+Key difference from a normal prompt: when a turn ends but the goal isn't met, the agent **auto-continues** instead of waiting for input.
+
+**Lifecycle states:** `pursuing`, `paused`, `achieved`, `unmet`, `budget-limited`.
+
+When monitoring a running `/goal`, every check should include a one-line update to the user: what the agent is doing and whether it is on track. Keep it extremely concise.
+
+**Not:** a budget command, a safety boundary, "run forever", or a replacement for `/plan`. It's a contract enforcer with a verification loop.
+
+## Requirements
+
+- An agent with the `/goal` feature — right now: Codex, Claude Code, or Hermes Agent
+- The goals feature enabled in the agent's config
+- **Subscription auth** — API-key auth does **not** work. A pro-tier plan is the realistic minimum for long runs.
+
+## When to Use it
+
+Use only when **all three** are true:
+1. Task is >30 min of mechanical work.
+2. There's a **verifiable stop condition** (tests pass, coverage hit, eval ≥ X, build green).
+3. Repo is agent-ready (working build, decent tests, `AGENTS.md` present).
+
+Fits: migrations, coverage lifts, TDD feature builds, refactors with contract tests, prompt/eval optimization, deploy retry loops, bug-repro-then-fix.
+
+Bad fits: exploratory work, vague "improve this", anything without a "done" definition, prod credentials, destructive shared-infra ops.
+
+## The 5-part contract (every goal needs this)
+
+1. **Objective** — one sentence, one concrete outcome.
+2. **Constraints** — what must NOT change (public API, files, libs, conventions).
+3. **Validation command** — the exact shell command that proves progress (`pytest -q`, `pnpm test`, etc.).
+4. **Stop condition** — verifiable: "Stop when X passes" OR "when further changes need human/product input."
+5. **Documentation** — one sentence instructing the agent to write concise, targeted docs for every change, either creating new `.md` files or updating existing ones.
+
+Plus: tell the agent what to read first, ask it to work in checkpoints with a short progress log.
+
+## Writing a goal (the core deliverable)
+
+When the user wants a quick `/goal` instruction, produce a structured markdown block with one line per contract item (proper newlines, not flowing prose). **Do not prefix the output with `/goal`** — the user adds the slash command themselves in the composer. Emit only the contract body. Template:
+
+```
+**Objective:** <one-sentence objective>
+**Read first:** <files/PLAN.md/issue>
+**Constraints:** <what not to change, libs, conventions>
+**Validate:** `<exact command>` after each change
+**Document:** Write concise, targeted documentation for all changes — create new `.md` files or update existing docs as needed.
+**Checkpoints:** work in checkpoints and log progress briefly
+**Stop when:** <verifiable condition>, OR when further changes require human/product input
+```
+
+### Example (migration)
+
+```
+**Objective:** Migrate this project from Pydantic v1 to v2.
+**Read first:** pyproject.toml, src/, tests/
+**Constraints:** no public API changes; keep imports backwards-compatible via shims if needed; no new dependencies
+**Validate:** `pytest -q` after each change
+**Checkpoints:** work in checkpoints; log progress briefly
+**Stop when:** full suite passes with zero deprecation warnings, OR when a change requires architecture decisions
+```
+
+### Example (coverage lift)
+
+```
+**Objective:** Raise coverage in src/auth/ from ~38% to ≥75%.
+**Read first:** src/auth/, tests/auth/, AGENTS.md
+**Constraints:** no new deps; mirror existing test style; do not modify production code unless strictly required for testability
+**Validate:** `pytest --cov=src/auth --cov-report=term-missing`
+**Checkpoints:** work in checkpoints; log coverage delta each one
+**Stop when:** coverage ≥75% AND all tests pass, OR when uncovered code needs design changes
+```
+
+### Writing rules
+- **One objective, one stop condition.** Not a backlog.
+- **Documentation is mandatory.** Every `/goal` prompt must include a single sentence committing the agent to concise, targeted docs — new `.md` files or focused updates to existing docs.
+- **Never instruct the agent to create new ADRs** — ADRs require the user's explicit approval, so goal prompts must not pre-approve or encourage them.
+- **Forbid reward-hacking explicitly:** "Do not delete, skip, weaken, or narrow tests to make the goal pass." Otherwise the agent may game the stop condition.
+- **4,000-char limit** on the objective. If longer, put detail in a file (`PLAN.md`/`GOAL_BRIEF.md`) and make the goal point to it — keep the goal itself compact.
+- Use **literal strings** for paths, commands, issue numbers — exact.
+- Forbid scope creep explicitly: "Do not refactor unrelated code. Do not add dependencies."
+- Tell the agent when to pause: "If <condition>, pause and ask before proceeding."
+- Short, vague goals burn tokens for no extra value vs. a normal prompt.
+
+### Meta-prompting trick (highest-leverage)
+
+Hand-written goals under-specify. Ask a second AI session (Claude with the codebase loaded, ChatGPT with project connected, or a separate agent thread in the same dir) to: (1) inspect the codebase, (2) surface hidden assumptions/constraints/edge cases, (3) emit a structured `/goal` markdown block using the 4-part contract. Paste that into the agent. Order-of-magnitude better runs.
+
+Claude Code cmux note: after Claude finishes, it may prefill a predicted next user message; that draft is Claude, not the user speaking.
+
+### Self-goal setting
+
+The agent can now write and set its own goal natively (the `create_goal` tool). Instead of crafting the contract yourself, give it your high-level intent and tell it to set the goal: "Inspect this repo, then write yourself a `/goal` with a verifiable stop condition and pursue it." It's the meta-prompting trick done inline — the agent turns your intent into the contract. Still give it the same raw materials (files to read, constraints, the validation command) so the goal it writes is grounded. Add: "ask clarifying questions before committing if the intent is underspecified" — catches ambiguity up front and prevents the self-set goal from drifting.
+
+## Launching
+
+1. `cd <repo>` (goals run scoped to the working directory).
+2. Launch the agent bare (opens the TUI). **Not** exec/headless mode — `/goal` is a TUI slash command only.
+3. Sign in with subscription auth (not an API key).
+4. Type `/goal <your contract>` in the composer, Enter.
+5. Walk away.
+
+## Controlling a running goal
+
+| Command | Effect |
+|---|---|
+| `/goal` (alone) | Status: current checkpoint, what's verified, what remains, blockers |
+| `/goal pause` | Freeze |
+| `/goal resume` | Unfreeze (paused goals never auto-resume) |
+| `/goal clear` | Kill the goal |
+| `/goal <new>` | Replace the current goal |
+| Ctrl+C / any typed message | Auto-pauses; user input always wins priority |
+
+Resuming across sessions: goal state is persisted server-side. `cd` back into the repo, launch the agent, `/goal` for status, `/goal resume`.
+
+Budget-limited state: the agent doesn't stop abruptly — it summarizes, notes what's left, saves state. `/goal resume` works after budget refresh or upgrade.
+
+## When a goal drifts
+
+- **Minor drift:** just type a correction in the composer (auto-pauses, folds it in, resumes).
+- **Loose objective:** `/goal pause`, read status, then `/goal <tighter version>` — replaces the contract. Don't pile instructions on a vague goal.
+- **Bad mess:** `/goal clear`, `git status` or `git stash`, rewrite with the meta-prompting trick, restart.
+
+Don't let a drifting goal keep running "to see where it goes." Tokens burn, diffs compound.
+
+## Operational tips
+
+- Inspect status periodically with bare `/goal`.
+- **Always review the diff** before merging — long autonomy means more code to validate, not less. Human oversight becomes more critical, not optional.
+- Keep approvals/sandboxing tight; default permissions are correct.
+- First run: pick a 30-min scoped task so you learn how `/goal` actually stops before trusting it overnight.
+- Bake recurring policy into `AGENTS.md` so every goal inherits it without restating: adversarial self-review before declaring done, an extra QA pass even when tests pass, and the standard validation command. Saves repeating it in each goal paragraph.
+
+## Troubleshooting
+
+| Symptom | Fix |
+|---|---|
+| `/goal` missing from slash popup | Update the agent to a version that supports `/goal` |
+| Feature flag on but command missing | Quit and restart the agent fully |
+| Typed `/goals` | It's singular: `/goal` |
+| Doesn't activate | Sign out, sign back in with subscription auth (not API key) |
+| Stopped with progress summary | Budget-limited — `/goal resume` after refresh, or tighten scope |
+| `/goal resume` says no active goal | Terminal state or cleared — start fresh with `/goal <new>` |
+| Goal looks active but won't auto-continue | Stuck in Plan mode — plan-only work doesn't trigger continuation. Draft the plan, then switch to Goal execution |
+
+## Mental model
+
+`/goal` is a **contract enforcer with a verification loop**, not a "run forever" button. The shift: stop writing prompts, start writing **specifications with stop conditions**. Spend the time upfront defining "done"; the run takes care of itself.
+
+## Limitations
+
+- Adapted from `davidondrej/skills`; verify local paths, tools, credentials, and agent features before acting.
+- For commands, remote access, scheduling, browser automation, or file-changing workflows, get explicit user approval and confirm the target environment first.

package/bundled-skills/hugging-face-evaluation/SKILL.md

@@ -192,7 +192,7 @@ Fetch benchmark scores from Artificial Analysis API and add them to a model card
 
 **Basic Usage:**
 ```bash
-AA_API_KEY="your-api-key" uv run scripts/evaluation_manager.py import-aa \
+env "AA_API_KEY=${AA_API_KEY:?set AA_API_KEY first}" uv run scripts/evaluation_manager.py import-aa \
   --creator-slug "anthropic" \
   --model-name "claude-sonnet-4" \
   --repo-id "username/model-name"

package/bundled-skills/hugging-face-jobs/SKILL.md

@@ -830,7 +830,7 @@ webhook = create_webhook(
         {"type": "org", "name": "your-org-name"}
     ],
     domains=["repo", "discussion"],
-    secret="your-secret"
+    secret=os.environ["HF_WEBHOOK_SECRET"]
 )
 ```
 

package/bundled-skills/hugging-face-jobs/scripts/finepdfs-stats.py

@@ -42,6 +42,19 @@ import sys
 import time
 from pathlib import Path
 
+
+def safe_user_path(path_value, base_dir="."):
+    """Resolve a CLI path under the current workspace."""
+    if base_dir != ".":
+        raise ValueError("Custom base directories are not supported for CLI paths")
+    base_path = Path.cwd().resolve()
+    resolved_path = Path(path_value).expanduser().resolve()
+    try:
+        resolved_path.relative_to(base_path)
+    except ValueError as exc:
+        raise ValueError(f"Path escapes allowed directory: {path_value}") from exc
+    return resolved_path
+
 import polars as pl
 from ascii_graph import Pyasciigraph
 from datasets import Dataset
@@ -401,7 +414,7 @@ def main():
         print("The 'text' column is never loaded, making this very fast.\n")
 
     # Create output directory
-    output_dir = Path(args.output_dir)
+    output_dir = safe_user_path(args.output_dir)
     output_dir.mkdir(parents=True, exist_ok=True)
 
     # Single scan: compute temporal stats

package/bundled-skills/hugging-face-model-trainer/scripts/convert_to_gguf.py

@@ -84,6 +84,7 @@ def run_command(cmd, description):
             cmd,
             check=True,
             capture_output=True,
+            shell=False,
             text=True
         )
         if result.stdout:
@@ -114,6 +115,14 @@ def require_hf_repo_id(value, name):
         sys.exit(1)
 
 
+def safe_filename_component(value, name):
+    """Allow repo-name text only where it becomes a local filename component."""
+    if not re.fullmatch(r"[A-Za-z0-9._-]{1,96}", value):
+        print(f"   Invalid {name}: {value!r}. Use letters, numbers, dots, dashes, or underscores.", file=sys.stderr)
+        sys.exit(1)
+    return value
+
+
 def env_flag(name):
     return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"}
 
@@ -230,7 +239,7 @@ gguf_output_dir = "/tmp/gguf_output"
 os.makedirs(gguf_output_dir, exist_ok=True)
 
 convert_script = "/tmp/llama.cpp/convert_hf_to_gguf.py"
-model_name = ADAPTER_MODEL.split('/')[-1]
+model_name = safe_filename_component(ADAPTER_MODEL.split('/')[-1], "ADAPTER_MODEL repo name")
 gguf_file = f"{gguf_output_dir}/{model_name}-f16.gguf"
 
 print(f"   Running conversion...")

package/bundled-skills/hugo-to-markdown/scripts/inventory_hugo_rules.py

@@ -6,6 +6,19 @@ import re
 from collections import Counter, defaultdict
 from pathlib import Path
 
+
+def safe_user_path(path_value, base_dir="."):
+    """Resolve a CLI path under the current workspace."""
+    if base_dir != ".":
+        raise ValueError("Custom base directories are not supported for CLI paths")
+    base_path = Path.cwd().resolve()
+    resolved_path = Path(path_value).expanduser().resolve()
+    try:
+        resolved_path.relative_to(base_path)
+    except ValueError as exc:
+        raise ValueError(f"Path escapes allowed directory: {path_value}") from exc
+    return resolved_path
+
 try:
     import tomllib
 except ModuleNotFoundError:  # pragma: no cover
@@ -177,7 +190,7 @@ def main():
 
     payload = json.dumps(result, indent=2, sort_keys=True)
     if args.output:
-        output = Path(args.output)
+        output = safe_user_path(args.output)
         output.parent.mkdir(parents=True, exist_ok=True)
         output.write_text(payload + "\n", encoding="utf-8")
     else:

package/bundled-skills/image-generator/SKILL.md

@@ -39,7 +39,9 @@ Before using this skill, the user must set the `GEMINI_API_KEY` environment vari
 1. Get a free API key from [Google AI Studio](https://aistudio.google.com/)
 2. Export the key in your shell profile (`~/.zshrc`, `~/.bashrc`, etc.):
    ```bash
-   export GEMINI_API_KEY="your_api_key_here"
+   read -rsp "Gemini API key: " GEMINI_API_KEY
+   echo
+   export GEMINI_API_KEY
    ```
 3. Restart your terminal or run `source ~/.zshrc` (or `~/.bashrc`)