opencode-skills-collection 3.0.51 → 3.1.1

package/bundled-skills/youtube-notetaker/scripts/serve.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Standalone viewer + API server for a YouTube deep-dive library.
+
+Zero framework dependencies (Python stdlib + PyYAML). It serves the interactive
+artifact and a small read/write API over a plain folder of markdown files, so the
+whole thing runs anywhere with no custom backend.
+
+  python3 serve.py [--dir LIBRARY] [--port 8000] [--artifact path/to/artifact.html]
+
+LIBRARY defaults to $VIDEO_LIBRARY_DIR or ~/video-deepdives. Layout:
+  LIBRARY/<YTID>.md                     one markdown file per video (frontmatter + transcript)
+  LIBRARY/_media/<YTID>-slide-NN.jpg    slide images
+
+Routes (the artifact talks to these; the /api/video-deepdives namespace is
+arbitrary and kept only so the same artifact HTML works unmodified):
+  GET   /                                       the artifact (single-page app)
+  GET   /api/video-deepdives              list every video (flattened frontmatter)
+  GET   /api/video-deepdives/<id>         one video: {meta, body}
+  GET   /api/video-deepdives/_media/<f>   a slide image
+  PATCH /api/video-deepdives/<id>         merge {fields:{...}} into frontmatter, rewrite
+"""
+import argparse, json, os, sys, re, mimetypes, posixpath
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+try:
+    import yaml
+except ImportError:
+    sys.exit("pip install pyyaml")
+
+API = "/api/video-deepdives"
+FM_RE = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.DOTALL)
+
+
+def split_frontmatter(text):
+    """Return (meta_dict, body_str) from a markdown file with YAML frontmatter."""
+    m = FM_RE.match(text)
+    if not m:
+        return {}, text
+    meta = yaml.safe_load(m.group(1)) or {}
+    return meta, m.group(2)
+
+
+def dump_file(meta, body):
+    out = "---\n" + yaml.safe_dump(meta, sort_keys=False, allow_unicode=True, width=100) + "---\n"
+    return out + body
+
+
+def load_item(lib, slug):
+    path = os.path.join(lib, slug + ".md")
+    if not os.path.isfile(path):
+        return None
+    meta, body = split_frontmatter(open(path, encoding="utf-8").read())
+    return path, meta, body
+
+
+def list_items(lib):
+    items = []
+    for fn in sorted(os.listdir(lib)):
+        if not fn.endswith(".md") or fn.startswith("_"):
+            continue
+        slug = fn[:-3]
+        loaded = load_item(lib, slug)
+        if not loaded:
+            continue
+        _, meta, body = loaded
+        it = dict(meta)
+        it["slug"] = slug
+        it["file"] = fn
+        it["preview"] = body.strip()[:160]
+        items.append(it)
+    return items
+
+
+class Handler(BaseHTTPRequestHandler):
+    lib = None
+    artifact = None
+
+    def log_message(self, *a):
+        pass  # quiet
+
+    def _send(self, code, body, ctype="application/json"):
+        if isinstance(body, (dict, list)):
+            body = json.dumps(body).encode()
+        elif isinstance(body, str):
+            body = body.encode()
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, PATCH, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.end_headers()
+        if self.command != "HEAD":
+            self.wfile.write(body)
+
+    def do_OPTIONS(self):
+        self._send(204, b"")
+
+    def do_GET(self):
+        path = self.path.split("?", 1)[0].rstrip("/") or "/"
+        if path in ("/", "/index.html"):
+            try:
+                return self._send(200, open(self.artifact, encoding="utf-8").read(), "text/html; charset=utf-8")
+            except OSError:
+                return self._send(500, {"error": "artifact not found: " + self.artifact})
+
+        if path == API:
+            items = list_items(self.lib)
+            return self._send(200, {"collection": "video-deepdives", "total": len(items), "items": items})
+
+        if path.startswith(API + "/_media/"):
+            fn = posixpath.basename(path)  # strip any traversal
+            fp = os.path.join(self.lib, "_media", fn)
+            if not os.path.isfile(fp):
+                return self._send(404, {"error": "no such media"})
+            ctype = mimetypes.guess_type(fp)[0] or "application/octet-stream"
+            with open(fp, "rb") as f:
+                return self._send(200, f.read(), ctype)
+
+        if path.startswith(API + "/"):
+            slug = posixpath.basename(path)
+            loaded = load_item(self.lib, slug)
+            if not loaded:
+                return self._send(404, {"error": "no such item"})
+            _, meta, body = loaded
+            return self._send(200, {"slug": slug, "type": "video-deepdive", "meta": meta, "body": body.rstrip("\n")})
+
+        return self._send(404, {"error": "not found"})
+
+    def do_PATCH(self):
+        path = self.path.split("?", 1)[0].rstrip("/")
+        if not path.startswith(API + "/"):
+            return self._send(404, {"error": "not found"})
+        slug = posixpath.basename(path)
+        loaded = load_item(self.lib, slug)
+        if not loaded:
+            return self._send(404, {"error": "no such item"})
+        fp, meta, body = loaded
+        try:
+            n = int(self.headers.get("Content-Length", 0))
+            payload = json.loads(self.rfile.read(n) or b"{}")
+        except (ValueError, json.JSONDecodeError):
+            return self._send(400, {"error": "bad json"})
+        fields = payload.get("fields", payload)  # accept {fields:{...}} or a bare dict
+        if not isinstance(fields, dict):
+            return self._send(400, {"error": "fields must be an object"})
+        meta.update(fields)
+        open(fp, "w", encoding="utf-8").write(dump_file(meta, body))
+        return self._send(200, {"ok": True, "slug": slug, "updated": list(fields.keys())})
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dir", default=os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives")))
+    ap.add_argument("--port", type=int, default=int(os.environ.get("VIDEO_LIBRARY_PORT", "8000")))
+    ap.add_argument("--host", default="127.0.0.1")
+    here = os.path.dirname(os.path.abspath(__file__))
+    ap.add_argument("--artifact", default=os.path.join(here, "..", "reference", "artifact.html"))
+    a = ap.parse_args()
+
+    lib = os.path.abspath(os.path.expanduser(a.dir))
+    os.makedirs(lib, exist_ok=True)
+    Handler.lib = lib
+    Handler.artifact = os.path.abspath(a.artifact)
+    n = len([f for f in os.listdir(lib) if f.endswith(".md") and not f.startswith("_")])
+    print(f"Library: {lib}  ({n} videos)")
+    print(f"Artifact: {Handler.artifact}")
+    print(f"Serving on http://{a.host}:{a.port}/   (Ctrl-C to stop)")
+    ThreadingHTTPServer((a.host, a.port), Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/youtube-notetaker/scripts/setup.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Resolve a YouTube id from a URL/id, print the scratch dir, and report embeddability.
+# Usage: setup.sh "<youtube_url_or_id>"
+#
+# Library location is configurable via the VIDEO_LIBRARY_DIR env var
+# (default: ~/video-deepdives). One markdown file per video lives there.
+set -euo pipefail
+IN="${1:?usage: setup.sh <youtube_url_or_id>}"
+LIB="${VIDEO_LIBRARY_DIR:-$HOME/video-deepdives}"
+
+# Extract 11-char id from common URL shapes, or accept a bare id.
+YTID="$(printf '%s' "$IN" | sed -nE 's#.*(youtu\.be/|v=|/embed/|/shorts/)([A-Za-z0-9_-]{11}).*#\2#p')"
+[ -z "$YTID" ] && [ "${#IN}" -eq 11 ] && YTID="$IN"
+[ -z "$YTID" ] && { echo "Could not parse a YouTube id from: $IN" >&2; exit 1; }
+
+SCRATCH="/tmp/ytnote-$YTID"
+mkdir -p "$SCRATCH"
+
+# Embeddability: oembed returns 200 if embedding allowed, 401 if the owner disabled it.
+CODE="$(curl -s -o /dev/null -w '%{http_code}' \
+  "https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v=$YTID&format=json" || echo "000")"
+if [ "$CODE" = "200" ]; then EMBED="allowed"; else EMBED="BLOCKED (oembed $CODE) — inline player disabled, artifact falls back to YouTube link"; fi
+
+echo "YTID:    $YTID"
+echo "SCRATCH: $SCRATCH"
+echo "EMBED:   $EMBED"
+echo "LIBRARY: $LIB/$YTID.md"

package/bundled-skills/youtube-notetaker/scripts/verify.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Verify a video is correctly served by the standalone server + appears in the index.
+# Usage: verify.sh <YTID> [base_url]
+# Start the server first:  python3 scripts/serve.py --dir <LIBRARY> --port 8000
+set -uo pipefail
+YTID="${1:?usage: verify.sh <YTID> [base_url]}"
+BASE="${2:-http://127.0.0.1:8000}"  # standalone serve.py default port
+COLL="$BASE/api/video-deepdives"
+fail=0
+
+code(){ curl -s -o /dev/null -w '%{http_code}' "$1"; }
+
+echo "1) collection list:"
+C=$(code "$COLL"); echo "   GET $COLL -> $C"; [ "$C" = 200 ] || fail=1
+if curl -s "$COLL" | grep -q "\"$YTID\""; then echo "   ✓ $YTID present in index"; else echo "   ✗ $YTID NOT in index"; fail=1; fi
+
+echo "2) item:"
+C=$(code "$COLL/$YTID"); echo "   GET $COLL/$YTID -> $C"; [ "$C" = 200 ] || fail=1
+
+echo "3) first slide image:"
+C=$(code "$COLL/_media/$YTID-slide-01.jpg"); echo "   GET .../_media/$YTID-slide-01.jpg -> $C"; [ "$C" = 200 ] || fail=1
+
+echo "4) artifact shell:"
+C=$(code "$BASE/"); echo "   GET / -> $C"; [ "$C" = 200 ] || fail=1
+
+if [ "$fail" = 0 ]; then
+  echo "ALL GOOD. Open: $BASE/#/$YTID"
+else
+  echo "SOME CHECKS FAILED — is serve.py running and pointed at the library that contains $YTID?"
+fi
+exit $fail

package/bundled-skills/youtube-notetaker/scripts/vtt_to_transcript.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Convert a YouTube .vtt (manual or auto-captions) into clean [HH:MM:SS] transcript lines.
+
+Usage: vtt_to_transcript.py <input.vtt> <output.txt>
+
+Handles the rolling-duplicate problem in auto-captions: each cue repeats the tail of the
+previous cue, so we keep only newly-added words per cue and emit one line per cue start
+time. Strips inline <00:00:00.000> word-timing tags and HTML tags.
+"""
+import sys, re, html
+
+TS=re.compile(r'(\d{2}):(\d{2}):(\d{2})\.\d{3}\s*-->\s*(\d{2}):(\d{2}):(\d{2})')
+INLINE=re.compile(r'<[^>]+>')
+
+def hhmmss(h,m,s): return f"[{int(h):02d}:{int(m):02d}:{int(s):02d}]"
+
+def clean(text):
+    text=INLINE.sub('',text)
+    text=html.unescape(text)
+    return re.sub(r'\s+',' ',text).strip()
+
+def main():
+    if len(sys.argv)!=3: sys.exit("usage: vtt_to_transcript.py <in.vtt> <out.txt>")
+    raw=open(sys.argv[1],encoding='utf-8',errors='replace').read().splitlines()
+    cues=[]  # (start_label, text)
+    i=0; cur=None
+    while i<len(raw):
+        m=TS.search(raw[i])
+        if m:
+            if cur: cues.append(cur)
+            cur=[hhmmss(*m.groups()[:3]),[]]
+            i+=1
+            while i<len(raw) and not TS.search(raw[i]) and raw[i].strip()!='':
+                if raw[i].strip() and not raw[i].strip().isdigit():
+                    cur[1].append(clean(raw[i]))
+                i+=1
+        else:
+            i+=1
+    if cur: cues.append(cur)
+
+    # De-duplicate rolling captions: keep only the suffix not already seen.
+    out=[]; seen_words=[]
+    for label,parts in cues:
+        text=clean(' '.join(parts))
+        if not text: continue
+        words=text.split()
+        # find longest overlap of seen tail with this cue's head
+        overlap=0; maxk=min(len(words),len(seen_words))
+        for k in range(maxk,0,-1):
+            if seen_words[-k:]==words[:k]: overlap=k; break
+        new=words[overlap:]
+        if new:
+            out.append(f"{label} {' '.join(new)}")
+        seen_words=(seen_words+new)[-40:]  # bounded window
+    with open(sys.argv[2],'w',encoding='utf-8') as f:
+        f.write('\n'.join(out)+'\n')
+    print(f"wrote {len(out)} transcript lines -> {sys.argv[2]}")
+
+if __name__=="__main__": main()

package/bundled-skills/youtube-notetaker/scripts/write_library_item.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Assemble the library markdown file for a video deep-dive.
+
+Usage:
+  write_library_item.py --id <YTID> --title "..." --speaker "..." \
+    --tags a,b,c --slides slides.json --transcript transcript.txt [--created YYYY-MM-DD]
+
+slides.json: a JSON array of slide objects. Each:
+  {
+    "idx": 1,                # sequence/original frame number (display only; sorted by t)
+    "t": 55.7,               # seconds (float ok) — used for video seeking
+    "mmss": "00:55",         # display label
+    "title": "Slide title",  # short headline
+    "note": "1-3 sentences grounded in the transcript at this timestamp.",
+    "img": "/api/video-deepdives/_media/<YTID>-slide-01.jpg"
+  }
+
+Writes  $VIDEO_LIBRARY_DIR/<YTID>.md  (default ~/video-deepdives/<YTID>.md)
+with YAML frontmatter + transcript body. No em dashes or arrows in titles/notes.
+"""
+import argparse, json, os, sys, datetime
+try:
+    import yaml
+except ImportError:
+    sys.exit("pip install pyyaml")
+
+LIB = os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives"))
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument("--id",required=True)
+    ap.add_argument("--title",required=True)
+    ap.add_argument("--speaker",default="")
+    ap.add_argument("--tags",default="")
+    ap.add_argument("--slides",required=True)
+    ap.add_argument("--transcript",required=True)
+    ap.add_argument("--created",default=datetime.date.today().isoformat())
+    a=ap.parse_args()
+
+    slides=json.load(open(a.slides))
+    slides=sorted(slides,key=lambda s:s["t"])
+    for bad in ("—","→"):
+        for s in slides:
+            if bad in (s.get("title") or "")+(s.get("note") or ""):
+                sys.exit(f"Found forbidden char {bad!r} in slide notes/titles; remove it.")
+
+    fm={
+        "id":a.id,
+        "title":a.title,
+        "youtube_id":a.id,
+        "speaker":a.speaker,
+        "source_url":f"https://www.youtube.com/watch?v={a.id}",
+        "slide_count":len(slides),
+        "created":a.created,
+        "tags":[t.strip() for t in a.tags.split(",") if t.strip()],
+        "slides":slides,
+    }
+    body=open(a.transcript,encoding="utf-8").read().strip()
+    os.makedirs(LIB,exist_ok=True)
+    path=os.path.join(LIB,f"{a.id}.md")
+    with open(path,"w",encoding="utf-8") as f:
+        f.write("---\n")
+        yaml.safe_dump(fm,f,sort_keys=False,allow_unicode=True,width=100)
+        f.write("---\n## Transcript\n")
+        f.write(body+"\n")
+    print(f"wrote {path}  ({len(slides)} slides, {len(body.splitlines())} transcript lines)")
+    print("Verify with: scripts/verify.sh "+a.id)
+
+if __name__=="__main__": main()

package/dist/skill-pointer/config-loader.d.ts

@@ -1,7 +1,21 @@
 import type { RiskLevel } from "./risk-level.js";
+export interface ScanPattern {
+    id: string;
+    pattern: string;
+    description: string;
+    severity: "block" | "warn";
+}
+export interface SkillPatch {
+    skillId: string;
+    find: string;
+    replace: string;
+    description?: string;
+}
 export interface SkillRiskFilterConfig {
     excludedRiskLevels?: RiskLevel[];
     excludedSkills?: string[];
+    scanPatterns?: ScanPattern[];
+    skillPatches?: SkillPatch[];
 }
 export declare const DEFAULT_FILTER_CONFIG_PATH: string;
 /**

package/dist/skill-pointer/config-loader.js

@@ -1,13 +1,34 @@
-import os from "os";
-import path from "path";
-import fs from "fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs";
 import stripJsonComments from "strip-json-comments";
 const DEFAULT_CONFIG = {
     excludedRiskLevels: [],
     excludedSkills: [],
+    scanPatterns: [],
+    skillPatches: [],
 };
 export const DEFAULT_FILTER_CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "skill-filter.jsonc");
 const VALID_RISK_LEVELS = ["none", "safe", "critical", "offensive", "unknown"];
+const VALID_SEVERITIES = ["block", "warn"];
+function isValidScanPattern(entry) {
+    if (typeof entry !== "object" || entry === null)
+        return false;
+    const obj = entry;
+    return (typeof obj.id === "string" &&
+        typeof obj.pattern === "string" &&
+        typeof obj.description === "string" &&
+        typeof obj.severity === "string" &&
+        VALID_SEVERITIES.includes(obj.severity));
+}
+function isValidSkillPatch(entry) {
+    if (typeof entry !== "object" || entry === null)
+        return false;
+    const obj = entry;
+    return (typeof obj.skillId === "string" &&
+        typeof obj.find === "string" &&
+        typeof obj.replace === "string");
+}
 /**
  * Loads filter config from skill-filter.jsonc. Missing file or section returns defaults.
  * @param configPath Optional override (for testing).
@@ -28,6 +49,12 @@ export function loadFilterConfig(configPath) {
             excludedSkills: Array.isArray(parsed.excludedSkills)
                 ? parsed.excludedSkills
                 : DEFAULT_CONFIG.excludedSkills,
+            scanPatterns: Array.isArray(parsed.scanPatterns)
+                ? parsed.scanPatterns.filter(isValidScanPattern)
+                : DEFAULT_CONFIG.scanPatterns,
+            skillPatches: Array.isArray(parsed.skillPatches)
+                ? parsed.skillPatches.filter(isValidSkillPatch)
+                : DEFAULT_CONFIG.skillPatches,
         };
     }
     catch {

package/dist/skill-pointer/content-scanner.d.ts

@@ -0,0 +1,38 @@
+import type { ScanPattern } from "./config-loader.js";
+import type { SkillIndexEntry } from "./vault-installer.js";
+export interface ScanResult {
+    skillId: string;
+    matchedPatterns: {
+        id: string;
+        severity: "block" | "warn";
+    }[];
+    blocked: boolean;
+}
+export interface ScanOutput {
+    passed: SkillIndexEntry[];
+    quarantined: ScanResult[];
+    warned: ScanResult[];
+}
+/** Default patterns that detect recursive loop triggers in skill content. */
+export declare const DEFAULT_SCAN_PATTERNS: ScanPattern[];
+/**
+ * Merges user-supplied scan patterns with built-in defaults.
+ * Config patterns with the same `id` override the default entry,
+ * but only if the config pattern has a valid regex. Invalid overrides
+ * are rejected and the default is preserved to prevent silently
+ * disabling built-in protection.
+ */
+export declare function mergePatterns(configPatterns: ScanPattern[]): ScanPattern[];
+/**
+ * Tests skill content against a list of scan patterns.
+ * Returns the list of matched pattern ids and severities.
+ */
+export declare function scanSkillContent(content: string, patterns: ScanPattern[]): {
+    id: string;
+    severity: "block" | "warn";
+}[];
+/**
+ * Scans every skill's SKILL.md for dangerous content patterns.
+ * Returns lists of passed, quarantined (blocked), and warned entries.
+ */
+export declare function scanSkills(bundledSkillsPath: string, index: SkillIndexEntry[], configPatterns?: ScanPattern[]): ScanOutput;

package/dist/skill-pointer/content-scanner.js

@@ -0,0 +1,118 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { SKILL_FILENAME } from "../constants/constants.js";
+/** Default patterns that detect recursive loop triggers in skill content. */
+export const DEFAULT_SCAN_PATTERNS = [
+    {
+        id: "recursive-skill-invocation",
+        pattern: String.raw `(invoke|use|check|load)\b.*?\bskills?\b.*?\bbefore\s+(any|every|all)\s+(response|action|message)`,
+        description: "Detects instructions mandating skill invocation before every response",
+        severity: "block",
+    },
+    {
+        id: "aggressive-match-threshold",
+        pattern: String.raw `(even\s+)?(a\s+)?1%\s+chance.*skill`,
+        description: "Detects extremely low probability thresholds causing over-triggering",
+        severity: "block",
+    },
+    {
+        id: "mandatory-pre-response-skill-check",
+        pattern: String.raw `you\s+(absolutely\s+)?must.*invoke.*skill`,
+        description: "Detects mandatory skill invocation directives",
+        severity: "block",
+    },
+];
+/**
+ * Merges user-supplied scan patterns with built-in defaults.
+ * Config patterns with the same `id` override the default entry,
+ * but only if the config pattern has a valid regex. Invalid overrides
+ * are rejected and the default is preserved to prevent silently
+ * disabling built-in protection.
+ */
+export function mergePatterns(configPatterns) {
+    const merged = new Map();
+    for (const p of DEFAULT_SCAN_PATTERNS) {
+        merged.set(p.id, p);
+    }
+    for (const p of configPatterns) {
+        // Validate regex before allowing override
+        try {
+            new RegExp(p.pattern, "is");
+            merged.set(p.id, p);
+        }
+        catch {
+            // If this would override a default, keep the default — don't silently disable protection
+            if (!merged.has(p.id)) {
+                // New pattern with invalid regex — just skip it
+                console.warn(`Invalid regex for pattern '${p.id}': ${p.pattern}`);
+            }
+            // Existing default stays in place
+        }
+    }
+    return [...merged.values()];
+}
+/**
+ * Tests skill content against a list of scan patterns.
+ * Returns the list of matched pattern ids and severities.
+ */
+export function scanSkillContent(content, patterns) {
+    const matches = [];
+    for (const p of patterns) {
+        try {
+            const re = new RegExp(p.pattern, "is");
+            if (re.test(content)) {
+                matches.push({ id: p.id, severity: p.severity });
+            }
+        }
+        catch {
+            // Invalid regex — skip silently
+        }
+    }
+    return matches;
+}
+/**
+ * Scans every skill's SKILL.md for dangerous content patterns.
+ * Returns lists of passed, quarantined (blocked), and warned entries.
+ */
+export function scanSkills(bundledSkillsPath, index, configPatterns) {
+    const patterns = mergePatterns(configPatterns ?? []);
+    const passed = [];
+    const quarantined = [];
+    const warned = [];
+    for (const entry of index) {
+        // Path traversal guard: quarantine entries whose id escapes the bundled-skills directory
+        if (entry.id.includes("..") || entry.id.includes(path.sep) || entry.id.includes("/")) {
+            quarantined.push({
+                skillId: entry.id,
+                matchedPatterns: [{ id: "path-traversal", severity: "block" }],
+                blocked: true,
+            });
+            continue;
+        }
+        const skillFile = path.join(bundledSkillsPath, entry.id, SKILL_FILENAME);
+        if (!fs.existsSync(skillFile)) {
+            passed.push(entry);
+            continue;
+        }
+        const content = fs.readFileSync(skillFile, "utf-8");
+        const matches = scanSkillContent(content, patterns);
+        if (matches.length === 0) {
+            passed.push(entry);
+            continue;
+        }
+        const hasBlock = matches.some((m) => m.severity === "block");
+        const result = {
+            skillId: entry.id,
+            matchedPatterns: matches,
+            blocked: hasBlock,
+        };
+        if (hasBlock) {
+            quarantined.push(result);
+        }
+        else {
+            warned.push(result);
+            passed.push(entry);
+        }
+    }
+    return { passed, quarantined, warned };
+}

package/dist/skill-pointer/index.d.ts

@@ -17,10 +17,15 @@ export interface SkillPointerOptions {
  * Orchestrates the full SkillPointer pipeline:
  *
  * 1. Reads skills_index.json bundled alongside the skills snapshot.
- * 2. Copies bundled skills directly into the vault, categorised by the index.
- * 3. Generates pointer SKILL.md files in activeSkillsDir with full skill
+ * 2. Filters by risk level / excluded skills.
+ * 3. Copies skills into the vault, categorised by the index.
+ * 4. Applies config-driven content patches to installed skills.
+ * 5. Generates pointer SKILL.md files in activeSkillsDir with full skill
  *    listings so keyword searches (e.g. "laravel") resolve out of the box.
  *
+ * Content safety scanning is performed at CI time (sync-skills.yml),
+ * not at runtime — dangerous skills are removed before npm publish.
+ *
  * The activeSkillsDir is never used as a staging area — user custom
  * skills already present there are never moved or overwritten.
  */

package/dist/skill-pointer/index.js

@@ -1,11 +1,12 @@
-import os from "os";
-import path from "path";
+import * as os from "node:os";
+import * as path from "node:path";
 import { VAULT_DIR_NAME } from "../constants/constants.js";
 import { ensureDir } from "../utils/fs.utils.js";
 import { generatePointers } from "./pointer-generator.js";
 import { installSkillsToVault, loadSkillsIndex } from "./vault-installer.js";
 import { filterIndex } from "./skill-risk-filter.js";
 import { loadFilterConfig, DEFAULT_FILTER_CONFIG_PATH } from "./config-loader.js";
+import { applySkillPatches } from "./skill-patcher.js";
 function resolveDefaultVaultDir() {
     return path.join(os.homedir(), ".config", "opencode", VAULT_DIR_NAME);
 }
@@ -13,10 +14,15 @@ function resolveDefaultVaultDir() {
  * Orchestrates the full SkillPointer pipeline:
  *
  * 1. Reads skills_index.json bundled alongside the skills snapshot.
- * 2. Copies bundled skills directly into the vault, categorised by the index.
- * 3. Generates pointer SKILL.md files in activeSkillsDir with full skill
+ * 2. Filters by risk level / excluded skills.
+ * 3. Copies skills into the vault, categorised by the index.
+ * 4. Applies config-driven content patches to installed skills.
+ * 5. Generates pointer SKILL.md files in activeSkillsDir with full skill
  *    listings so keyword searches (e.g. "laravel") resolve out of the box.
  *
+ * Content safety scanning is performed at CI time (sync-skills.yml),
+ * not at runtime — dangerous skills are removed before npm publish.
+ *
  * The activeSkillsDir is never used as a staging area — user custom
  * skills already present there are never moved or overwritten.
  */
@@ -29,5 +35,9 @@ export function runSkillPointer(options) {
     const config = loadFilterConfig(configPath);
     const filteredIndex = filterIndex(index, config);
     installSkillsToVault(options.bundledSkillsPath, vaultDir, filteredIndex);
+    // Apply content patches
+    if (config.skillPatches && config.skillPatches.length > 0) {
+        applySkillPatches(vaultDir, filteredIndex, config.skillPatches);
+    }
     generatePointers(options.activeSkillsDir, vaultDir, filteredIndex);
 }

package/dist/skill-pointer/pointer-generator.js

@@ -35,6 +35,8 @@ ${skillList}
 **Vault path:** \`${normalizedPath}\`
 
 > Do not guess best practices — always read from the vault first.
+
+> ⚠️ **Anti-loop guard**: Do NOT invoke skills recursively or check for applicable skills before every response. Each skill should be loaded at most once per user request. If you have already identified and loaded the relevant skill for this task, proceed with execution — do not re-scan for skills.
 `;
 }
 /**