Introduction

Questions like these often appear in design documents, architecture specifications, and refactoring plans: the documentation is written very definitely, but the actual code behavior might be inconsistent. For example, claims like “the migration won’t break fields,” “the retry limit is safe,” and “this state machine won’t deadlock” need to be grounded in code facts or executable models, not just stuck in textual descriptions.

LogicProbe is a skill plugin for claim verification. It first enumerates verifiable claims from documents or plans and then provides evidence against the codebase item by item; when encountering behavioral claims, it upgrades to executable model verification. Below introduces its core capabilities, installation methods, typical usage, and precautions.

What is it

  • Repository: AmethystLuna/logicprobe
  • Type: skill plugin
  • License: MIT
  • Supported Environments: Claude Code, Codex CLI, Cursor, Kimi CLI, OpenCode, ZCode, and DeepSeek Harness (dsh)

The materials do not provide an independent maintainer field; currently verifiable information mainly comes from the repository path AmethystLuna/logicprobe and its scraped documentation.

Core Capabilities

Document Claim Verification

LogicProbe handles verifiable claims in design documents, architecture specifications, and refactoring plans, providing evidence against the codebase item by item.

The output includes:

  • Precise file:line evidence
  • Severity levels
  • Correction direction
  • coverageNotes external tool routing

State Machine Model Verification

LogicProbe can perform structural checks and adversarial probes on state machine models.

Verified functional descriptions include:

  • 8 structural checks: S1-S8
  • 14 adversarial probes: A1-A14

Please note that there is inconsistent phrasing regarding the number of probes in the verified materials. After installation, please refer to the actual instructions within the package.

logicprobe_verify supports the following verification dimensions:

  • BEFORE/AFTER comparison
  • cost/budget
  • weight/probability
  • onEntry/onExit
  • maxTicks/tickEvents

When a LogicModelV1 JSON already exists, you can run the verify, compose, and export capabilities of logicprobe-engine.py.

Refactoring Patterns

Refactoring patterns are used to compare before and after models, focusing on:

  • Behavioral preservation
  • Invariant continuity
  • Deadlock regression
  • Complexity claims

Data Model Patterns

The data model pattern supports DataModelV1 data model verification, focusing on:

  • Migration coverage
  • copy consistency
  • before/after breaking change regression

Data model/migration reviews can use the logicprobe-datamodel skill.

Concurrent Risk Mining

LogicProbe scans documentation or plans for concurrency safety claims and marks entries that require specialized verification.

DSH Bundle Capabilities

In DeepSeek Harness, LogicProbe is provided as a bundle.

The DSH bundle injects a claim verification gate in the first round of the session and registers:

  • cordis_inspect
  • logicprobe_verify
  • logicprobe:mode

logicprobe_compose_verify supports the verification of two or more combined state machines, reporting:

  • C1 Combined Deadlock
  • C2 Handshake Never Triggers

logicprobe_export can export:

  • UPPAAL
  • TLA+
  • PRISM
  • SPIN

These exports correspond to the native inputs of external model checkers.

Installation and Enablement

DSH Installation

First confirm the DSH version requirements, then execute the installation.

The package.json declares the version as 0.6.0, and dsh.engines requires:

dsh >=0.1.0-rc.7

The verified DSH installation command is:

dsh plugin add "github:AmethystLuna/logicprobe"

The DSH npm package name is dsh-logicprobe with no scope.

In the package.json of the web profile, the dependency key and dsh.profile.bundles must be written as:

dsh-logicprobe

Otherwise, the DSH loader may fail to start because it cannot find node_modules/dsh-logicprobe.

If the plugin manager refuses to install, first confirm whether the @deepseek-ai/* packages are declared in peerDependencies rather than dependencies.

Other Platform Environment Requirements

Verified environment requirements are:

  • Claude Code v2.1+
  • Codex CLI latest
  • Cursor 2.5+
  • Kimi CLI latest
  • OpenCode latest
  • ZCode 3.0+
  • DeepSeek Harness (dsh) dev preview: tested on mainline 2026-08-14

Python is optional:

  • Python 3.6+ is only needed for the automatic verification tool
  • Manual fallback mode requires no dependencies

Typical Usage

The following usages come from verified materials.

Design Document or Plan Review

Example triggers:

Review this design document

Used for design document/plan review, triggering claim enumeration and codebase verification.

Behavioral Questions

Example triggers:

could this state machine deadlock

is this retry limit safe

check this timing for bugs

These types of behavioral questions are proactively suggested as optional verification.

Refactoring Plans

Used to compare before and after models and mark behavioral changes not declared in the plan.

Data Model or Migration Review

Example triggers:

is this migration non-breaking

does this copy cover all required fields

Used for data model/migration review, the logicprobe-datamodel skill can be used.

Existing LogicModelV1 JSON

When a LogicModelV1 JSON already exists, you can run the following of logicprobe-engine.py:

verify
compose
export

Configuration and Limitations

DSH Bundle Configuration

The DSH bundle supports the following configuration keys:

enabled
gateContent
interaction

Specific default values refer to the documentation within the package.

Model Confirmation Process

The model must first be presented as a transition table and confirmed by the user before running.

Verified materials indicate: model extraction errors are the top failure mode of verification.

Runtime Permissions

At runtime, LogicProbe only reads the package’s skills/ directory.

It:

  • Does not read credentials
  • Does not initiate network connections
  • Does not access user data outside of DSH session context

However, the plugin runs with the current dsh process permissions. It is recommended to check the source code, dependencies, and MIT license before installation.

Applicable Scenarios

LogicProbe is suitable for the following scenarios:

  • Reviewing design documents for consistency with code
  • Verifying behavioral claims in architecture specifications
  • Reviewing refactoring plans for unannounced behavioral changes
  • Verifying state machines for deadlocks, liveness, or timing risks
  • Reviewing data model migrations and copy consistency
  • Marking concurrency safety claims that require specialized verification

Summary

The value of LogicProbe lies in changing “what the documentation says should be the case” into “whether code facts or executable models can prove it is the case.” It is suitable for development workflows that need to ground design documents, refactoring plans, state machine behaviors, or data migration claims in an evidence chain.

Verified materials do not provide specific star counts or directory page URLs.

GitHub Repository:

https://github.com/AmethystLuna/logicprobe