Violin v3.2.1

Fixed

• Prevented phase validation failures from mutating PTT state.
• Made targeted hypothesis validation fail closed when scope is missing or malformed.
• Repaired Windows smoke coverage for bootstrap, scope, and target resolution.

Changed

• Removed stale facades, dead helpers, unused telemetry, and the obsolete search-exploit CLI path.
• Removed the profile-level model and provider selection; Hermes now uses the operator's configuration.
• Simplified guard imports and internal call paths without changing the registered Hermes tool surface.
• Reworked the README and operator documentation around the current runtime, release gates, and benchmark limits.

Violin v3.2.0

Core Architecture & Tool Consolidation

• 11 Core Tools: Consolidated registered tool surface (17 -> 11 tools) by pruning 6 thin-proxy wrappers (violin_httpx, violin_nuclei, violin_ffuf, violin_listener, violin_search_exploit, violin_check_command) in favor of direct, unified violin_exec.
• Subpackage Architecture: Modularized plugins/violin_guard into direct subpackages (core, gates, engine, handlers) with explicit __all__ exports and clean dependency isolation.

Skills & Methodology Framework

• 7 Domain Skills: Reorganized and routed pentest methodology across 7 distinct skill packages (pentest, web-app, identity-auth, api-testing, business-logic, misconfig, llm-security).
• Coverage Matrix: Automated bootstrap generation of coverage matrix from scope obligations with strict schema validation.
• WSTG Methodology Gates: Enforced methodology disposition checks before phase transitions and standardized canonical FIND-NNN.md schemas and templates.
• Evidence & Discipline: Documented two-step skill binding mechanics, evidence redaction patterns, and decisive raw response byte capture.

Performance, Ergonomics & Concurrency Safety

• AST Scope & Backend Caching: LRU and TTL caching for AST scope parsing (bashlex + yarl + netaddr) and container probing.
• Adaptive Poll Throttling: Jittered backoff during long-running execution checks to eliminate CPU spin.
• Robust Hypothesis Parsing: Tolerates variable heading depths (#, ##, ###, bare) and parenthetical/confidence annotations without dropping validated records.
• Process Safety: Removed global environment mutations (os.environ["ENG_DIR"]), eliminated dynamic module inspection, and added advisory filelock protection on state/feedback logs.

Code Quality & Maintenance

• Fix relative-path resolution in abandon_execution history tracking (.resolve()).
• Release sync-credit reservations via try/finally on mid-burst process kill.
• Validate listener port presence before integer coercion.
• Normalize command history with splitlines() (handles legacy CR line breaks).
• Use hashlib.file_digest() for single-pass SHA-256 in receipt_integrity.py.
• Automated GitHub release and tagging workflow (.github/workflows/release.yml) on push to master.

Violin v3.1.0

Benchmark & Evaluation Framework

• Automated Benchmark Runner (benchmark/run.py): End-to-end evaluation harness supporting automated multi-turn execution, OpenRouter provider integration, Docker containerization, and soft-timeout closeout handling.
• Evidence-Gated Scorer & Proof Evaluator (benchmark/score.py, proof.py): Unified Technical-Proof Recall scoring with require/require_any sentinels, absence-proof verification for rate-limiting challenges, decisive payload matching, and reverse hypothesis-to-finding validation.
• Automated AI Judge & Indexer (benchmark/ai_judge.py, indexer.py): Heuristic proof auditing, quality verification, and bounded artifact indexing for large engagements.
• Calibration Suite: 100% pass baseline on the 20-challenge Escape Duck Store reference suite (--calibrate known-good and known-bad).
• Canonical Closeout Synthesis: generate-closeout derives findings.yaml and executive report.md exclusively from verified FIND-NNN.md artifacts.

Guard & Scope Policy

• AST Scope Parser Rewrite: targets.py scope checks rewritten using bashlex AST tokenization and yarl URL parsing, eliminating benign-command false positives while independently verifying pipelines, subshells, and compound commands.
• Actionable Remediation Guidance: Denials explicitly provide exact typed tool signatures and parameter templates (violin_record_hypothesis, violin_record_ptt, violin_exec) to eliminate turn-budget waste across models.
• Record-As-You-Go Recency Gates: Prevents deferred state writes, auto-logs friction events at block time, and resolves hypothesis disposition deadlocks.
• Receipt Integrity & Parser Hardening: Fail-closed state parsers, receipt integrity verifier, and single-approval bounded command batches (violin_exec_burst).

Methodology & Playbooks

• Consolidated 31 Playbooks, 17 References, 12 Templates: Cleanly routed across the pentest orchestrator, web-attacks (5 playbooks), and access-control (3 playbooks) skills with single-source vulnerability routing.
• Parallel Reconnaissance: Mandated multi-agent parallel discovery patterns in /goal prompts and SKILL.md §3 for high-throughput asset mapping.
• Small Model Grounding & Worked Examples: Added §7b worked tool-call parameter templates in SKILL.md to ensure seamless execution for open-weight models (Qwen 3.5/3.8, DeepSeek) without guard friction.
• Single-Step Win Formalization: Immediate hypothesis validation (Validated) coupled with atomic FIND-NNN.md evidence bundling upon decisive technical proof capture.

Violin v3.0.1

Release v3.0.1

• Aligned workflow instructions in .hermes.md, SKILL.md, and playbooks/recon.md with Hermes v3 runtime tool contracts.
• Added cross-cutting evidence & verification discipline guidance (
  eferences/evidence-and-verification-discipline.md).
• Added authorized flag-capture (FLAGS) mode for lab/CTF engagements (
  eferences/flags-mode.md, emplates/flag-capture-register.md).
• Enforced per-hypothesis discipline fields (Confidence, Timebox, Cheapest test, Kill criteria) and Decoy Trail logging.
• Fixed hypothesis board rewriter in plugins/violin_guard/hypotheses.py to preserve structural sections (## Observations, ## Decoy Trail, ## Research Log, ## Resolved Theories).
• Updated RecordHypothesisArgsModel in schemas.py to expose discipline fields in tool parameters.
• Standardized workspace AGENTS.md to follow industry AI developer guidance best practices.

Violin v3.0.0

Violin v3.0.0

• Made the Windows workflow smoke harness use the repository virtual-environment runtime when available, avoiding false failures from a dependency-free system Python.
• Made background execution restart-safe by recording PID creation times and deadlines, refusing to signal reused PIDs, recovering matching processes, and marking missing processes as lost; new pending batches now use collision-resistant UUIDs.
• Made burst execution atomic at admission: every command is preflighted before launch, required sync credit is reserved under one lock, and unused reservations are returned after partial batches.
• Fixed target extraction for dotted identifiers and direct /dev/tcp//dev/udp redirections, and prevented network-capable local-looking commands from bypassing execution accounting.
• Made interrupted skill preparation recoverable with expiring reservations and stale-owner protection; batch review now remains tied to the delivered execution receipt.
• Stabilized the core engagement workflow: domain/URL-only scopes now validate, runtime execution cannot substitute another scope file, PTT/review CLI contracts carry skill metadata, and review reuses the active delivered binding.
• Added receipt-backed skill routing, delivery, task binding, browser enforcement, Kali auto-backend selection, proof-based finding review, and semantic anti-stuck enforcement.
• Replaced marker-file authorization with two-turn skill preparation and receipt diagnostics; legacy markers can only infer a unique session ID during migration.
• Allowed direct host-local init-engagement --host bootstrapping, persisted runtime session identity before skill delivery, and blocked shell-indirection workarounds.
• Scoped skill cooldowns to Hermes model API requests so the next tool-loop continuation unlocks automatically, while batch review no longer replaces the active execution-skill binding.
• Migrated guard tool schemas and parameter validation to Pydantic v2.
• Replaced platform-specific process termination with cross-platform psutil process tree traversal and cleanup.
• Upgraded target IP/CIDR scope policy arithmetic to netaddr.IPSet and RFC 3986 URL parsing to yarl.
• Replaced shell regexes in terminal policy with bashlex AST tokenization and command parsing.

Violin v2.0.8

v2.0.8

• Expanded Duck Store benchmark challenges to 20 article-parity vulnerabilities matching Redpick's verified findings (7 critical, 9 high, 3 medium, 1 low across 7 categories)
• Renamed benchmark engagement prompt to engage.md and added post-engagement report.md prompt for automated scoring + report generation
• Ruff format fix

v2.0.7

• Added Duck Store benchmark harness: evidence-gated scorer with hypothesis-aware matching, proof-quality gates, and auditable output
• Fixed config.yaml with explicit model section (profiles don't inherit default model config)
• 8 scoring fixes from first benchmark run: PTT path, hypothesis parsing, word-boundary patterns, HTTP proof gates, compliance reporting, calibration mode, coverage vs quality split

Full changelog

Violin v2.0.6

Highlights

Violin v2.0.6 consolidates six verified patch releases focused on security hardening, guard correctness, and maintainability.

Security

• Upgraded pytest to 9.0.3 or later and locked pytest 9.1.1, addressing CVE-2025-71176 / GHSA-6w46-j5rx-g56g.
• Restricted GitHub Actions workflow tokens to read-only repository contents.
• Hardened compound raw-terminal command classification so target activity cannot be hidden behind pipelines, logical operators, semicolons, or newlines.
• Blocked callback and research endpoints when supplied as primary assessment targets.

Guard reliability

• Restored exact-repeat detection for receipt-backed execution history.
• Added unambiguous command-length metadata while retaining compatibility with existing history records.
• Made intentional exception fallbacks explicit and removed dead variables reported by CodeQL.

Verification

Every patch passed focused regression tests, Ruff lint and formatting checks, and the full python scripts\violin_guard.py check-release gate. The consolidated release passed lint, guard-check, and Violin CI in PR #24.

Issues #1, #2, and #3 were closed as completed through their individual patch PRs.

Full changelog: https://github.com/Strategic-Automation/violin/blob/v2.0.6/CHANGELOG.md
Compare: v2.0.0...v2.0.6

Violin v2.0.0

Violin v2.0.0

Violin v2.0.0 is a major release of the supervised Hermes penetration-testing profile. It introduces a Hermes-native guarded execution boundary, improves engagement continuity and auditability, and reorganises specialised testing guidance into routed skills.

Highlights

Hermes-native guarded execution

• Makes violin_exec, violin_exec_burst, and typed adapters the canonical path for target-touching commands.
• Supports any installed non-interactive Kali or Parrot CLI tool without a fragile binary allowlist.
• Adds guarded listener execution and asynchronous execution status and cancellation.
• Audits Hermes execute_code calls using engagement metadata, saved source, completion status, and SHA-256 evidence digests.
• Keeps raw-terminal detection as a best-effort safety boundary while enforcing scope through typed execution.

Stronger scope and target enforcement

• Requires an explicit primary target at the command boundary.
• Replaces regex-heavy target extraction with shell, URL, hostname, IP/CIDR, and MIME-aware parsing.
• Supports approved callback and public-research hosts without allowing them to become assessment targets.
• Improves handling of wildcard hosts, virtual hosts, URL and port-qualified targets, UNC-style paths, dotted filenames, and Bash /dev/tcp and /dev/udp endpoints.
• Keeps unknown or ambiguous target-like values reviewable instead of silently treating them as safe.

Phase-aware engagement workflow

• Adds violin_status diagnostics showing the active task, phase requirements, pending work, blockers, and recommended next actions.
• Introduces reviewed command windows:
  • 10 commands during reconnaissance and vulnerability research.
  • 20 commands during exploitation-heavy phases.
• Adds atomic violin_review_batch reconciliation for evidence review, optional finding creation, PTT progression, and batch-lock clearing.
• Removes the initial active-task deadlock while retaining fail-closed post-batch review.
• Raises the Hermes profile budget to 350 iterations for realistic engagement continuity.
• Removes message-count heartbeat locks while retaining phase-aware executed-command checks.

Evidence and findings

• Keeps command history executor-owned and engagement-local.
• Adds receipt-backed finding creation to prevent unsupported findings from being recorded.
• Creates engagement-local exploits/ and phase evidence directories.
• Directs local scripts and output away from host /tmp.
• Improves hypothesis parsing, canonicalises IDs such as H-001, and repairs malformed board content.
• Preserves scope, PTT, hypothesis, history, and pending-batch state across context compression.

Routed skills

• Keeps pentest as the engagement methodology and workflow orchestrator.
• Adds the web-attacks skill for injection and web-application testing.
• Adds the access-control skill for authentication and authorisation testing.
• Updates the nine-question scoping workflow.
• Synchronises the README, Hermes instructions, playbooks, templates, security policy, contribution guidance, and release metadata.

Reliability and maintainability

• Reorganises plugins/violin_guard/ into focused execution, state, target, history, phase, PTT, result, and service modules.
• Adds file locking for serialized state transitions and more reliable Windows concurrency.
• Improves isolated plugin imports, tool registration, manifest validation, and cross-platform smoke testing.
• Aligns the distribution, project, plugin, dependency lock, documentation, and tests with the v2.0.0 runtime surface.

Upgrade notes

• Requires Hermes Agent >=0.18.0.
• Requires Python >=3.11.
• Adds filelock>=3.13,<4 as a runtime dependency.
• Target-touching commands should use Violin’s typed execution tools.
• Raw terminal should be limited to host-local preparation and administration.
• Start Violin with hermes chat --skills pentest when supported.
• Existing engagements should confirm their scope, primary target, session marker, active PTT task, hypotheses, and pending batch before resuming.
• Web-attack and access-control playbooks are now loaded through their routed skills.

Validation

The release is validated through:

• Distribution and plugin version checks.
• Isolated Hermes-style plugin import.
• Registered tool-surface validation.
• Ruff linting and formatting.
• Full Python test suite across supported platforms.
• Skill and documentation consistency checks.
• Clean release diff validation.

For the complete change history, see CHANGELOG.md.

Violin v1.1.0

Violin v1.1.0 — Public Release

A supervised, agentic Hermes Agent pentest profile for authorised reconnaissance, exploit validation, and reporting. This release hardens the guard layer, adds multi-layer freshness gates, and ships a thorough README/docs accuracy pass so the public repo matches the code.

Highlights

• violin-guard plugin (Hermes plugin, not just a script) — registers typed guard tools (violin_check_command, violin_record_ptt, violin_record_history, violin_record_hypothesis, violin_exec, violin_sync_done, violin_heartbeat_done, violin_message_tick) that delegate to scripts/guard/ and enforce the skill-load, PTT, history, and hypothesis freshness gates. There is no way to bypass the gate.
• Freshness / drift guards — check-command (with --eng-dir) enforces PTT staleness, command-history duplicate detection, and hypothesis-board coverage per target. Omitting --eng-dir is blocked.
• Heartbeat gate — every 5 approved target commands (and every 10 messages via violin_message_tick) forces a re-read of SKILL.md + engagement-file review before the next command releases.
• Engagement bootstrap — init-engagement auto-creates a guard-clean engagement tree; self-healing --auto-repair rescues orphaned sync locks and resolves engagement dirs to a single absolute root.
• Doc accuracy pass — fixed repo links (Strategic-Automation), corrected plugin/toolset/template counts, aligned version metadata (distribution.yaml, SKILL.md) to 1.1.0, and removed a stray local working directory.

Guard capabilities

Subcommand	Purpose
validate-scope	Validate an engagement scope.yaml (exit 0 = approved)
check-command	Gate every target-touching command (0 allow / 1 block / 2 review)
check-bootstrap	Verify engagement bootstrap is complete before any target interaction
check-skill-loaded	Skill-load gate — marks SKILL.md read for the current work-block
init-engagement	Auto-create a complete, guard-clean engagement directory
record-ptt / record-history / record-hypothesis	Engagement artifact tracking (enforced)
sync-done / heartbeat-done / message-tick	Doc-sync and periodic-review gates
closeout	Tier close-out artifacts as hard gates
check-release	Validate release readiness (YAML, 31 playbooks, markdown refs)

Engagement workflow

1. SCOPING → 2. RECON → 3. VULN RESEARCH → 4. EXPLOITATION → 5. REPORTING → 6. RETROSPECTIVE — every phase gated by clarify approval + guard checks.

Contents

• 31 playbooks — 7 methodology (6 phase + 1 tools catalog) + 24 per-vulnerability-class (OWASP Top 10, OWASP API Top 10, LLM Top 10, and beyond)
• 8 references — methodology, standards, tool catalog, tool discovery, CVE APIs, Kali/Parrot paths, retrospective, coverage matrix
• 6 templates — PTT, hypothesis board, scope, report, methodology gates, transparency boilerplate
• 11 toolsets — 10 built-in Hermes toolsets + the violin_guard plugin toolset

Install

hermes profile install https://github.com/Strategic-Automation/violin
hermes -p violin

Notes

• Engagement workspaces (engagements/) and local promotion material (PROMOTION.md) are git-ignored and excluded from distribution — no client data, tokens, or credentials are committed.
• Safety policy and forbidden-behaviour rules are in SECURITY.md, skills/pentest/references/standards.md, and .hermes.md. Authorised testing only.

Violin v1.0.0

Violin v1.0.0 — Public Release

The supervised agentic Hermes pentest profile is now public.

What's inside

• 31 pentest playbooks covering OWASP Top 10, API security, auth bypass, cloud, and more
• 0 plugins — 100% Hermes built-in tools (browser, terminal, file, delegate, web)
• 8 reference docs (standards, scope template, recon methodology)
• Guardrails-first design — every engagement runs through mandatory authorisation + scope verification
• 2 CI workflows — guard-check + YAML lint on every push/PR
• Full community setup — issue templates, PR template, CONTRIBUTING, SECURITY policy

Safety model

Violin is a defensive, authorised-engagement-only profile. It refuses to act without verified written authorisation and a scoped target list. Built for red teams operating inside the rules of engagement.

Quick start

hermes profile install Strategic-Automation/violin

Links

• README: full playbook index, Mermaid architecture diagrams, and safety layers
• License: MIT