devrites 3.2.28 → 4.0.0

package/scripts/scan-pack-security.py

@@ -1,209 +0,0 @@
-#!/usr/bin/env python3
-"""Scan the shipped DevRites pack for prompt-injection and hidden-unicode risks.
-
-DevRites ships executable instruction files (skills, agents, rules, hooks) into
-other people's projects. A poisoned or invisibly-altered file is a supply-chain
-vulnerability, not a style nit (cf. the Snyk Feb-2026 "ToxicSkills" study: 36%
-of public skills carried prompt injection). This is the BLOCKING gate that keeps
-such a file from ever being released.
-
-Usage: scan-pack-security.py PATH [PATH ...]
-  PATH may be a file or a directory (directories are walked for text files).
-Exits non-zero if any finding is reported.
-
-Two finding classes:
-
-  1. Hidden unicode (always a finding: no legitimate reason to exist in a
-     Markdown/shell instruction file): bidi controls, zero-width characters,
-     other invisibles, and homoglyph confusables (a word that mixes ASCII with
-     look-alike Cyrillic/Greek letters).
-
-  2. Prompt-injection patterns (a finding unless explicitly suppressed): the
-     "ignore previous instructions" family, system-prompt overrides, tool /
-     permission escalation, and data-exfiltration phrasing.
-
-Suppression (for DevRites' own files that legitimately *discuss* injection
-defensively: e.g. security.md, the reviewer agents): put a marker on the same
-line OR anywhere in the file:
-
-    ... ignore previous instructions ...   <!-- pack-scan-ignore: defensive doc -->
-
-A whole file can opt a class out with a top-of-file marker:
-
-    <!-- pack-scan-ignore-file: injection -->
-
-Suppressions live in the file, so every exception is visible in the diff and
-reviewable: consistent with DevRites' "no silent state" thesis. Hidden-unicode
-findings can be suppressed the same way but should essentially never be.
-"""
-import os
-import re
-import sys
-import unicodedata
-
-# --- hidden unicode -------------------------------------------------------
-
-# Invisible / formatting code points with no business in an instruction file.
-ZERO_WIDTH = {
-    0x200B,  # zero width space
-    0x200C,  # zero width non-joiner
-    0x200D,  # zero width joiner
-    0x2060,  # word joiner
-    0xFEFF,  # zero width no-break space / BOM (mid-file)
-    0x180E,  # mongolian vowel separator
-    0x00AD,  # soft hyphen
-}
-BIDI_CONTROLS = {
-    0x202A, 0x202B, 0x202C, 0x202D, 0x202E,  # LRE RLE PDF LRO RLO
-    0x2066, 0x2067, 0x2068, 0x2069,          # LRI RLI FSI PDI
-    0x200E, 0x200F,                          # LRM RLM
-}
-HIDDEN = ZERO_WIDTH | BIDI_CONTROLS
-
-# Scripts whose letters are commonly used as ASCII look-alikes.
-CONFUSABLE_SCRIPTS = ("CYRILLIC", "GREEK")
-
-
-def _char_script(ch):
-    try:
-        return unicodedata.name(ch).split(" ")[0]
-    except ValueError:
-        return ""
-
-
-def find_hidden_unicode(text):
-    """Yield (line_no, col, label) for hidden code points and homoglyph words."""
-    for lineno, line in enumerate(text.splitlines(), start=1):
-        for col, ch in enumerate(line, start=1):
-            cp = ord(ch)
-            if cp == 0xFEFF and lineno == 1 and col == 1:
-                continue  # a leading BOM is legal; only mid-file ZWNBSP is suspect
-            if cp in HIDDEN:
-                yield lineno, col, "hidden char U+%04X (%s)" % (cp, _hidden_name(cp))
-        # Homoglyph: a token mixing ASCII letters with confusable-script letters.
-        for m in re.finditer(r"\S+", line):
-            tok = m.group(0)
-            has_ascii_alpha = any(("a" <= c.lower() <= "z") for c in tok)
-            mixed = [c for c in tok if c.isalpha() and _char_script(c) in CONFUSABLE_SCRIPTS]
-            if has_ascii_alpha and mixed:
-                yield lineno, m.start() + 1, (
-                    "homoglyph: ASCII word mixes %s look-alike(s) %r" % (
-                        _char_script(mixed[0]).title(), "".join(sorted(set(mixed)))))
-
-
-def _hidden_name(cp):
-    try:
-        return unicodedata.name(chr(cp))
-    except ValueError:
-        return "unnamed"
-
-
-# --- prompt-injection patterns -------------------------------------------
-
-# Each: (label, compiled regex). Kept high-signal to limit false positives on
-# legitimate prose; defensive discussion is handled via suppression markers.
-# Gaps use '.' (any non-newline char): scanning is per-line, so a match can't
-# cross lines, and excluding periods would miss tokens like ".env" / ".ssh".
-_INJECTION = [
-    ("ignore-previous-instructions",
-     r"\b(ignore|disregard|forget)\b.{0,40}\b(previous|prior|above|earlier|all)\b"
-     r".{0,20}\b(instruction|instructions|prompt|prompts|direction|directions|context)\b"),
-    ("system-prompt-override",
-     r"\b(you are now|act as|pretend to be|new instructions\s*:|override (your|the) (system|prompt|rules))"),
-    ("permission-escalation",
-     r"\b(bypass|ignore|disable|skip)\b.{0,30}\b(approval|permission|permissions|guardrail|guardrails|safety|sandbox|restriction|restrictions)\b"),
-    ("data-exfiltration",
-     r"\b(exfiltrat\w+|send|post|upload|leak|curl|wget)\b.{0,40}\b(env|environment|secret|secrets|credential|credentials|token|tokens|api[_-]?key|\.ssh|private key)\b"),
-]
-INJECTION = [(label, re.compile(rx, re.IGNORECASE)) for label, rx in _INJECTION]
-
-
-def find_injection(text, file_suppressed):
-    """Yield (line_no, label, excerpt) for injection patterns, honoring suppression."""
-    for lineno, line in enumerate(text.splitlines(), start=1):
-        if _line_suppressed(line):
-            continue
-        for label, rx in INJECTION:
-            if "injection" in file_suppressed:
-                break
-            m = rx.search(line)
-            if m:
-                yield lineno, label, line.strip()[:120]
-
-
-_LINE_SUPPRESS = re.compile(r"pack-scan-ignore\b(?!-file)", re.IGNORECASE)
-# Class list is word/comma/space only: a trailing "-->" comment closer must not
-# get swallowed into the captured class name.
-_FILE_SUPPRESS = re.compile(r"pack-scan-ignore-file\s*:\s*([\w, ]+)", re.IGNORECASE)
-
-
-def _line_suppressed(line):
-    return bool(_LINE_SUPPRESS.search(line))
-
-
-def _file_suppressions(text):
-    classes = set()
-    for m in _FILE_SUPPRESS.finditer(text):
-        for c in m.group(1).split(","):
-            classes.add(c.strip().lower())
-    return classes
-
-
-# --- driver ---------------------------------------------------------------
-
-TEXT_EXTS = {".md", ".sh", ".json", ".toml", ".txt", ".py", ".js", ".yaml", ".yml", ""}
-
-
-def iter_files(paths):
-    for p in paths:
-        if os.path.isdir(p):
-            for root, _dirs, names in os.walk(p):
-                for n in sorted(names):
-                    fp = os.path.join(root, n)
-                    ext = os.path.splitext(n)[1].lower()
-                    if ext in TEXT_EXTS:
-                        yield fp
-        else:
-            yield p
-
-
-def scan(paths):
-    """Return a list of finding strings. Empty list == clean."""
-    findings = []
-    for path in iter_files(paths):
-        try:
-            with open(path, "r", encoding="utf-8") as fh:
-                text = fh.read()
-        except (OSError, UnicodeDecodeError) as e:
-            findings.append("ERROR %s: cannot read as utf-8 (%s)" % (path, e))
-            continue
-        file_sup = _file_suppressions(text)
-        hidden_off = ("unicode" in file_sup) or ("hidden" in file_sup)
-        if not hidden_off:
-            for lineno, col, label in find_hidden_unicode(text):
-                if _line_suppressed(text.splitlines()[lineno - 1]):
-                    continue
-                findings.append("FINDING %s:%d:%d: %s" % (path, lineno, col, label))
-        for lineno, label, excerpt in find_injection(text, file_sup):
-            findings.append("FINDING %s:%d: injection/%s: %s" % (path, lineno, label, excerpt))
-    return findings
-
-
-def main(argv):
-    paths = argv[1:]
-    if not paths:
-        print("usage: scan-pack-security.py PATH [PATH ...]", file=sys.stderr)
-        return 2
-    findings = scan(paths)
-    if findings:
-        for f in findings:
-            print(f)
-        print("\n%d security finding(s). Fix, or add an auditable "
-              "pack-scan-ignore marker if this is defensive content." % len(findings))
-        return 1
-    print("OK    pack security scan clean (%s)" % ", ".join(paths))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))

package/scripts/scan-supply-chain-iocs.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python3
-"""Scan an npm lockfile against known supply-chain indicators of compromise.
-
-Dependabot manages version *updates*; this gate catches a *known-malicious* installed
-version (a compromised release that slipped in). It checks every name@version in the
-lockfile against the bundled IOC dataset (scripts/supply-chain-iocs.json): an offline,
-always-available advisory source, so CI is deterministic and needs no network.
-
-`--online` also queries the OSV API per package and is best-effort: if the
-advisory source is unreachable it prints a notice and falls back to the bundled dataset
-(it never fails the build on a network error: only on a real IOC match).
-
-Usage: scan-supply-chain-iocs.py [LOCKFILE] [--iocs FILE] [--online]
-  LOCKFILE defaults to package-lock.json.
-Exit: 0 clean; 1 on an IOC match; 2 on a usage/parse error.
-"""
-import json
-import os
-import sys
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-DEFAULT_IOCS = os.path.join(HERE, "supply-chain-iocs.json")
-
-
-def load_iocs(path):
-    with open(path, "r", encoding="utf-8") as fh:
-        data = json.load(fh)
-    index = {}
-    for e in data.get("iocs", []):
-        index[e["name"]] = e
-    return index
-
-
-def installed_packages(lockfile):
-    """Yield (name, version) for every package in an npm lockfile (v2/v3 or v1)."""
-    with open(lockfile, "r", encoding="utf-8") as fh:
-        data = json.load(fh)
-    pkgs = data.get("packages")
-    if isinstance(pkgs, dict):  # lockfile v2/v3
-        for key, meta in pkgs.items():
-            if not key or "node_modules/" not in key:
-                continue
-            name = key.split("node_modules/")[-1]
-            ver = (meta or {}).get("version")
-            if name and ver:
-                yield name, ver
-    deps = data.get("dependencies")
-    if isinstance(deps, dict):  # lockfile v1 (recursive)
-        stack = list(deps.items())
-        while stack:
-            name, meta = stack.pop()
-            meta = meta or {}
-            ver = meta.get("version")
-            if name and ver:
-                yield name, ver
-            nested = meta.get("dependencies")
-            if isinstance(nested, dict):
-                stack.extend(nested.items())
-
-
-def query_osv(name, version):
-    """Best-effort OSV lookup. Returns a finding note or None; never raises."""
-    try:
-        import json as _json
-        import urllib.request
-        body = _json.dumps({"package": {"name": name, "ecosystem": "npm"},
-                            "version": version}).encode()
-        req = urllib.request.Request("https://api.osv.dev/v1/query", data=body,
-                                     headers={"Content-Type": "application/json"})
-        with urllib.request.urlopen(req, timeout=8) as r:
-            vulns = _json.loads(r.read()).get("vulns", [])
-        ids = [v.get("id") for v in vulns if v.get("id")]
-        return ("OSV: " + ", ".join(ids)) if ids else None
-    except Exception:
-        return "__unreachable__"
-
-
-def main(argv):
-    args = [a for a in argv[1:]]
-    online = "--online" in args
-    args = [a for a in args if a != "--online"]
-    iocs_path = DEFAULT_IOCS
-    if "--iocs" in args:
-        i = args.index("--iocs")
-        iocs_path = args[i + 1]
-        del args[i:i + 2]
-    lockfile = args[0] if args else "package-lock.json"
-
-    if not os.path.isfile(lockfile):
-        print("OK    no lockfile at %s: nothing to scan" % lockfile)
-        return 0
-    try:
-        index = load_iocs(iocs_path)
-        pkgs = list(installed_packages(lockfile))
-    except (OSError, ValueError, KeyError) as e:
-        print("ERROR cannot scan (%s)" % e, file=sys.stderr)
-        return 2
-
-    findings = []
-    for name, ver in pkgs:
-        e = index.get(name)
-        if e and ver in e.get("versions", []):
-            findings.append("FINDING %s@%s: %s (%s)" % (name, ver, e["note"], e["source"]))
-
-    if online:
-        offline_notice = False
-        for name, ver in pkgs:
-            res = query_osv(name, ver)
-            if res == "__unreachable__":
-                offline_notice = True
-                break
-            if res:
-                findings.append("FINDING %s@%s: %s" % (name, ver, res))
-        if offline_notice:
-            print("note: OSV unreachable: fell back to the bundled IOC dataset only")
-
-    if findings:
-        for f in sorted(set(findings)):
-            print(f)
-        print("\n%d supply-chain finding(s) across %d packages." % (len(set(findings)), len(pkgs)))
-        return 1
-    print("OK    supply-chain scan clean (%d packages, %d IOCs)" % (len(pkgs), len(index)))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))

package/scripts/skill-pruning-audit.mjs

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-// Advisory pruning audit plus blocking ordered-step completion contracts.
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const root = fileURLToPath(new URL('..', import.meta.url));
-const skillsArg = process.argv.indexOf('--skills-dir');
-const skillsDir = skillsArg >= 0 ? process.argv[skillsArg + 1] : join(root, 'pack', '.claude', 'skills');
-const quiet = process.argv.includes('--quiet');
-
-function frontmatter(src) {
-  const m = src.match(/^---\n([\s\S]*?)\n---/);
-  const out = {};
-  if (!m) return out;
-  for (const line of m[1].split(/\r?\n/)) {
-    const i = line.indexOf(':');
-    if (i > 0) out[line.slice(0, i).trim()] = line.slice(i + 1).trim().replace(/^['"]|['"]$/g, '');
-  }
-  return out;
-}
-
-function refs(src) {
-  return [...src.matchAll(/\]\(([^)]+\.md)\)/g)].map((m) => m[1]);
-}
-
-function workflowSteps(src) {
-  const steps = [];
-  const sections = src.matchAll(/^## (?:Workflow|Protocol|Process|Steps|Run|Flow|The .*cycle)[^\n]*\n([\s\S]*?)(?=^##\s|(?![\s\S]))/gm);
-  for (const section of sections) {
-    const body = section[1];
-    const starts = [...body.matchAll(/^(\d+[a-z]?)\.\s+/gm)];
-    steps.push(...starts.map((match, i) => ({
-      id: match[1],
-      body: body.slice(match.index, starts[i + 1]?.index ?? body.length),
-    })));
-  }
-  return steps;
-}
-
-function hasStepCompletion(body) {
-  const explicit = /\b(done when|completion|stop(?:s|ped)?|pass(?:es|ed)?|fail(?:s|ed)?|written|updated|recorded|reported|returned|emitted|rendered|confirmed|verified|captured|mapped|resolved|green)\b|\brc=|\bexit\s+\d|\buntil\b/i;
-  const observableAction = /\b(write|update|record|report|return|emit|render|confirm|verify|read|run|dispatch|apply|select|capture|map|append|persist|fetch|compare|classify|rank|fix|build)\b/i;
-  const observableTarget = /`[^`]+`|\b(file|artifact|command|result|verdict|matrix|diff|workspace|slice|question|route|scenario|report|evidence|spec|plan|test|check|gate|surface|journey|finding|decision)\b/i;
-  return explicit.test(body) || (observableAction.test(body) && observableTarget.test(body));
-}
-
-function markdownFiles(dir, skipResearch = false) {
-  const out = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith('.') || entry.name === 'generated' || (skipResearch && entry.name === 'research')) continue;
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...markdownFiles(path, skipResearch));
-    else if (entry.isFile() && entry.name.endsWith('.md')) out.push(path);
-  }
-  return out;
-}
-
-const warnings = [];
-const contractFailures = [];
-for (const dir of readdirSync(skillsDir).sort()) {
-  const file = join(skillsDir, dir, 'SKILL.md');
-  try { if (!statSync(file).isFile()) continue; } catch { continue; }
-  const src = readFileSync(file, 'utf8');
-  const fm = frontmatter(src);
-  const lines = src.split(/\r?\n/).length;
-  const isPublic = fm['user-invocable']?.toLowerCase() === 'true';
-  const budget = isPublic ? 220 : 180;
-  if (lines > budget) warnings.push(`${relative(root, file)}: ${lines} lines > advisory budget ${budget}; consider progressive disclosure`);
-
-  const desc = fm.description || '';
-  const useWhen = (desc.match(/\bUse (when|for)\b/g) || []).length;
-  if (useWhen > 1) warnings.push(`${relative(root, file)}: description has ${useWhen} trigger clauses; collapse duplicate branches if they are synonyms`);
-
-  if (refs(src).some((r) => r.includes('/') && !r.startsWith('reference/') && !r.startsWith('../'))) {
-    warnings.push(`${relative(root, file)}: has a multi-level reference pointer; prefer one-hop disclosure from SKILL.md`);
-  }
-
-  const hasCompletion = /Completion:|\bstop\b|output contract|reply contract|Verification|checklist/i.test(src);
-  const hasPointer = /reference\/|\.md\)/.test(src);
-  if (!hasCompletion && !hasPointer) warnings.push(`${relative(root, file)}: no obvious completion criterion or reference pointer`);
-  for (const step of workflowSteps(src)) {
-    if (!hasStepCompletion(step.body)) {
-      contractFailures.push(`${relative(root, file)}: ordered step ${step.id} needs a checkable completion criterion`);
-    }
-  }
-}
-
-const proseFiles = [
-  ...markdownFiles(skillsDir),
-  ...markdownFiles(join(root, 'pack', '.claude', 'agents')),
-  ...markdownFiles(join(root, 'docs'), true),
-  join(root, 'README.md'),
-  join(root, 'CONTRIBUTING.md'),
-];
-for (const file of proseFiles) {
-  const src = readFileSync(file, 'utf8');
-  const lines = src.split(/\r?\n/).map((line) => line.trim());
-  const seen = new Set();
-  let inCode = false;
-  for (const line of lines) {
-    if (line.startsWith('```')) { inCode = !inCode; continue; }
-    if (inCode || line.length < 100 || line.startsWith('|') || line.startsWith('> **Untrusted-input safety.**')) continue;
-    if (seen.has(line)) warnings.push(`${relative(root, file)}: repeats a long sentence/line; keep one owner or use a leading word`);
-    seen.add(line);
-  }
-  if (/^(?:[-*]\s+)?(?:be careful|be thorough|do your best|produce high quality)[.!]?$/im.test(src)) {
-    warnings.push(`${relative(root, file)}: contains a likely no-op instruction; replace it with a checkable target or delete it`);
-  }
-  if (/[/$](?:humanizer|writing-great-skills)\b/i.test(src)) {
-    warnings.push(`${relative(root, file)}: contains a foreign workflow command token in a promoted surface`);
-  }
-}
-
-if (!quiet) {
-  console.log(`skill-pruning-audit: ${warnings.length} advisory finding(s)`);
-  for (const w of warnings.slice(0, 40)) console.log(`warn: ${w}`);
-  if (warnings.length > 40) console.log(`warn: ${warnings.length - 40} more finding(s) suppressed`);
-}
-for (const failure of contractFailures) console.log(`FAIL: ${failure}`);
-process.exit(contractFailures.length ? 1 : 0);

package/scripts/skills-inventory.mjs

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-// Verify the authored DevRites skill inventory and documentation counts.
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const root = fileURLToPath(new URL('..', import.meta.url));
-const skillsDir = join(root, 'pack', '.claude', 'skills');
-const docsSkills = join(root, 'docs', 'skills.md');
-const docsCommandMap = join(root, 'docs', 'command-map.md');
-const docsFlow = join(root, 'docs', 'flow.md');
-const readme = join(root, 'README.md');
-const arch = join(root, 'docs', 'architecture.md');
-
-function fail(message) {
-  console.error(`FAIL: ${message}`);
-  failures++;
-}
-
-function frontmatter(text, file) {
-  const lines = text.split(/\r?\n/);
-  if (lines[0] !== '---') {
-    fail(`${file}: missing opening frontmatter fence`);
-    return new Map();
-  }
-  const fields = new Map();
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (line === '---') return fields;
-    if (!line.trim() || line.trimStart().startsWith('#') || /^[ \t]/.test(line)) continue;
-    const idx = line.indexOf(':');
-    if (idx === -1) continue;
-    const key = line.slice(0, idx).trim();
-    const value = line.slice(idx + 1).trim().replace(/^['"]|['"]$/g, '');
-    fields.set(key, value);
-  }
-  fail(`${file}: missing closing frontmatter fence`);
-  return fields;
-}
-
-let failures = 0;
-const skills = [];
-for (const entry of readdirSync(skillsDir).sort()) {
-  if (entry.startsWith('.')) continue;
-  const dir = join(skillsDir, entry);
-  if (!statSync(dir).isDirectory()) continue;
-  const file = join(dir, 'SKILL.md');
-  const text = readFileSync(file, 'utf8');
-  const fm = frontmatter(text, relative(root, file));
-  const name = fm.get('name') || '';
-  const description = fm.get('description') || '';
-  const invocable = fm.get('user-invocable') || '';
-  const lines = text.split(/\r?\n/).length;
-
-  if (name !== entry) fail(`${relative(root, file)}: name ${JSON.stringify(name)} does not match directory ${JSON.stringify(entry)}`);
-  if (!description) fail(`${relative(root, file)}: missing description`);
-  if (!['true', 'false'].includes(invocable)) fail(`${relative(root, file)}: user-invocable must be explicit true/false`);
-  if (entry === 'devrites-lib' && fm.get('disable-model-invocation') !== 'true') {
-    fail(`${relative(root, file)}: devrites-lib must set disable-model-invocation: true`);
-  }
-  skills.push({ name: entry, invocable, lines, description });
-}
-
-const total = skills.length;
-const publicCount = skills.filter((s) => s.invocable === 'true').length;
-const internalCount = skills.filter((s) => s.invocable === 'false').length;
-const publicRiteCount = skills.filter((s) => s.invocable === 'true' && s.name.startsWith('rite-')).length;
-const modelInvokedInternalCount = skills.filter((s) => s.invocable === 'false' && s.name !== 'devrites-lib').length;
-
-function assertDocContains(path, expected, label) {
-  const text = readFileSync(path, 'utf8');
-  if (!text.includes(expected)) {
-    fail(`${relative(root, path)}: missing ${label}: ${JSON.stringify(expected)}`);
-  }
-}
-
-function assertPublicSkillLinks(path, label) {
-  const text = readFileSync(path, 'utf8');
-  for (const skill of skills.filter((s) => s.invocable === 'true')) {
-    const link = `../pack/.claude/skills/${skill.name}/SKILL.md`;
-    if (!text.includes(link)) {
-      fail(`${relative(root, path)}: missing ${label} link for ${skill.name}: ${link}`);
-    }
-  }
-}
-
-function assertPublicSkillMentions(path, label) {
-  const text = readFileSync(path, 'utf8');
-  for (const skill of skills.filter((s) => s.invocable === 'true')) {
-    const escaped = skill.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const token = new RegExp(`(^|[^a-z0-9-])${escaped}([^a-z0-9-]|$)`, 'im');
-    if (!token.test(text)) {
-      fail(`${relative(root, path)}: missing ${label} entry for ${skill.name}`);
-    }
-  }
-}
-
-assertDocContains(docsSkills, `# All ${total} skills`, 'total skill heading');
-assertDocContains(docsSkills, `The pack contains ${total} skills`, 'total skill prose');
-assertDocContains(docsSkills, `${publicRiteCount} user-invocable \`rite-*\``, 'public rite-* count');
-assertDocContains(docsSkills, `${modelInvokedInternalCount} model-invoked \`devrites-*\` specialists`, 'model-invoked internal count');
-assertDocContains(docsSkills, 'npx devrites', 'npx distribution contract');
-assertDocContains(docsCommandMap, 'npx devrites', 'npx distribution contract');
-assertDocContains(readme, `The pack ships ${total} skills`, 'README total skill prose');
-assertDocContains(readme, `${publicCount} public and ${internalCount} internal`, 'README public/internal count');
-assertDocContains(readme, '[skills catalogue](docs/skills.md)', 'README skills catalogue link');
-assertDocContains(arch, `${publicRiteCount} public \`rite-*\` skills (${total} total)`, 'architecture surface count');
-assertDocContains(docsFlow, `: ${publicCount} skills`, 'flow public count');
-assertDocContains(docsFlow, `: ${internalCount} skills`, 'flow internal count');
-assertPublicSkillLinks(docsSkills, 'skills catalogue');
-assertPublicSkillLinks(docsCommandMap, 'command map');
-assertPublicSkillMentions(docsFlow, 'flow namespace');
-assertPublicSkillMentions(arch, 'architecture surface');
-
-console.log(`skills total: ${total}`);
-console.log(`public skills: ${publicCount}`);
-console.log(`public rite-* skills: ${publicRiteCount}`);
-console.log(`internal skills: ${internalCount}`);
-console.log(`model-invoked devrites-* specialists: ${modelInvokedInternalCount}`);
-
-if (failures) {
-  console.error(`skills-inventory: ${failures} failure(s)`);
-  process.exit(1);
-}
-console.log('skills-inventory: PASS');

package/scripts/supply-chain-iocs.json

@@ -1,11 +0,0 @@
-{
-  "_comment": "Bundled supply-chain indicators-of-compromise: documented malicious npm releases. This offline dataset is the always-available advisory source the scanner checks against, so CI is deterministic and needs no network. Extend it as new incidents are confirmed; keep each entry sourced.",
-  "iocs": [
-    {"name": "event-stream", "versions": ["3.3.6"], "note": "pulled in malicious flatmap-stream (bitcoin-wallet stealer)", "source": "GHSA-mh6f-8j2x-4483 (2018)"},
-    {"name": "flatmap-stream", "versions": ["0.1.1"], "note": "malicious payload targeting Copay bitcoin wallets", "source": "npm advisory (2018)"},
-    {"name": "ua-parser-js", "versions": ["0.7.29", "0.8.0", "1.0.0"], "note": "account takeover shipped a crypto-miner + password stealer", "source": "CVE-2021-41265 / GHSA-pjwm-rvh2-c87w (Oct 2021)"},
-    {"name": "coa", "versions": ["2.0.3", "2.0.4", "2.1.1", "2.1.3", "3.0.1", "3.1.3"], "note": "maintainer-account compromise shipped malware", "source": "GHSA-73qr-pfmq-6rp8 (Nov 2021)"},
-    {"name": "rc", "versions": ["1.2.9", "1.3.9", "2.3.9"], "note": "maintainer-account compromise shipped malware", "source": "GHSA-g2q5-5433-rhrf (Nov 2021)"},
-    {"name": "node-ipc", "versions": ["10.1.1", "10.1.2", "11.0.0"], "note": "protestware that wiped files based on geolocation", "source": "CVE-2022-23812 (Mar 2022)"}
-  ]
-}

package/scripts/sync-version.sh

@@ -1,54 +0,0 @@
-#!/usr/bin/env bash
-# Sync the semantic-release-determined version into package.json and the README
-# status line so the published version stays in step with the released tag.
-#
-# Usage: sync-version.sh <version>
-set -euo pipefail
-
-VERSION="${1:-}"
-if [[ -z "$VERSION" ]]; then
-  echo "usage: sync-version.sh <version>" >&2
-  exit 1
-fi
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$ROOT"
-
-echo "Syncing version ${VERSION} across DevRites manifests"
-
-node - "$VERSION" <<'NODE'
-const fs = require('fs');
-const path = require('path');
-const version = process.argv[2];
-
-const updates = [
-  { file: 'package.json',                       set: (j) => { j.version = version; } },
-];
-
-for (const u of updates) {
-  const p = path.resolve(u.file);
-  const data = JSON.parse(fs.readFileSync(p, 'utf8'));
-  u.set(data);
-  fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n');
-  console.log(`  → ${u.file}`);
-}
-
-// Update README status line so the published version shows on the repo
-// landing page. Matches the previous status block (single- or two-line form)
-// and rewrites it to a one-liner pointing at the new tag.
-const readmePath = path.resolve('README.md');
-const readme = fs.readFileSync(readmePath, 'utf8');
-const statusLine =
-  `**Status:** [\`v${version}\`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v${version}): ` +
-  "see [`CHANGELOG.md`](CHANGELOG.md) for release notes.";
-const re = /\*\*Status:\*\*[^\n]*(?:\n(?!\n)[^\n]*)*/;
-if (re.test(readme)) {
-  const updated = readme.replace(re, statusLine);
-  if (updated !== readme) {
-    fs.writeFileSync(readmePath, updated);
-    console.log('  → README.md');
-  }
-} else {
-  console.warn('  ! README.md status line not found: skipping');
-}
-NODE