- Extract writeJSONResult() to replace 5 identical write+silent-error trailers
- Replace local isRepoDirty() with existing git.IsDirty() (8 call sites)
- Use defer for suppressUIToDevnull restore instead of manual calls at each
return site in install.go and update.go (prevents stdout leak on new paths)
- Fix ResolvePolicy always filling EnabledAnalyzers, which broke the
nil-means-all contract for ForPolicy; add EffectiveAnalyzers() for display
- Simplify collectOutputJSON double map allocation
- Remove unnecessary string conversion in writeJSONError
When no explicit analyzer filter was configured, status --json reported
an empty analyzers array. Now ResolvePolicy backfills the full list of
built-in analyzer IDs so the JSON output reflects what actually runs.
Add Registry.IDs() helper with deduplication (markdownLinkAnalyzer and
staticAnalyzer share the "static" ID).
Detect inline API keys, tokens, and passwords in skill files via 10 new
hardcoded-secret-* rules (HIGH severity): Google API keys, AWS access
keys, GitHub PATs (classic + fine-grained), Slack tokens, OpenAI keys,
Anthropic keys, Stripe keys, PEM private key blocks, and generic
api_key/password assignments.
Closes a gap where GitHub Secret Scanning caught a Google API key in a
skill file but our audit engine missed it entirely.
Add metadataAnalyzer (skill scope) that cross-references SKILL.md
metadata against the actual git source from .skillshare-meta.json:
- publisher-mismatch (HIGH): description claims an org but repo owner
differs (e.g. "from Acme Corp" but sourced from evil-fork)
- authority-language (MEDIUM): uses "official"/"verified" language but
source is not a well-known organization
Both rules are disable-able via audit-rules.yaml. The analyzer reads
meta from disk (zero API signature changes) and avoids import cycles
by defining its own minimal metaJSON struct.
Labels use dim style while values use bold semantic colors, making
counts visually prominent. Threat category breakdown now colors each
category independently (injection=red, exfiltration=orange, etc.)
instead of uniform yellow, so users can distinguish threat types at
a glance.
Surface per-category finding counts (e.g., injection:3 exfiltration:2)
in CLI summary, TUI footer, markdown report, JSON output, and web API.
Adds Result.CountByCategory(), formatCategoryBreakdown() with compact
mode for TUI, and byCategory field to all audit summary structs.
Previously the Phase 2 finding fields (ruleId, analyzer, category,
confidence, fingerprint) were only emitted in JSON and SARIF output.
This propagates them to CLI text, TUI detail panel, Markdown reports,
Server API responses, and the React frontend — each channel showing
the subset most useful for its audience.
- Server API: all 5 fields (omitempty) in auditFindingResponse
- CLI text: dim [ruleID / analyzer] line between severity and snippet
- TUI: cyan ruleID / analyzer / category line + search index
- Markdown: Rule ID and Category table columns
- Frontend: ruleId · analyzer · category dim metadata line
- Make DefaultRegistry() a singleton (stateless analyzers, safe to share)
- Consolidate duplicate ANSI regex into ui.StripANSI(); broaden pattern
to match all CSI sequences ([a-zA-Z] terminator, not just 'm')
- Extract shared policyProfileLabel/policyDedupeLabel/policyAnalyzersLabel
helpers; unify formatPolicyLine and formatPolicyLineFromPolicy
- Remove redundant applyPolicyToSummary calls inside auditInstalled and
auditFiltered (cmdAudit already applies it centrally)
- Fix double isMarkdown check in scanSkillImpl walk loop
- Convert variadic ...*Registry to regular *Registry parameter across
scanSkillImpl, ParallelScan, scanSkillPath, and scanPathTarget
- Pre-compute registry.Has() before walk loop to avoid per-file O(n) scan
Introduce pluggable analyzer architecture for audit scanning:
- Analyzer interface with ID/Scope/Analyze contract
- AnalyzeContext union struct carrying inputs for file/skill/bundle scopes
- 7 analyzer wrappers: static, dataflow, tier, integrity, structure,
markdownLink, cross-skill
- Registry with DefaultRegistry(), ForPolicy() filtering, and
scope-based accessors (FileAnalyzers/SkillAnalyzers/BundleAnalyzers)
- Policy.EnabledAnalyzers allowlist (nil = all enabled, backward compat)
- scanSkillImpl refactored to use registry gates for file-scope and
iterator loop for skill-scope analyzers
- ScanSkillFiltered / ScanSkillFilteredForProject public APIs
All existing tests, integration tests, and 60/60 red team assertions pass.
Duplicate findings (same pattern+file+line+snippet) are noise.
Global deduplication is now the default for all profiles.
Use --dedupe legacy to opt back into the old behavior.
config.Load() normalized empty block_threshold to "CRITICAL", preventing
ResolvePolicy from applying profile-based thresholds (e.g. strict → HIGH).
Change: normalizeAuditBlockThreshold("") now returns "" instead of "CRITICAL".
All downstream callers (install, update, server) already use
audit.NormalizeThreshold() which handles empty → CRITICAL independently.
Also adds 4 integration tests for --profile, --dedupe, and config-based
profile resolution. Includes gofmt formatting fixes.
- CLI: add --profile and --dedupe flags to audit command with help text
- Pipeline: apply DeduplicateGlobal when dedupe_mode=global, recount
summary after dedup via recountSummary helper
- Output: add policyProfile/policyDedupe to JSON summary and Markdown
header (non-default profiles only)
- Server: add auditPolicy() method, populate policy fields in API
responses for both all-skills and single-skill audit endpoints
Remove rules that generated excessive false positives:
- source-repository-link (HIGH): legitimate docs links flagged too often;
external-link (LOW) already covers the same URLs
- env-access (MEDIUM): process.env references are ubiquitous in JS skills
- obfuscation-1 (long base64): caught README badges and binary data
Recalibrate credential-access severity levels to reduce alert fatigue:
- etc-passwd/sudoers: HIGH → MEDIUM (read-only system files, not secrets)
- shell-history, openvpn: MEDIUM → LOW (low-impact reconnaissance)
- auth-log: LOW → INFO (log files, no direct credential exposure)
Update all affected unit tests, integration tests, red team assertions,
skill references, and website docs to match.
P1: mergeYAMLRules Phase 2 used full-object replacement for overlays
without Enabled set, causing severity-only entries ({id, severity}) to
wipe regex/pattern/message from the base rule. compileRules then failed
with "empty regex". Now uses field-level merge: only entries with Regex
do full replacement; otherwise Enabled and Severity are patched
individually.
P2: TogglePattern enable only removed pattern-level disable entries,
leaving ID-level {id: "x", enabled: false} untouched — both builtin
and custom rules. Now clearDisableForPattern matches by builtin ID set
OR by r.Pattern == pattern, covering custom rules in the same group.
Implement a full bubbletea TUI with two navigation levels:
- Level 1 (patterns): shows pattern categories with rule count, disabled
count, and max severity; press Enter to drill in, d to toggle pattern
- Level 2 (rules): shows individual rules with severity and status; detail
panel shows full ID, regex, message, source; d toggles single rule,
D toggles entire pattern, Esc returns to Level 1
Also adds audit.ResetGlobalCache() to clear cached rules after YAML
mutations, enabling live-reload within the TUI session.
Introduce rules_list.go with exported types and functions for listing
all audit rules with their enable/disable status and source layer
(builtin/global/project). Includes PatternSummary for grouped stats
and UniquePatterns for pattern enumeration. Disabled rules appear in
listings with Enabled=false so UIs can display toggle state.
Extend mergeYAMLRules to handle overlay entries that specify a pattern
but no id — these apply to all base rules sharing that pattern name.
Processing uses two phases:
1. Pattern-level overlays (bulk disable / severity override)
2. ID-level overlays (can override pattern-level, e.g. re-enable
an individual rule after a pattern-level disable)
An explicit enabled:true in an id-level overlay clears a disabled flag
set by a pattern-level overlay.
Strengthen the audit engine with new detection capabilities inspired by
skilld's sanitization research and Snyk ToxicSkills findings:
- Expand prompt-injection-1 to detect OVERRIDE:/IGNORE:/ADMIN:/ROOT: prefixes
- Add prompt-injection-2: agent directive XML tags (<system>, <instructions>, etc.)
- Add prompt-injection-3: DEVELOPER MODE, JAILBREAK, DAN MODE directives
- Add data-exfiltration-2: external images with query params (exfil vector)
- Add credential-access-3/4: /etc/shadow, /etc/passwd and related system files
- Add TierInterpreter (T6): classify python/node/ruby/perl/lua/php as
Turing-complete runtimes separate from build tools
- Add tier-interpreter and tier-interpreter-network combination findings
- Add cross-skill-cred-interpreter rule for credential × interpreter pairs
- Update docs to reflect 38 rules and new tier/cross-skill patterns
Replace nested pair-checking loop with set-based approach:
- Single pass builds capability sets (credReaders, netSenders, etc.)
- Each rule checks non-empty sets → one summary finding per rule
- 100k skills: ~15ms vs ~30s+ (benchmark included)
- Use DiscoverSourceSkillsLite for audit discovery (skip frontmatter)
- Use patternDataflowTaint constant instead of raw string
P1: SARIF startLine=0 is invalid per spec — GitHub Code Scanning rejects
it. Use *sarifRegion pointer with omitempty so findings without line
numbers (tier, cross-skill, analyzability, content-integrity) produce
valid SARIF output without a region field.
P2: Server audit endpoint (handleAuditAll) now calls CrossSkillAnalysis
after collecting results, matching CLI behavior. Previously the API
returned only per-skill findings without cross-skill interaction checks.
Also guard fmt.Println() in auditFiltered() for structured output
consistency (same fix as auditInstalled in previous commit).
- Add --format markdown for self-contained audit reports (GitHub Issues/PRs)
- Simplify pterm box rendering: replace DefaultBox with separator-line style
- Remove unused SkillBox, SummaryBox, SkillDisplay, wrapText helpers
- Color Box titles cyan (consistent with HeaderBox)
- Add breathing room: blank lines around progress bar and after summary
- Show "skillshare audit (project)" header title in project mode
- Append elapsed time to cross-skill synthetic results to fix slice mismatch
Two individually harmless skills can form an attack chain when installed
together (e.g., one reads credentials, another has network access).
After per-skill scans complete, the audit engine now extracts a capability
profile from each Result and checks for dangerous cross-skill combinations:
- cross-skill-exfiltration (HIGH): credential reader + network sender
- cross-skill-privilege-network (MEDIUM): privilege commands + network
- cross-skill-stealth (HIGH): stealth skill alongside high-risk skill
Rules only fire for complementary pairs (each skill lacks the other's
capability) to avoid duplicating per-skill findings. Results appear as
synthetic "_cross-skill" entry in all output formats (text, JSON, SARIF, TUI).
Adds forward taint propagation analysis that detects multi-line data
exfiltration patterns where sensitive data flows through variables or
temp files before reaching a network sink.
Tracks three taint sources: credential file reads (~/.ssh, .env, etc.),
sensitive env var references ($TOKEN, $API_KEY, etc.), and command
substitution outputs. Propagates taint through variable assignments,
pipe chains, and temp file redirections. Generates HIGH-severity
dataflow-taint findings when tainted data reaches network commands.
- Add ScanShellDataflow for shell scripts and ScanMarkdownDataflow
for fenced code blocks in markdown
- Add DeduplicateDataflow to avoid duplicate findings with existing
per-line pattern rules
- Integrate into scanSkillImpl and ScanFileWithRules scan paths
- Can be disabled via audit-rules.yaml (id: dataflow-taint)
Classify every shell command in skill files into 6 behavioral tiers
(read-only, mutating, destructive, network, privilege, stealth) as an
orthogonal dimension to pattern-based severity. This lets audit report
"what kind of actions" a skill performs, not just "which known patterns
it matches."
- Add tier engine with 80+ command mappings and stealth regex patterns
- Detect tiers in scripts and Markdown fenced code blocks separately
- Generate combination findings: T2+T3→HIGH, T5→CRITICAL, T3>5→MEDIUM
- Display tier profile in CLI text, TUI detail panel, and JSON/API output
- Exclude .skillshare-meta.json from totalBytes to fix analyzability ratio
- Document tier definitions, profile output, and combination findings
Analyzability score measures what percentage of a skill's content is
auditable plaintext vs binary/non-scannable. Surfaces in CLI text
output, JSON, SARIF, and Web UI API responses.
- Add TotalBytes, AuditableBytes, Analyzability fields to audit.Result
- Emit INFO-level low-analyzability finding when score < 70%
- Show "Auditable: X%" in per-skill and summary text output
- Expose analyzability in server API (auditResultResponse + auditSummary)
- Add .pre-commit-hooks.yaml for pre-commit framework integration
- Add pre-commit hook recipe docs and audit.md cross-references
Add ToSARIF() function that converts audit Results into SARIF 2.1.0
format for CI/CD integration (GitHub Code Scanning, etc.).
- 12 structs modeling the SARIF schema subset we need
- Severity mapping: CRITICAL/HIGH→error, MEDIUM→warning, LOW/INFO→note
- Rule deduplication by pattern (first occurrence wins)
- SARIFOptions for tool version and base URI
- 4 test cases: empty, findings, severity mapping, JSON round-trip
- Extract shared applyDetailScroll into tui_helpers.go (was duplicated
across diff_tui.go, log_tui.go, audit_tui.go)
- Create utils.FileHash and utils.FileHashFormatted, replacing private
copies in install/meta.go and audit/audit.go
- Export install.MetaFileName constant, use from diff_file.go
- Replace double SHA-256 in fileContentsEqual with streaming byte compare
for early-exit efficiency
- Add 1MB size cap to generateUnifiedDiff to prevent performance issues
- Move noTUI into diffRenderOpts struct, simplifying function signatures
- Fix non-TTY progress bar not incrementing for grouped skills in Phase 2
- Fix Unicode truncation in UpdateTitle using runewidth instead of len()
- Fix IP address regex missing end-of-line bare IPs (add $ anchor)
- Fix gofmt alignment in updateTarget struct comments
- Extract sliceHasName[T] generic helper to deduplicate universal detection
- Add nil meta defensive warning with skipped count in grouped updates
- Replace hand-rolled contains/containsStr with strings.Contains in tests
- Add red team TC-20b for inline code fetch-with-pipe detection
Add 5 new audit rules (31 → 36 total) to close detection gaps:
- fetch-with-pipe (HIGH ×3): curl/wget piped to sh/bash/python/node/etc.
Previously only double-pipe (||) was caught by shell-chain; single
pipe (|) to interpreters — the classic RCE vector — was undetected.
- ip-address-url (MEDIUM): URLs with raw IP addresses that bypass DNS
security controls; excludes RFC 1918 and loopback ranges.
- data-uri (HIGH): data: URIs in markdown links that may embed
executable content.
fetch-with-pipe is suppressed inside markdown code fences (tutorial
context), matching existing behavior for destructive-commands et al.
Includes unit tests (25 cases), code fence suppression test, red team
TC-18 through TC-21, and audit.md documentation updates.
- Add bubbletea TUI for multi-skill audit results (side-by-side layout
with skill list + detail panel, severity sorting, fuzzy filter)
- Add progress bar during parallel scan via onDone callback
- Add --quiet/-q flag to suppress clean skill lines
- Add --yes/-y flag to skip large-scan confirmation prompt (>1000 skills)
- Add --no-tui flag to force plain text output
- Scale parallel workers to NumCPU (bounded 2–32) instead of fixed 8
- Use file cache in content-integrity check to avoid redundant disk reads
- Replace line splitting with streaming scan (avoid full []string alloc)
- Remove snippet truncation (preserve full trimmed line)
- Differentiate LOW (bright blue) and INFO (medium gray) severity colors
- Centralize log TUI color styles into `lc` struct
- Export DisplayWidth and add BoxWithMinWidth/HeaderBoxWithMinWidth for
aligned header + summary box widths
- Update docs with TUI controls, new flags, and CI/CD auto-skip behavior
InstallTrackedRepo and updateTrackedRepo had no security audit,
allowing --track to bypass all supply-chain checks. This adds
auditTrackedRepo (removes repo on block for fresh installs) and
auditTrackedRepoUpdate (git reset rollback for updates), plus
input validation, testable removeAll, and hardened error handling
across audit/install/uninstall paths.
Replace simple regex-based markdown link extraction with a full
structural parser that handles inline links with titles, autolinks,
reference-style links, HTML anchors, multiline links, and correctly
skips code fences, inline code spans, and image links.
This ensures external-link and source-repository-link audit rules
match all Markdown link syntax variants while avoiding false positives
from code examples and images.
- P1: Batch/all update now returns non-zero when repos are blocked by
security audit (fail-closed for CI pipelines)
- P2: Pass --skip-audit to regular skill update via InstallOptions
- P2: Add path containment check in content integrity to prevent
directory traversal via crafted file_hashes keys
- P3: Switch git diff parsing to NUL-delimited (-z) for safe handling
of special filenames
Pin sha256 file hashes in .skillshare-meta.json during install/update.
Audit now detects content-tampered (MEDIUM), content-missing (LOW),
and content-unexpected (LOW) findings. Backward-compatible: skills
without file_hashes in meta are silently skipped.
Supply-chain hardening Phase 1:
- Add source-repository-link-0 rule (HIGH) to detect [source repository](url) patterns
- Exclude source-repo labels from external-link-0 to prevent double-reporting
- Introduce risk floor: RiskLabel = max(score-label, severity-floor) so a
single HIGH finding produces "high" risk instead of "low"
- Apply severity floor to CLI summary, server API summary, and per-result risk
Deduplicate bounded-concurrency worker pool that was repeated in
auditInstalled(), auditFiltered(), and handleAuditAll(). The new
audit.ParallelScan() centralises the pattern with index-aligned
results, reducing ~90 lines to a single reusable function.