Your tests catch code that breaks. Nothing catches an agent that has drifted.

The failure this exists for

Losing your bearings is a failure with no stack trace

Nothing is red. The build passes, the tests pass, the paragraph is convincing. What changed is what the agent believes the code means — and belief has no assertion.

Built for a codebase where 81 documents had come to contradict each other on live production parameters.

What you get

Eleven instruments. Pick any combination.

Each works alone and none depends on another. Install one, install all eleven — --features northstars,taskcore is a complete install, and so is --features all.

North-stars

Falsifiable, or it's decoration

.bearing/north-stars.md

- NS-4 — Win-rate is NEVER a ranker. Only net
         expectancy is a profitability claim.

- NS-9 — REJECTED: averaging into a losing
         position. Measured: adds fill only on
         the weaker cases. Don't re-propose
         without new evidence.

Gold practices — the half that isn't yours

North-stars say what your project is. gold-practices.md ships with bearing and says how the work is done anywhere — numbered GP-#, cited the same way, and outranked by your NS-# whenever they disagree. Every rule carries a scar, and a rule without one is not in the file.

GP-3 — Test at the seam the bug lives at. A unit test that passes an argument the real pipeline never produces is green and dead. Scar: a context-window fix tested as resolve(300_000, undefined) while the shipped config always passed a number — so the fix could not run, and did not, for two releases.

The honest number

What it costs your context — measured, not guessed

Every intel layer costs tokens. Most don't tell you how many. bearing's share is fixed per session, and half of it isn't even bearing: the graph tool schemas are there whenever the MCP server is connected, with or without this package.

Don't take my repos for it. npm run bearing:token-benchmark runs the same comparison on yours — and reports the losses too. On lead-sniffer the graph loses one symbol in eight, and the table says so. A benchmark that never admits that is advertising.

It tells you when it's the problem

A tool that can block your work should show you when it was wrong to

Every enforcement tool believes its own rules are correct. This one assumes they might not be — and keeps the evidence, with the graph state that produced it: version, node and edge counts, the indexed commit. Not "the graph was wrong once", but this query, on this index, at this commit.

Read together they stopped being complaints and became a diagnosis. That corpus is what the rules are calibrated against — and the gates are measured too:

$ npm run bearing:scorecard

⚠ Enforcement is 49% of graph interaction:
  57 redirects vs 60 graph calls.

It refuses to draw the conclusion for you. Nothing leaves your repo. There is no telemetry endpoint.

Where it fires by itself

Enforcement needs hooks, and not every runtime has them

Only Claude Code exposes tool-interception hooks, and a dash is not always absence: the task-core skill and its contract section install everywhere, so you can invoke it by name — what Claude Code adds is the nudge that fires it unprompted. Minions and the GitNexus gates genuinely need the hooks and are not there at all.

Install

One command, and it explains each module before it writes anything

$ npx bearing
# interactive — explains each module

$ npx bearing install . \
    --runtime claude \
    --features northstars,taskcore

# or take the lot
$ npx bearing install . --features all

# later
$ npx bearing update .      # keeps your choices
$ npx bearing uninstall .   # restores what it overwrote

$ npx bearing install . --stealth