dvalincode

Dvalin is the independent security runtime between code generation and merge. Humans, coding agents, and CI call the same versioned contract for discovery, remediation, and verification; Dvalin normalizes scanner evidence, applies a baseline-aware gate, persists the security workflow, and independently verifies a repair before publication. Its built-in coding capability is a remediation executor—not the trust boundary and not an attempt to compete with every general-purpose coding agent.

Dvalin can run independently, compete in overlapping application-security workflows, or interoperate with specialist systems such as Codex Security. Codex Security's portable SARIF export can become local Dvalin remediation cases and pass through the same release gate as every other human or agent. Dvalin differentiates through a no-account deterministic baseline, an open multi-engine scanner fleet, agent-neutral interfaces, local operation, and policy-bound audit evidence. We adopt strong workflow ideas where they improve user outcomes while keeping both products optional. See the security-agent strategy.

⏱️ 30 seconds, no install, no API key

npx dvalincode security scan .
# After installing the package: dvalin scan .

That is the whole thing. It runs the built-in rules for injection, hardcoded secrets, XSS, eval, and unsafe shell use against the current directory and prints what it found. No account, no model, no config, no code leaves your machine. The default policy runs only Dvalin Built-in, so the first scan always works. Add optional engines explicitly, or inspect their fixed install commands:

dvalin scanners list
dvalin scanners install semgrep       # review the command
dvalin scanners install semgrep --yes # execute it under Dvalin policy

For an incremental “no new high-risk findings” gate, commit the policy and baseline with the repository:

dvalin init
dvalin baseline
dvalin scan

This creates dvalin.security.json and .dvalin/baseline.json. Suppressions require a reason and may have an owner and expiry date. Scan output is a versioned envelope with a deterministic gate result and a resumable workflow ID.

Or put it on every pull request — nothing to install at all

# .github/workflows/security.yml
permissions:
  contents: read
  security-events: write
steps:
  - uses: actions/checkout@v5
  - uses: arthurpanhku/dvalincode@v0.17.0
    with:
      fail-on: high

Findings land inline on the pull request diff and in your Security tab. No API key, no secrets, no model — the scan is deterministic and local to the runner. Full example →

Or let your agent call it

If an agent is writing the code, something other than that agent has to check it. DvalinCode is an MCP server, so any agent that speaks MCP can:

claude mcp add dvalin -- npx -y dvalincode mcp-serve --workspace .

dvalin_scan never runs a model or edits the target workspace. It records a small local workflow so an agent can retrieve one finding by fingerprint and request an independent re-scan through dvalin_get_finding and dvalin_verify_findings. Responses include MCP structuredContent; scanner readiness is available through dvalin_list_scanners. The same server exposes dvalin_run_task as an optional implementation helper, plus session and audit evidence tools.

Verified end to end with both Claude Code and Codex driving a real tool call against the published package, not only completing a handshake. Agent integrations →

Or interoperate with Codex Security

Codex Security can export a completed, sealed scan as SARIF. Import that portable projection without coupling Dvalin to Codex Security's private state directory:

DVALIN_CODEX_SCAN_DIR=/tmp/codex-security-results
npx @openai/codex-security scan . --output-dir "$DVALIN_CODEX_SCAN_DIR"
npx @openai/codex-security export "$DVALIN_CODEX_SCAN_DIR" \
  --export-format sarif --source-root "$PWD" --output /tmp/codex-security.sarif

dvalin import /tmp/codex-security.sarif .
dvalin scan . --fail-on high

The import creates stable Dvalin remediation cases; --no-persist validates the handoff without changing the backlog. Keep Codex Security's original manifest, findings, and coverage artifacts together—Dvalin imports the SARIF finding projection but does not rewrite its sealed bundle or reinterpret its coverage. Integration guide →

Then let it fix what it found

dvalincode dvalin . --fix --verify --draft-pr

This step does use a model — your model, any OpenAI-compatible endpoint. It prepares focused repairs in an isolated worktree, runs your tests, and requires a clean re-scan before anything can proceed to a draft PR. It never auto-merges, and a clean scan is never treated as proof that the code is safe.

This animation is made from the real application, not a mock. The input is an Apache-2.0-licensed example adapted from OWASP NodeGoat, whose contribution route evaluated user-controlled text.

🛡️ What that run actually did

Dvalin turns open-source scanner evidence into a controlled scan → fix → test → re-scan → draft-PR workflow. Here is the run in the animation above, measured:

The scanning and hardening control plane uses open-source components:

• Semgrep CE and its community rules for semantic SAST.
• Trivy for filesystem vulnerabilities, secrets, and misconfiguration.
• OSV-Scanner with the open OSV database for dependency vulnerabilities.
• DvalinCode's MIT-licensed built-in rules, remediation orchestration, test and re-scan gates, plus SARIF 2.1 import for other compatible scanners.

The scanners find and rank evidence. The configured model proposes source changes; DvalinCode constrains that work, records the diff, runs project tests, re-scans the changed tree, and keeps PR publication explicit. It does not auto-merge and it does not claim that a clean scan proves the absence of bugs. Choose an open-weight model through Ollama if the repair-proposal step must also stay fully local and open; hosted model licensing depends on the provider.

You can still prove what the agent did after the fact:

dvalincode report verify    # re-derive the hash chain of the last run's audit log

🏛️ And it survives a security review

That last command is the part that matters once more than one person depends on this. DvalinCode is a full coding agent — terminal, web GUI, and desktop app — built so that an organization, not the developer, bounds what it may do: a policy file constrains modes, commands, paths, tools, and models; every run is hash-chained into a tamper-evident audit log; nothing reaches a provider that the egress guard did not allow. A repo policy can only ever narrow the machine-level one.

If you are the person who has to approve this class of tool, start at APPROVABILITY-PLAN.md and the Evidence Pack that every release ships of itself.