From plan to proof

Dino now accounts for the full verification run: what it planned, what ran, what passed, what failed, what could not be verified, and the canonical evidence behind the verdict.

A large part of the verification engine was rebuilt to make that statement true.

Install or upgrade with curl -fsSL https://usedino.dev/install.sh | sh, which installs the new standalone binary on macOS and Linux. Homebrew, npm, Windows and pinned versions: usedino.dev/docs/install.

The work was tagged as 1.1.0 through 1.1.2 on the way here: 1.1.0 and 1.1.1 never reached npm, and 1.1.2 was superseded the same afternoon. 1.1.3 is the release that carries all of it.

Plan before execution

Before Dino sends a request, it establishes the work it intends to perform. The plan is deterministic: the same API, configuration, and safety policy produce the same set of verification units with stable identities.

The engine owns the plan, scheduling, safety boundaries, execution evidence, and final accounting. Individual verification tools execute bounded work instead of each inventing its own definition of complete.

That boundary matters because a verdict is only credible when you can name its denominator. Dino can now answer exactly what it intended to verify, not just report the requests that happened to finish.

Couldn't test is not passed

A timeout is not a pass. An unreachable target is not a pass. A missing credential is not a pass. A request withheld by the safety policy is not a pass. Unsupported or inconclusive work does not disappear into a clean result.

If Dino could not verify it, the result says so.

Every planned unit resolves as passed, failed, or explicitly not tested for a reason. The reason stays attached to the unit, so an incomplete run cannot quietly look complete. Partial coverage remains partial, and health is withheld when the evidence is not strong enough to support it.

This also makes failure less theatrical and more useful. An unreachable API is represented as untested work, not fabricated findings. A protected write that Dino refuses to send is withheld, not scored. The report tells you what happened without pretending the engine learned something it did not.

One canonical result

The run now resolves into one versioned DinoResult. It has one deterministic serialized representation, one canonical byte sequence, and one SHA-256 digest. Terminal output, JSON, runner payloads, and downstream views derive from that result instead of maintaining loosely synchronized versions of the truth.

Same run. One source of truth.

Runners can sign those exact canonical bytes. Dino pins the expected signer identity, and for a cloud scan, dino verify independently checks that the result and attestation match. No second score, no reinterpretation: just verification of the same artifact.

Built for agents, runnable anywhere

dino skill prints or installs a version-matched agent skill. The loop is direct: change, run dino scan, read the verdict, fix, and verify again. When information is missing, headless flows return a structured ask_user action that explains what is needed and how to resume without soliciting secret values. dino schema exposes commands, flags, effects, and exit behavior as an offline clispec contract, so an agent does not have to scrape help text or guess.

Dino 1.1.3 also ships as six standalone binaries: Linux x64, Linux x64 baseline, Linux ARM64, macOS Intel, macOS Apple Silicon, and Windows x64. They ship alongside npm with SHA256SUMS and Sigstore bundles for checking the downloads.

The result is a verification runtime that can be driven by coding agents and run almost anywhere, while keeping the standard that matters most: every verdict traces back to the work Dino planned, the work it actually performed, and the evidence it can prove.