MotusSupra.
Define work once.
Verify it. Carry it forward.

Work disappears into chat,
tickets, and memory.

Most teams have activity everywhere but accepted context nowhere. The work happened, but the exact scope, proof, and close decision are scattered across chat threads, ticket comments, and someone's head.

Motus fixes that by treating the work item as the atomic unit. You claim it, attach evidence while it happens, and close it with an explicit receipt. That is the smallest loop that keeps work from dissolving back into ambiguity.

Start local and human-driven. Add scripts, CI, or agents later. The runtime can change. The packet semantics should not.

Claim gives temporary ownership.
Evidence shows what happened. Receipt closes the loop.

The command loop is intentionally small. `claim` says who owns the work right now. `evidence` records what happened while the work runs. `release` closes that attempt with an explicit outcome instead of leaving completion implied.

That is why Motus scales beyond chat. The next person, script, or agent starts from an accepted close record, not a reconstruction exercise.

Workflows coordinate. Trust scales.
Work crosses boundaries.

Execution speed increased. Certainty did not. Agents and automation mean you can get more done than ever. But you cannot verify any faster. The gap between "done" and "done right" keeps widening.

Each workflow defines a contract. Each step verifies against it. Workflow, contract, verification, receipt. Work moves forward with proof attached.

Each outcome emits a receipt that binds context, evidence, timestamp, and hash. You define required proof in the contract. If proof is missing, the check fails.

When something goes wrong, you check the receipt. It reduces forensic effort and decision replay. Less time arguing what happened. More time moving forward.

When work crosses boundaries, the receiver runs their own checks on the same receipt. Local acceptance is authoritative. Motus stays local-first and works with your existing stack.

Your repo. Your receipts.
You decide visibility.

Contracts live in your repo and version like code. When scope changes, you see the diff. When something breaks, you can still inspect what was promised.

Receipts are portable. JSON can move into logs, dashboards, or downstream systems without handing over ownership of the work itself.

The CLI is the operator surface. Claim work, attach evidence, release the attempt, inspect the close record, and move to the next packet from accepted truth.

Start with the first run.

Build shows the day-1 loop. The implementation guide expands that same path into exact commands. Use Define and Verify once the packet model makes sense.