lehre

Plugin lehre from marketplace werkstoff in Anselmoo/werkstoff. Commands read from the repo's manifest — 11 days ago.

Skills (9)

• lehre-brief

  Use after lehre-gauge to turn a violation set into an ordered remediation plan behind an explicit human approval gate, written to LEHRE_BRIEF.md. Trigger on 'plan the cleanup', 'what order should we fix these in', 'write the remediation brief', or 'lehre brief'. Refuses to run without a gauge result

• lehre-codify

  Use after lehre-preflight (brownfield) or lehre-decompose (greenfield) to research a code style, pattern and architecture doctrine from external authority plus real repository evidence, and write it to .lehre/ruleset.json as machine-checkable rules. Trigger on 'establish our code standards', 'what r

• lehre-conform

  Use to build a greenfield unit, or to apply exactly one approved phase of LEHRE_BRIEF.md, with the doctrine's blocking rules enforced at the tool-call layer throughout. Trigger on 'build the next unit', 'implement phase 1', 'apply the approved fixes', 'make this conform', or 'lehre conform'. Refuses

• lehre-decompose

  Use on a blank page, after lehre-preflight reports greenfield, to turn a stated project intent into build units, the seams between them, and an enforced build order. Trigger on 'start this project properly', 'initialize this repo', 'break this down into pieces and connect them', 'what should I build

• lehre-gauge

  Use to sweep a codebase against the doctrine in .lehre/ruleset.json and report every violation with file:line, after lehre-codify has written rules. Trigger on 'check this code against our standards', 'where do we violate our own architecture', 'audit for antipatterns', 'gauge this repo', or 'lehre

• lehre-pin

  Use once a unit or phase is validated, to make its rules survive without the plugin: emit a CI check that runs the doctrine with no agent in the loop, and write behaviour tests around the code that was changed to conform. Covers CI pinning of the ruleset, durable enforcement once the plugin is unins

• lehre-preflight

  Use FIRST, before any other lehre skill, to determine whether this repository is a blank page or an existing tree, report what doctrine it already declares, and say plainly what lehre can and cannot enforce here. Trigger on 'set up code standards', 'enforce our architecture', 'start a new project pr

• lehre-status

  Use to report where a lehre run currently stands — which units are validated, blocked or ready, how many rules are in force, and what is denied at write time right now. Trigger on 'lehre status', 'where are we', 'what's blocked', 'what can I build next', or when resuming work on a repository that al

• lehre-validate

  Use after lehre-conform to independently check that a unit satisfies its rules AND actually does what the project intent said it would, then close it so dependent units become buildable. Trigger on 'validate this unit', 'is this actually done', 'check the work before moving on', or 'lehre validate'.

Subagents (9)

• conformance-remediator

  Use this agent when one cluster of already-verified, brief-approved MECHANICAL findings sharing a single (file, rule) pair needs its exact rewrite applied, and nothing else. Only ever dispatched by lehre-conform against a lehre rule-card finding — not for befund-code-idiom "modernization" findings (

• decomposition-critic

  Use this agent to adversarially review a candidate unit decomposition before it is written to .lehre/ruleset.json — hunting for invented or missing depends_on edges, owns and must_not_know claims the stated intent does not support, invented technologies, shared-bucket units, and overlapping or uncov

• doctrine-researcher

  Use this agent when one rule-domain (naming, module boundaries and layering, error handling, dependency direction, test placement, public API surface) needs candidate rules researched from external published authority for a specific language and version. Returns candidates with citations only — neve

• pattern-investigator

  Use this agent when an existing codebase needs surveying for how it actually handles one convention dimension, with real file:line evidence, so a researched rule can be upgraded to evidence-backed provenance or dropped for contradicting settled practice. Brownfield only — never dispatched on a blank

• rule-critic

  Use this agent to adversarially review a candidate ruleset before it is written to .lehre/ruleset.json — independently re-deriving whether each rule's sourceMode claim is honest, hunting for forced consistency where genuine variation was warranted, and catching blocking rules whose predicate cannot

• spec-decomposer

  Use this agent when one concern of a stated project intent needs turning into candidate build units — what each owns, what it must not know about, and which seams it participates in. Every dispatch names exactly ONE concern; a dispatch naming several is out of scope and only the first is handled.

• spec-fidelity-auditor

  Use this agent when a completed unit needs checking against the project intent it was built for — does it deliver what the recorded intent said, and does it respect what the decomposition declared it must not know? Answers a question no rule can express; every rule passing is not the same as the uni

• violation-auditor

  Use this agent when a rule that has no deterministic predicate — an advisory rule the closed check vocabulary cannot express — needs a codebase surveyed for violations by reading, since the gauge script cannot decide it. Never dispatched for a rule the gauge can already decide — re-auditing those by

• violation-verifier

  Use this agent to independently re-confirm one candidate violation at its exact file:line, blind to the reasoning that produced it, so a false positive is caught before a remediation is planned around it. Judges one location per dispatch and never infers one location's verdict from another's, even w

Hooks (1)

• PreToolUse

  python3 -B "${CLAUDE_PLUGIN_ROOT}/hooks/lehre_guard.py"

Similar plugins