What changed.Why it matters.

Advisory predictions, static rules, demonstrated regressions, pre-existing failures, and incomplete checks retain distinct labels through scan reports and GitHub summaries. Observation-only contracts remain nonblocking.

The installed Vitest workflow checks immutable revisions, records actual assertions and failures, and requires matching test identity. Changed tests, setup problems, missing reports, and unsupported execution remain inconclusive.

Repository owners can select the stored claims a linked test actually exercises. AI plans and matching text no longer stand in for runtime coverage. Verifier changes become captured contract versions.

Reports retain verification coverage, omitted guards, engine configuration, and the actual comparison base. Guard-loading and evidence-persistence failures cannot silently produce a clean verification result.

Add reviewed historical cases and real tool observations, compare shared cases across configurations, test memory-enabled and memory-disabled reviews, and export JSON or spreadsheet-safe CSV. Version history, concurrent-save protection, and recoverable form drafts preserve the study.

On one public Zod change with two documented regression causes and one within-change negative control, both advisory-review variants identified one cause and missed the other. Memory did not improve detection in this single-run pilot. The reports, label-validation evidence, limitations, timings, and token usage are published; no competitor was run.

Measured comparisons read a separately reviewed public dataset. Saving a private study does not publish repository links or evidence. Missing measurements stay missing, and software test-suite results are reported separately from detection accuracy.

The verification and benchmark migration has been applied, including rollback-only tenant-isolation and revision checks. Verification and isolated public-label validation workflows are installed through protected pull-request checks.

Documentation covers the comparison lab, historical information boundaries, runtime prerequisites, supported execution, metric denominators, and publication. Regression and DOM tests cover verdict policies, evidence reports, metrics, private saves, CSV exports, and draft recovery.

Code reviews, verification planning, and evidence investigations now run on the upgraded engine to reason through changes and their surrounding repository context.

Historical-fix discovery, behavior-origin analysis, suggested fixes, and regression-test generation use the same upgraded engine.

Token and cost tracking now reflect the upgraded engine, including cached context and reasoning usage.

A collapsible dashboard sidebar and shared top bar provide consistent access to overview, repositories, scan history, teams, and settings.

Repository controls, branch comparisons, pull requests, scan evidence, and Production Sentinel screens share dark surfaces, stronger text contrast, and a 12px minimum text size.

Features, pricing, documentation, comparisons, security, and policy pages use consistent typography and navigation. Changelog is now accessible from the main navbar.

Login and account creation use focused GitHub sign-in forms with distinct repository-verification and behavior-memory visuals.

Apply criticality, enforcement, approval, GitHub merge-gate, waiver, and permission requirements across every shared repository in one versioned operation.

Switch an organization to restricted access and grant individual members read, contribute, or manage access for each repository.

Organization policy changes can leave affected Behavior Contracts pending until a different administrator reviews the new immutable contract versions.

Declare protected environments and whether deployment integrations should observe, require verified behavior, or require verification plus approval.

Policy versions, synchronized contract changes, access grants, actors, and resulting decisions are retained in the workspace audit history.

Capture the cause, resolution, permanent invariant, and a focused regression scenario directly from an open, acknowledged, or resolved production incident.

Approve a proposal to append its invariant and regression scenario to the source Behavior Guard as a new immutable Behavior Contract version.

Contract changes, version history, approver identity, and the incident-to-guard link are committed together so partial protection cannot be recorded.

Every proposal retains its incident snapshot, review status, resulting guard, and approved contract version for later investigation and compliance review.

Recent incidents now expose capture, review, approval, and dismissal controls beside the runtime evidence that created them.

Pricing buttons route new purchases into Stripe checkout and account for existing subscriptions when changing plans.

Billing controls handle upgrades, downgrades, cancellation, and resuming a subscription through dedicated account workflows.

Workspace owners can manage team subscriptions and seats from the shared workspace.

Connect a provider contract to API consumers, SDK dependencies, event consumers, and data-contract consumers across repositories shared with a workspace.

Provider scans classify every mapped dependency as preserved, at risk, violated, or inconclusive from the contract evidence produced for that revision.

At-risk, violated, and inconclusive dependencies become scan findings, so cross-repository impact contributes to the final ship verdict instead of living in a separate diagram.

Workspace scan reports show the affected consumer repository, relationship type, status, message, and evidence used for each downstream decision.

Dependency creation and removal use workspace roles, audit events, row-level security, and automatic cleanup when a repository is unshared.

Eligible runtime Behavior Guards execute against the base and head commits so ShipCheck can distinguish a confirmed regression from a preserved behavior, pre-existing failure, improvement, or inconclusive run.

Scan reports retain base and head status, commit SHAs, output, duration, and transition classification for the exact scenario that ran.

Create shared workspaces with owner, admin, member, and viewer roles; invite teammates by verified email; and share repositories without transferring repository ownership.

Teams can assign contract owners, save organization policy templates, apply governed settings, and require a second administrator to approve pending contract changes.

Workspace members can inspect verification across shared repositories while role changes, invitations, repository sharing, policy changes, and contract decisions remain auditable.

The backend now supports workspace-linked subscriptions, seat counts, pooled allowances, and billing-owner controls ahead of public Team checkout.

Completed pull-request scans publish a check conclusion derived from the underlying ShipCheck verdict and repository merge policy.

Repositories can choose whether review-required verdicts block, which GitHub permission may approve an exception, how long it lasts, and whether regulated contracts may be waived.

Authorized maintainers can approve a reasoned temporary exception without changing or hiding the underlying Behavior Contract verdict.

Approvals, revocations, policy snapshots, verdict snapshots, actors, reasons, and expiry are retained as governance evidence.

Every Behavior Guard can now carry explicit lifecycle, criticality, enforcement, ownership, approval, evidence freshness, preconditions, invariants, scenarios, and observable outcomes.

Contract changes create immutable snapshots with the responsible developer and change reason, preserving the exact expectation and governance policy that applied at each point in time.

Relevant protected behaviors are converted into small, falsifiable verification plans with invariants, scenarios, expected outcomes, and requested evidence before verification begins.

The verification agent can retrieve files, look up references, discover tests, and inspect historical evidence under a strict call budget without mutating the repository.

Coverage scoring, citation validation, contradiction handling, source diversity, and contract-specific evidence requirements now determine whether a behavior can be called verified.

When runtime proof is unavailable or required evidence is missing, ShipCheck reports an explicit inconclusive result with remaining questions instead of presenting code presence as proof of behavior.

Ship decisions now distinguish Ready to ship, Ready with uncertainty, Review before shipping, and Do not ship based on findings plus each affected contract's criticality and enforcement mode.

The Behavior Impact Graph selects relevant contracts while critical and regulated behavior receives priority; deprecated and retired contracts are excluded from active verification.

Each verification run stores the exact contract snapshot, evidence policy result, investigation trail, uncertainty, and verdict reasons used for that commit.

Repository pages now let developers configure contract governance and structured claims, while scan reports expose the contract version, evidence, enforcement, and reasons behind the final verdict.

Protected behaviors can now be represented as a persistent graph connecting Behavior Guards to implementation code, API entrypoints, regression tests, and downstream workflow impact.

ShipCheck can move beyond file-level associations and identify specific functions that implement or depend on protected behavior, making behavioral relationships substantially more precise.

Bounded static analysis can follow supported imports and function calls around protected behavior without requiring ShipCheck to send an entire repository to an AI model.

Behavior Impact can distinguish the implementation directly responsible for a protected contract from downstream code and potential impact reached through that implementation.

Static dependency evidence can identify Behavior Guards connected to files and symbols changed by the pull request, helping ShipCheck prioritize the most relevant repository behavior during analysis.

Graph connections carry their relationship type, confidence, evidence, and source so ShipCheck can distinguish proven implementation and verification links from weaker inferred impact.

The scan report now presents protected behavior, implementation, and impact or verification as an interactive graph with pan, zoom, auto-fit, relationship labels, stage boundaries, and node details.

Behavior Impact relationships are stored as repository knowledge instead of existing only for a single scan, allowing future pull requests to build on previously established behavioral context.

ShipCheck's review prompts were tightened to remove repeated instructions, empty sections, and redundant metadata while preserving the code, behavioral evidence, repository context, and safeguards used during analysis.

The /shipcheck pull-request workflow is now surfaced across ShipCheck's website and documentation, making it clear how an activated repository can be rescanned without leaving GitHub.

Documentation now explains repository activation, the /shipcheck pull-request command, permission requirements, on-demand rescanning, and how ShipCheck publishes results back into GitHub.

ShipCheck can use previously fixed repository problems during pull request analysis and flag changes that recreate an old failure mode or break behavior established by a past fix.

Repository history can be inspected for meaningful bug fixes and safeguards, turning established behavior from previous fixes into candidate Behavior Guards that developers can review and protect.

Behavioral findings can now distinguish removed safeguards, authorization changes, validation changes, API contract changes, state-transition changes, error behavior, data semantics, user behavior, and other behavioral changes.

Behavior Guards can be connected to executable regression tests so protected behavior can be verified against the actual repository instead of relying only on static reasoning.

Runtime verification now supports Vitest, Jest, Node Test, Playwright, Pytest, Python unittest, Go test, Cargo test, JUnit, .NET test, RSpec, and PHPUnit.

ShipCheck can carry the relevant test name or verification pattern into runtime verification, allowing generated and protected tests to be executed more precisely.

Pull request scans surface whether repository behavior was preserved, intentionally changed, violated, or newly introduced so developers can understand behavioral impact without interpreting every finding individually.

Dashboard and scan interfaces received readability, layout, and navigation improvements while scan processing and verification were made more resilient for larger real-world repositories.

A rebuilt documentation experience now explains ShipCheck's core workflow, Behavior Guards, behavioral regression detection, Behavior History, historical fixes, runtime verification, scanning, GitHub integration, and repository configuration with searchable navigation.

Protected behaviors can record when they were introduced, preserved, violated, restored, or intentionally changed.

ShipCheck can inspect repository history to find the earliest supported commit where a protected behavior became true.

Origin analysis can follow related implementation files, helpers, authorization logic, validation, and tests instead of relying only on the file where the Behavior Guard was discovered.

Historical introductions include the source commit, strongest supporting file, confidence score, and an explanation of why that commit established the behavior.

Developer-confirmed behavior changes can be distinguished from regressions, creating a more accurate record of what the repository is expected to do.

Improved scan queue and worker behavior so interrupted scans can recover more reliably.

Failed or interrupted scan jobs can be retried instead of becoming permanently stuck.

ShipCheck can detect abandoned scan work and recover it without requiring manual intervention.

Protect repository behaviors and safeguards that future pull requests should preserve.

Pull requests can be evaluated against previously protected behavior instead of being reviewed only as isolated code changes.

Behavior Guard gives ShipCheck additional context for recognizing when a reasonable-looking change weakens behavior the repository depends on.

Generate a test directly from a ShipCheck finding to capture the behavior that should continue working.

Generated tests target the behavioral regression identified by ShipCheck instead of producing generic test coverage.

Once a regression is fixed, its expected behavior can be encoded in the test suite so the same class of issue is less likely to return.

Connect ShipCheck through the GitHub App and choose which repositories it can access.

Review connected repositories and their pull requests directly through ShipCheck.

Repository access is handled through the GitHub App installation flow instead of requiring personal access tokens.

AI-enhanced behavioral analysis can be controlled independently for individual repositories.

Security, Reliability, Code Quality, Accessibility, and Testing analysis can be enabled or disabled independently.

Exclude generated files, documentation, vendored code, snapshots, and rules that do not apply to a repository.

Before applying a fix, ShipCheck verifies that the pull request has not changed since the finding was produced.

Related file changes are applied together so fixes do not leave the repository in a partially updated state.

After code changes, previous scan results are marked stale so developers know the pull request should be verified again.

See which issues were introduced by the latest pull request revision.

See which previously detected findings remain unresolved.

See which findings disappeared after the pull request was updated.

Recognize when a previously resolved finding appears again later.

Revision metadata, verdicts, Ship Score changes, and scan deltas make it easier to understand what changed between runs.

Pull requests receive a score that summarizes the level of risk ShipCheck identified.

Scans surface a clear recommendation about whether a pull request appears safe to ship or needs review first.

Findings are organized into Security, Reliability, Code Quality, Accessibility, and Testing.

Critical findings, warnings, and informational findings make it easier to focus on the changes that matter most.

Findings explain what behavior existed before the pull request and what behavior exists after it.

ShipCheck looks for validation, authorization, normalization, error handling, and other protections that became weaker or disappeared.

Changes to APIs, callers, state transitions, assumptions, and repository conventions can be identified as behavioral risk.

Analysis uses relevant code outside the changed lines to understand the contracts and assumptions surrounding a pull request.

Behavior changes that should be protected by regression tests are surfaced during review.

Connect a repository and analyze pull requests for behavioral regressions and risky changes.

ShipCheck is designed for a world where tools like Cursor, Claude Code, Codex, and Copilot can produce large amounts of plausible-looking code quickly.

Catch unintended behavior changes before they reach production.