opencode-skills-collection 3.1.23 → 4.0.1

package/bundled-skills/lore/scripts/list_entries.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""List all lore entries in `.lore/` as JSON or human-readable text.
+
+Usage:
+    python list_entries.py                 # human-readable
+    python list_entries.py --json          # JSON output
+    python list_entries.py --scope=frontend
+    python list_entries.py --layer=ARCH
+
+Walks `.lore/_global/*` and `.lore/scopes/*/*` and parses every
+Markdown bullet that matches the entry format. Output is one record per
+entry with these fields:
+
+    id              full ID, e.g. "ARCH-2026-07-09-a3f2"
+    layer           prefix, e.g. "ARCH" / "DEC" / "CONV"
+    layer_file      source file stem, e.g. "ARCHITECTURE"
+    scope           scope name, or "_global"
+    file            path relative to .lore/, e.g. "scopes/frontend/ARCHITECTURE.md"
+    text            entry body, with tags stripped
+    tags            dict of tag name -> value, e.g. {"added": "2026-07-09", "verified": "2026-07-15"}
+    last_verified   value of #verified tag, or None
+
+Used by:
+    - query / audit / compress workflows (pre-step enumeration)
+    - find_duplicates.py
+    - find_stale.py
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+
+# Schema version this skill understands. Bumped only on breaking
+# config changes; see references/compatibility.md.
+KNOWN_SCHEMA_VERSION = 1
+
+
+def check_schema_version(lore_root: Path) -> None:
+    """Warn if .lore/.config.json is missing or has an unknown schema_version.
+
+    Output goes to stderr so it does not pollute --json consumers.
+    Idempotent and best-effort: any failure (missing file, malformed
+    JSON, permission error) is silent — config is optional and the
+    user can address it separately.
+    """
+    cfg_path = lore_root / ".config.json"
+    if not cfg_path.exists():
+        return
+    try:
+        cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return
+
+    version = cfg.get("schema_version")
+    if version is None:
+        print(
+            "[WARN] .lore/.config.json has no schema_version field. "
+            "Add \"schema_version\": 1 so future lore upgrades can detect "
+            "this config and prompt for migrations when they exist.",
+            file=sys.stderr,
+        )
+    elif isinstance(version, int) and version > KNOWN_SCHEMA_VERSION:
+        print(
+            f"[WARN] .lore/.config.json#schema_version={version} is newer "
+            f"than this lore skill expects (max: {KNOWN_SCHEMA_VERSION}). "
+            "Pull the latest lore from upstream.",
+            file=sys.stderr,
+        )
+
+
+def find_lore_root(start: Path) -> Path:
+    """Walk up from start to find the project root containing .lore/."""
+    p = start.resolve()
+    while p != p.parent:
+        if (p / ".lore").is_dir():
+            return p / ".lore"
+        p = p.parent
+    return None
+
+
+def parse_entry(line: str):
+    """Parse one Markdown bullet line. Returns dict or None if not an entry."""
+    m = re.match(
+        r"^\s*-\s*\[([A-Z]+)-(\d{4}-\d{2}-\d{2})-([a-f0-9]{4})\]\s+(.*?)\s*$",
+        line,
+    )
+    if not m:
+        return None
+
+    layer, date, h, rest = m.group(1), m.group(2), m.group(3), m.group(4)
+    eid = f"{layer}-{date}-{h}"
+
+    # Extract #tag:value pairs
+    tag_re = re.compile(r"#(added|verified|stale|archived):(\S+)")
+    tags = {name: val for name, val in tag_re.findall(rest)}
+    text = tag_re.sub("", rest).strip()
+
+    return {
+        "id": eid,
+        "layer": layer,
+        "layer_file": None,  # filled in by caller
+        "scope": None,       # filled in by caller
+        "file": None,        # filled in by caller
+        "text": text,
+        "tags": tags,
+        "last_verified": tags.get("verified"),
+    }
+
+
+def collect_entries(root: Path):
+    entries = []
+    layers_dirs = [("_global", root / "_global"), ("scopes", root / "scopes")]
+
+    for section_name, section_path in layers_dirs:
+        if not section_path.exists():
+            continue
+        for md_file in sorted(section_path.rglob("*.md")):
+            if section_name == "_global":
+                scope = "_global"
+            else:
+                scope = md_file.parent.name
+            layer_file = md_file.stem
+            try:
+                with open(md_file, encoding="utf-8") as f:
+                    for line in f:
+                        e = parse_entry(line)
+                        if e is None:
+                            continue
+                        e["scope"] = scope
+                        e["layer_file"] = layer_file
+                        e["file"] = str(md_file.relative_to(root))
+                        entries.append(e)
+            except OSError as exc:
+                print(f"warning: cannot read {md_file}: {exc}", file=sys.stderr)
+    return entries
+
+
+def main():
+    args = sys.argv[1:]
+
+    scope_filter = None
+    layer_filter = None
+    json_output = "--json" in args
+
+    for arg in args:
+        if arg.startswith("--scope="):
+            scope_filter = arg.split("=", 1)[1]
+        elif arg.startswith("--layer="):
+            layer_filter = arg.split("=", 1)[1]
+
+    root = find_lore_root(Path("."))
+    if root is None:
+        print("error: .lore/ not found (run from project root or below)",
+              file=sys.stderr)
+        sys.exit(1)
+
+    check_schema_version(root)
+    entries = collect_entries(root)
+
+    if scope_filter:
+        entries = [e for e in entries if e["scope"] == scope_filter]
+    if layer_filter:
+        entries = [e for e in entries if e["layer"] == layer_filter]
+
+    if json_output:
+        print(json.dumps(entries, indent=2, ensure_ascii=False))
+        return
+
+    if not entries:
+        print("(no entries)")
+        return
+
+    for e in entries:
+        verified = (
+            f" [verified:{e['last_verified']}]" if e["last_verified"] else ""
+        )
+        stale = " [STALE]" if "stale" in e["tags"] else ""
+        print(f"[{e['file']}] {e['id']} {e['text']}{verified}{stale}")
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/lovable-cleanup/SKILL.md

@@ -14,7 +14,7 @@ tools: [claude, cursor, codex, antigravity, gemini-cli]
 # lovable-cleanup
 
 > Remove every trace of Lovable scaffolding and ship the project as your own.
-> Made with [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills) · author: **whoisabhishekadhikari**
+> Made with [agentic-awesome-skills](https://github.com/sickn33/agentic-awesome-skills) · author: **whoisabhishekadhikari**
 
 ---
 
@@ -395,7 +395,7 @@ wrapper — React-level title tags override `index.html` at runtime.
 - [Lovable docs](https://docs.lovable.dev)
 - [shadcn/ui component list](https://ui.shadcn.com/docs/components)
 - [Radix UI primitives](https://www.radix-ui.com/primitives)
-- [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills)
+- [agentic-awesome-skills](https://github.com/sickn33/agentic-awesome-skills)
 
 ---
 
@@ -416,4 +416,4 @@ After completing the audit, produce a cleanup report:
 
 ---
 
-*Made with [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills) · author: [whoisabhishekadhikari](https://github.com/whoisabhishekadhikari)*
+*Made with [agentic-awesome-skills](https://github.com/sickn33/agentic-awesome-skills) · author: [whoisabhishekadhikari](https://github.com/whoisabhishekadhikari)*

package/bundled-skills/makepad-splash/SKILL.md

@@ -62,7 +62,7 @@ script!{
 
 ```rust
 // Evaluate Splash code at runtime
-cx.eval(code_string);
+cx.eval(code_string); // security-allowlist: Makepad runtime API; require trusted code_string
 
 // With context
 cx.eval_with_context(code, context);

package/bundled-skills/mmx-cli/SKILL.md

@@ -80,17 +80,30 @@ cat conversation.json | mmx text chat --messages-file - --output json
 
 ### image generate
 
-Generate images. Model: `image-01`.
+Generate images through MiniMax. Use this command for text-to-image tasks, thumbnails, concept art, social visuals, and quick prompt iteration. Model: `image-01`.
 
 ```bash
 mmx image generate --prompt <text> [flags]
 ```
 
 ```bash
+# Machine-readable response for agents
 mmx image generate --prompt "A cat in a spacesuit" --output json --quiet
+
+# Save multiple generated images to a directory
 mmx image generate --prompt "Logo" --n 3 --out-dir ./gen/ --quiet
+
+# Select region explicitly when a workflow must stay on one MiniMax endpoint family
+mmx image generate --prompt "Product hero image" --region global --output json --quiet
+mmx image generate --prompt "Product hero image" --region cn --output json --quiet
 ```
 
+Agent notes:
+
+- Prefer `--output json --quiet --non-interactive` when another tool will parse the result.
+- Use `--dry-run` before API-backed calls when validating arguments or CI examples.
+- Keep generated media in a task-local output directory and validate returned file paths or URLs before reusing them.
+
 ---
 
 ### video generate

package/bundled-skills/monopoly/SKILL.md

@@ -2,6 +2,8 @@
 name: monopoly
 description: >
   MONOPOLY is a Senior System Design Engineer skill for architecting, reviewing, and scaling systems. Triggers on requests involving architecture, databases, scaling, microservices, or infrastructure design. Proactively engages to design resilient backend systems.
+risk: unknown
+source: community
 ---
 
 # MONOPOLY — Senior System Design Engineer
@@ -10,6 +12,9 @@ You are **MONOPOLY**, a world-class Senior System Design Engineer with 20+ years
 
 ---
 
+## When to Use
+- Use this skill when the task matches this description: MONOPOLY is a Senior System Design Engineer skill for architecting, reviewing, and scaling systems. Triggers on requests involving architecture, databases, scaling, microservices, or infrastructure design. Proactively engages to design resilient backend systems.
+
 ## Core Operating Modes
 
 When a user interacts with you, identify which mode applies and execute it fully:

package/bundled-skills/monopoly/patterns/SKILL.md

@@ -1,12 +1,16 @@
 ---
 name: patterns
 description: Reference document for monopoly patterns.
+source: community
 risk: safe
 reports-to: monopoly
 ---
 
 # MONOPOLY — Design Patterns Deep Dive
 
+## When to Use
+- Use this skill when the task matches this description: Reference document for monopoly patterns.
+
 ## Table of Contents
 1. CQRS
 2. Event Sourcing

package/bundled-skills/monopoly/scale-benchmarks/SKILL.md

@@ -1,12 +1,16 @@
 ---
 name: scale-benchmarks
 description: Reference document for monopoly scale-benchmarks.
+source: community
 risk: safe
 reports-to: monopoly
 ---
 
 # MONOPOLY — Scale Benchmarks & Estimation Formulas
 
+## When to Use
+- Use this skill when the task matches this description: Reference document for monopoly scale-benchmarks.
+
 ## Quick Estimation Formulas
 
 ### User → RPS Conversion

package/bundled-skills/monopoly/security-checklist/SKILL.md

@@ -1,12 +1,16 @@
 ---
 name: security-checklist
 description: Reference document for monopoly security-checklist.
+source: community
 risk: safe
 reports-to: monopoly
 ---
 
 # MONOPOLY — Security Hardening Checklist
 
+## When to Use
+- Use this skill when the task matches this description: Reference document for monopoly security-checklist.
+
 ## Network Security
 - [ ] All services inside private VPC; only LB/API GW exposed publicly
 - [ ] Security groups follow least-privilege (deny all, allow specific ports/CIDRs)

package/bundled-skills/monopoly/tech-matrix/SKILL.md

@@ -1,12 +1,16 @@
 ---
 name: tech-matrix
 description: Reference document for monopoly tech-matrix.
+source: community
 risk: safe
 reports-to: monopoly
 ---
 
 # MONOPOLY — Technology Decision Matrix
 
+## When to Use
+- Use this skill when the task matches this description: Reference document for monopoly tech-matrix.
+
 ## Table of Contents
 1. Database Selection
 2. Cache Selection

package/bundled-skills/mtls-configuration/SKILL.md

@@ -309,7 +309,7 @@ metadata:
 # Istio - Check certificate expiry
 istioctl proxy-config secret deploy/my-app -o json | \
   jq '.dynamicActiveSecrets[0].secret.tlsCertificate.certificateChain.inlineBytes' | \
-  tr -d '"' | base64 -d | openssl x509 -text -noout
+  tr -d '"' | base64 -d | openssl x509 -text -noout # security-allowlist: local certificate inspection
 
 # Force certificate rotation
 kubectl rollout restart deployment/my-app

package/bundled-skills/network-101/SKILL.md

@@ -170,9 +170,8 @@ Set up SMB file shares for enumeration:
 # Install Samba
 sudo apt install samba
 
-# Create share directory
-sudo mkdir -p /srv/samba/share
-sudo chmod 777 /srv/samba/share
+# Create a group-scoped share directory instead of a world-writable one
+sudo install -d -m 0770 -o root -g sambashare /srv/samba/share
 
 # Configure Samba
 sudo nano /etc/samba/smb.conf
@@ -324,8 +323,8 @@ snmpwalk -c public -v1 localhost
 ```bash
 # Configure anonymous share
 sudo apt install samba
-sudo mkdir /srv/samba/anonymous
-sudo chmod 777 /srv/samba/anonymous
+# Keep the service-owned anonymous share non-world-writable.
+sudo install -d -m 0770 -o root -g sambashare /srv/samba/anonymous
 
 # Test access
 smbclient //localhost/anonymous -N

package/bundled-skills/nika/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: nika
+description: "Runs repeatable AI work as checked, budgeted workflow files."
+risk: critical
+source: https://github.com/supernovae-st/nika-agents/tree/main/skills/nika
+source_repo: supernovae-st/nika-agents
+source_type: community
+version: 1.1.0
+author: Thibaut Melen (@ThibautMelen) · SuperNovae Studio (github.com/supernovae-st)
+license: MIT
+license_source: https://github.com/supernovae-st/nika-agents/blob/main/LICENSE
+platforms: [linux, macos]
+prerequisites:
+  commands: [nika]
+metadata:
+  hermes:
+    tags: [Workflow, Automation, Deterministic, Cost-Control, Audit, Local-First, MCP]
+    category: autonomous-ai-agents
+    related_skills: [opencode, claude-code, codex]
+    homepage: https://nika.sh
+    requires_toolsets: [terminal]
+---
+
+# Nika Skill
+
+Use [Nika](https://nika.sh) as a deterministic workflow worker orchestrated by
+the Hermes `terminal` tool. Nika is an open-source (AGPL) Rust engine that captures
+a repeatable AI task as a plain-text `*.nika.yaml` file, audits it **before a
+single token is spent** (plan, cost floor, secret flows, types), executes it
+against local or cloud providers (Ollama/llama.cpp/vLLM included), and records
+a tamper-evident trace.
+
+Division of labor: **Hermes orchestrates · Nika captures repeatable work as a
+checkable file and runs it with receipts.** Nika is NOT another coding agent —
+for autonomous coding, use the `opencode` skill. Delegate to Nika when the
+work should be *repeatable, budgeted, and auditable*.
+
+## When to Use
+
+- The user asks to run, check, or author a `*.nika.yaml` workflow
+- A task will be repeated (daily digest, triage, ETL, report, multi-step LLM
+  pipeline) — capture it as a workflow instead of re-prompting
+- The user wants a hard cost cap, a cost estimate before running, or
+  receipts/audit of what ran
+- A pipeline mixes models/providers (local + cloud) or mixes LLM steps with
+  shell/HTTP/file steps
+- The user wants a run they can replay, verify, or reproduce later
+
+### When NOT to use
+
+- One-off questions or single tool calls — just answer or use a tool
+- Autonomous code implementation/refactoring/PR review — use the `opencode` skill
+- Interactive back-and-forth tasks — workflows are non-interactive by design
+
+## Prerequisites
+
+- Nika installed: `brew install supernovae-st/tap/nika` — other install
+  paths (script, manual download) are documented at https://nika.sh: installing
+  is a human step, not something this skill runs
+- Verify: `terminal(command="nika --version")`
+- Zero keys needed for local/offline work: `--model mock/echo` (offline) and
+  `--model ollama/...` (local) run without any API key
+- Cloud providers read standard env vars from the shell;
+  `terminal(command="nika doctor")` diagnoses and prints exact fix commands
+
+## How to Run
+
+Prove the toolchain offline first (no key, no network):
+
+```
+terminal(command="nika examples run 01-hello --model mock/echo")
+```
+
+Run a real workflow — local model first:
+
+```
+terminal(command="nika run flow.nika.yaml --model ollama/qwen3.5:4b", workdir="~/project")
+```
+
+Cloud model with a hard budget (always set one for paid models):
+
+```
+terminal(command="nika run flow.nika.yaml --model mistral/mistral-small-latest --max-cost-usd 0.25", workdir="~/project")
+```
+
+Pass workflow variables:
+
+```
+terminal(command="nika run report.nika.yaml --var city=Paris --var days=7 --max-cost-usd 0.50", workdir="~/project")
+```
+
+Long runs: launch in background and poll — do not block the turn:
+
+```
+terminal(command="nika run long.nika.yaml --max-cost-usd 1.00", workdir="~/project", background=true)
+process(action="poll", session_id="<id>")
+process(action="log", session_id="<id>")
+```
+
+### The check-before-run law
+
+Never run a workflow you have not checked. `nika check` is a static pre-flight
+(no tokens spent, no network): plan shape, cost floor, secret-flow analysis,
+type checks, tool args.
+
+```
+terminal(command="nika check flow.nika.yaml --json", workdir="~/project")
+```
+
+Findings carry `NIKA-XXXX` codes that explain themselves via
+`nika explain NIKA-XXXX`. Exit 0 = green, safe to run. Fix findings before
+running — never suppress them.
+
+### Authoring a workflow
+
+Turn a repeated task into a file. List templates, then instantiate:
+
+```
+terminal(command="nika new --from '?'")
+terminal(command="nika new flow.nika.yaml --from chain", workdir="~/project")
+```
+
+`--from` also accepts plain-words intent. Edit the skeleton (`vars:`,
+`tasks:`, `outputs:`), then **check it**. `nika explain flow.nika.yaml`
+narrates what it will do, the waves, the cost floor, and what it touches —
+before anything runs.
+
+The artifact you are producing looks like this (checks clean on 0.98):
+
+```yaml
+nika: v1
+workflow: daily-brief
+model: ollama/qwen3.5:4b
+tasks:
+  - id: fetch
+    invoke:
+      tool: "nika:fetch"
+      args: { url: "https://hn.algolia.com/api/v1/search?tags=front_page" }
+  - id: brief
+    depends_on: [fetch]
+    infer:
+      max_tokens: 300
+      prompt: |
+        Five bullet points, most signal first: ${{ tasks.fetch.output }}
+outputs:
+  brief: ${{ tasks.brief.output }}
+```
+
+One file, plain YAML: tasks, an explicit dependency, a bounded model step,
+a declared output. That file is what gets checked, run, diffed and reused.
+
+### Cost honesty
+
+- When the workflow prices above the budget, `--max-cost-usd` refuses to
+  start (exit 2, zero tokens) — and since 0.99 the pre-start floor prices
+  the EFFECTIVE model, `--model` override included
+- Mid-run, the ledger stops the workflow the moment real spend crosses the
+  budget: the crossing call completes, nothing new starts, the run fails
+  `NIKA-1704` (exit 1) with spent-vs-budget
+- Estimates use LIST RATES from the vendored public catalog; local · mock ·
+  unpriced work is never blocked
+- A model absent from the catalog meters as $0 — a paid *uncataloged* model
+  runs with no budget protection; prefer cataloged ids (`nika catalog`)
+- Report the cost line from the final run card (the summary block `nika
+  run` prints last — status, cost, trace path) back to the user verbatim
+
+### Receipts and verification
+
+Every run writes a trace under `.nika/traces/` — the run card prints the
+trace path on its `trace:` line. Both commands take that path (bare
+invocations are a usage error):
+
+```
+terminal(command="nika trace show .nika/traces/<run>.ndjson", workdir="~/project")
+terminal(command="nika trace verify .nika/traces/<run>.ndjson", workdir="~/project")
+```
+
+`trace verify` checks the tamper-evidence hash chain: exit 0 intact · 2
+broken · 3 pre-chain. Also useful: `nika trace outputs` · `nika trace flow` ·
+`nika trace reproduce` · `nika trace export` (OTLP lines).
+
+### Optional: MCP oracle tools
+
+Nika also ships a read-only MCP oracle (`nika mcp`) exposing validation and
+learning tools (`nika_check`, `nika_explain`, `nika_schema`, `nika_examples`,
+`nika_template`, `nika_canon`, `nika_catalog`, `nika_tools`). If the user
+wants those wired into their agent client, point them at the wiring guide —
+https://github.com/supernovae-st/nika-agents/tree/main/integrations/mcp —
+editing the client's own configuration is the user's step, never this
+skill's. Without the oracle, everything above still works over the terminal;
+running workflows stays there regardless, where the budget flags and traces
+live.
+
+## Quick Reference
+
+| Command | Use |
+|---------|-----|
+| `nika welcome` | What Nika is + what this machine has (offline, exit 0) |
+| `nika new <file> --from <template>` | Scaffold a workflow (`--from '?'` lists) |
+| `nika check <file> --json` | Static pre-flight — ALWAYS before run |
+| `nika explain <file>` | Narrate: waves, cost floor, touches |
+| `nika run <file> --model <p/m> --max-cost-usd <usd>` | Execute with budget |
+| `nika test <file>` | Golden test under the mock provider (offline) |
+| `nika trace show/verify/outputs/flow <trace>` | Receipts after a run (path from the run card's `trace:` line) |
+| `nika doctor` | Diagnose env/keys — prints exact fixes |
+| `nika catalog` | Provider/model ids + required env vars |
+
+## Procedure
+
+1. Verify readiness: `terminal(command="nika --version")`; install per
+   Prerequisites if missing.
+2. If the task is new, scaffold: `nika new <file> --from <template>`.
+3. Check: `nika check <file> --json`. Fix every finding
+   (`nika explain <code>`). Do not run an unchecked file.
+4. Preview offline when useful: `nika run <file> --model mock/echo`.
+5. Run with an explicit `--model` and, for any paid model, an explicit
+   `--max-cost-usd`.
+6. For long runs use `background=true` and poll with
+   `process(action="poll"|"log")`.
+7. After the run: `nika trace show <trace>` + `nika trace verify <trace>`
+   (path from the run card); report outputs, actual cost, and the verify
+   verdict to the user.
+
+### Rules
+
+1. NEVER run an unchecked workflow — `nika check` first, every time.
+2. ALWAYS pass `--max-cost-usd` when the model is a paid cloud model.
+3. Prefer local models (`ollama/...`) or `mock/echo` for drafts; escalate to
+   cloud models only when needed.
+4. Report the final run card honestly: status, actual cost, trace path,
+   `trace verify` verdict.
+5. One workflow file per delegated task; keep files in the user's repo so
+   they are diffable and reusable.
+6. If a run fails, read `nika explain <NIKA-code>` before retrying — do not
+   blind-retry.
+
+## Pitfalls
+
+- `nika run` renders live on a TTY; when piped (Hermes terminal), output can
+  stay quiet until completion — for anything long, prefer `background=true` +
+  poll, then read `nika trace show <trace>` for the final card.
+- `nika new` with no `--from` opens a guided TTY flow; in a pipe it fails
+  fast naming the flag — always pass `--from <template>` when delegating.
+- The budget guard stops NEW admissions: one wide parallel wave can overshoot
+  by that wave's spend. Tighten with `max_parallel:` when the budget is strict.
+- Uncataloged model ids meter as $0 — never rely on `--max-cost-usd` for a
+  custom endpoint model.
+- Workflow `outputs:` are not resolved on a budget stop — per-task values
+  live in the trace (`nika trace outputs`).
+
+## Limitations
+
+- Static checks reduce risk but cannot prove that remote content, shell steps,
+  provider behavior, or generated outputs are safe or correct.
+- Cost caps are not reliable for uncataloged paid models and a parallel wave
+  can overshoot before new work is stopped; require explicit user approval for
+  paid runs and report the actual ledger result.
+- Trace verification proves integrity of the recorded chain, not correctness
+  of the workflow or truth of its outputs.
+
+## Verification
+
+Smoke test (offline, zero keys):
+
+```
+terminal(command="nika examples run 01-hello --model mock/echo")
+```
+
+Success criteria: run completes exit 0 with a final run card · `nika check`
+exits 0 before any real run · `nika trace verify` exits 0 after the run.

package/bundled-skills/not-a-vibe-coder/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: not-a-vibe-coder
 description: Turns vague prompts into 8 structured planning files for brand new projects. DO NOT use on existing codebases.
+source: community
 risk: critical
 ---
 
@@ -11,6 +12,9 @@ documents that act as the project's persistent memory across a long context wind
 The documents are the source of truth for "what we agreed on"; the user's live
 instructions are always the final authority and can override the docs at any time.
 
+## When to Use
+- Use this skill when the task matches this description: Turns vague prompts into 8 structured planning files for brand new projects. DO NOT use on existing codebases.
+
 ## Core Principles (never violate these)
 
 1. **User command > files > AI assumptions.** If the user says something that