Install
Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx agentmods add instructions/clay-good/openlore/claude-mdgit clone --depth 1 https://github.com/clay-good/OpenLoreWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/instructions/clay-good/openlore/claude-md)<a href="https://agentmods.dev/instructions/clay-good/openlore/claude-md"><img src="https://agentmods.dev/badge/instructions/clay-good/openlore/claude-md.svg" alt="Measured on agentmods" height="20"></a> Per session 5,602 This file is loaded in full into every session.
When invoked 5,602 The same file — it is already loaded in full.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost
What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5 | $0.05602 | $0.05602 |
| Opus 5 | $0.02801 | $0.02801 |
| Sonnet 5 | $0.01120 | $0.01120 |
| Haiku 4.5 | $0.00560 | $0.00560 |
Security
Grade A, and why
OpenLore CLAUDE.md scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 4d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
CLAUDE.md · 100 lines
How it starts
The opening of the file, as written. The whole thing — 100 lines — stays where its author put it; the contents beside it link to each section on GitHub.
@.openlore/analysis/CODEBASE.md @openspec/specs/overview/spec.md
openlore MCP tools — when to use them
| Situation | Tool |
|---|---|
| Starting any new task | orient — returns functions, files, specs, call paths, and insertion points in one call |
| Don't know which file/function handles a concept | search_code |
| Need call topology across many files | get_subgraph / analyze_impact |
| "Which tests must I run for this change?" | select_tests — backward reachability to the reaching tests |
| "Which important code has NO test reaching it?" / "is the risky part of this change untested?" | report_coverage_gaps (opt-in --preset full) — the structural inverse of select_tests over the whole graph: functions in no test's reachable set, ranked by hub/chokepoint significance (no runtime, no coverage tool). SOUND DIRECTION ONLY — reports "no reaching test", never claims a symbol is "tested" (reachable-from-a-test ≠ behavior-verified). A gap with no caller at all is labeled also-dead (distinct from find_dead_code); an untested entry point is untested-not-dead. Scope to a diff (changedSymbols/diffRef) or region (filePattern). Distinct from get_test_coverage (spec-tag based). CLI: openlore coverage-gaps |
| "What's the blast radius of my diff before I commit?" | blast_radius — one advisory briefing: callers/layers, tests to run, anchored memories/decisions that will drift, stale specs |
| "Post a deterministic structural review on a PR" (CLI, no MCP/agent) | openlore review — composes structural_diff + blast_radius into a Markdown/JSON briefing; bundled GitHub Action posts it as one sticky comment. Advisory by default; opt-in gating via blastRadius.block. No new MCP tool |
| "What's unreachable / what dies if I delete X?" | find_dead_code — cross-language reachability (candidates) |
| Reviewing a change: structural delta + stale callers | structural_diff |
| "Did my diff escape its declared write-footprint, and what conflict did that open?" | structural_diff with an opt-in declaredFootprint (+ peerFootprints) — the back-side of plan_parallel_work: flags symbols modified outside the declared write-set (out-of-scope / read-set-intrusion / scope-creep), names peers an escape newly conflicts with, and verifies declared appends against the realized diff. Advisory; opt-in blocking via enforcement.policy. No new tool (change: add-footprint-escape-detection) |
| "What changes together with this / what's volatile?" | get_change_coupling — co-change + churn from git |
| Lay of the land / where do regions connect? | get_map (region view; pass a communityId to drill in) |
| Find the route from A to B (by name, role, or landmark) | find_path (cheapest call path + alternates) |
| Planning where to add a feature | suggest_insertion_points |
| Reading a spec before writing code | get_spec |
| "Which requirements actually link to code, and which are unmapped/ambiguous/stale?" | get_mapping — the deterministic spec link index: requirement→code links derived from the exact - **Implementation**: \symbol::path`anchors written in the specs, resolved against the current graph. NO LLM, no embeddings, no name similarity: an anchor resolving to one symbol islinked, to several is ambiguous(candidates disclosed, none selected), to none isstale, and a requirement with no exact anchor is unmapped. A file-only reference is domain-footprint evidence and NEVER function coverage. mapping.jsonis a rebuildable CACHE, never a prerequisite — an absent, legacy, corrupt, or provenance-mismatched cache is re-derived in memory, so Repair works on a repo that never ran standalone generation. CLI:openlore mapping refresh` (change: harden-spec-workflow-lifecycle) |
| Checking if code still matches spec | check_spec_drift |
| Finding spec requirements by meaning | search_specs |
| Checking spec coverage before starting a feature | audit_spec_coverage |
| Recording an architectural decision before writing code | record_decision |
| Persisting a durable, code-anchored fact for later sessions | remember (opt-in memory preset) — anchors a note to a symbol/file so it self-invalidates; optional type (invariant/gotcha/rationale/…, default note) and supersedes=<id> to retire a prior memory (kept queryable via asOf); re-recording the same content+anchor updates in place |
| Recalling what's known about code you're touching | recall (opt-in memory preset) — returns memories with a freshness verdict and a factual served-content provenance class (local-unreviewed for locally recorded notes; reviewed decisions are reviewed-corpus); recorded text is never rewritten. It never serves orphaned records as authoritative; two authoritative memories on one symbol surface in unreconciled; an authoritative memory that cites a superseded decision carries a staleDecisionRef signal (and is not presented as cleanly fresh); optional asOf/changedSince (commit-ish) for history and a type filter. A memory whose anchored symbol was renamed/moved is carried forward at the next openlore analyze (change add-symbol-identity-continuity): recall re-points it and surfaces carriedAcross provenance instead of orphaning it; an ambiguous move stays orphaned but discloses possiblyMovedTo candidates |
| About to assert a structural fact to a user ("X is dead", "Y calls Z", "this is safe to change") — or cite a decision ("ADR abc12345 governs this") | verify_claim (opt-in verify preset) — verify the claim against the graph, then cite the receipt to the human; an unverifiable verdict means hedge or read the source. The decision-current kind (subject = an 8-char decision id) verifies a decision is still authoritative against the decision store: refuted (with the live superseder to cite instead) if it was superseded/rejected — catch a stale citation before it reaches the human |
| "Is my external spec store's binding to its code repos healthy?" | spec_store_status (opt-in federation preset) — read-only health of the .openlore/config.json specStore binding: per-target resolution + index freshness, reference presence, conclusion-shaped findings with stable codes and local-unreviewed provenance for config-derived names; never blocks |
| "Assemble the structural context an active change needs across its target repos" | working_set_context (opt-in federation preset) — orient generalized from one repo to a change's spec-store targets: reads the change's proposal, orients each indexed target on that intent, returns ONE token-budgeted, per-target-attributed briefing (symbols, callers, spec domains, insertion points) + fresh in-scope anchored intent (orphaned withheld, drifted flagged); read-only, never blocks |
| "Certify what my change touches before it lands — does it open a new path into a sensitive boundary?" | change_impact_certificate (opt-in federation preset) — ONE conclusion-shaped certificate for the current diff: blast radius, the paths the change NEWLY OPENS into each declared covering surface (reachable after but not before — differential, no LLM), drifted specs, tests to run. Decays via the freshness lease (anchored to touched symbols; the spec-store health check re-fires a stale one). Advisory; opt-in blocking only on a configured surface severity. Declare surfaces under impactCertificate.surfaces in .openlore/config.json. Also openlore impact-certificate [--base <ref>] [--change <id>] [--json] [--hook] [--save] |
| "Did my change break my consumers' public API contract?" | certify_public_surface (opt-in --preset full) — with NO base ref returns the PUBLIC SURFACE (exported symbols + signatures); with a base ref returns a deterministic breaking-change VERDICT for the working-tree diff: each changed export classified `breaking |
| "How does this codebase actually write code — so my edit matches the house style?" | get_style_fingerprint (opt-in --preset full) — a DESCRIPTIVE, deterministic idiom profile measured during the AST walk (no second parse, no LLM): per language, the dominant choice for a fixed set of idioms (arrow vs. declared function, const vs. let, ternary vs. if, await vs. .then, template vs. concatenation, function-naming case) as { dominant, ratio, samples }. Repository profile by default; communityId for a region (from get_map) or filePath for one file. HONEST: an idiom below a fixed evidence floor, or one the language/formatter enforces (e.g. Go ties identifier case to visibility → enforced null), reports a null signal, never a guess or a 1.0 tautology. Descriptive, not prescriptive — no lint judgment, no composite style score. Languages: TypeScript/JavaScript/Python/Go (others fail-soft, no counters). orient also carries a compact regionStyle summary for the touched region. Also openlore style-fingerprint [--community <id>] [--file <path>] [--language <name>] [--json] (change: add-codebase-style-fingerprint) |
| "I'm about to write this function — does a near-duplicate already exist that I should reuse?" | find_clones (opt-in --preset full) — the edit-time, SCOPED companion to get_duplicate_report (which is the whole-repo audit of every clone group). Takes ONE query: a symbol (a function in the index, name or name::path) or a snippet (raw code NOT necessarily indexed — the pre-write "does this already exist?" check the whole-repo report structurally cannot do). Returns the existing clones ranked exact > structural > near (each naming the file, function, line range, type, similarity, and language — a cross-language near match is flagged) — the canonical implementation to reuse. Reuses the same detector as get_duplicate_report (no new algorithm/constant), but ONE-VS-ALL (O(n)), so it finds near-clones even where the whole-repo O(n²) pass is skipped. HONEST: unknown symbol → explicit not-found (+candidates), never an empty "unique"; ambiguous bare name → name::path candidates; below-evidence-floor query → "too small to compare", not "no clones"; the query never matches itself; a symbol with no comparable body (HTML inline-script / external) says so. Computed live from the cached graph + a re-read of the source it spans (no new artifact). Also `openlore find-clones [--symbol |
| "What exceptions can blow out of this function — and is any already handled?" / "I changed this to throw; who's exposed and where is it caught?" | analyze_error_propagation (opt-in --preset full) — the error-handling analogue of analyze_impact: given a symbol (name or name::path), returns escapes (the exception types that can propagate OUT to callers — each with origin function/file/line, direct-vs-propagated, and the call path) and handledInternally (exceptions thrown in the reachable subtree but caught within this function, so callers are shielded). SCOPE: TypeScript/JavaScript/Python; a symbol in any other language returns an explicit unsupported result, NEVER an empty escape set. HONEST — a SOUND LOWER BOUND: an un-analyzable callee (external/bodyless/unsupported/over-bound) is disclosed in boundaries, never assumed exception-free; an intra-object this./super./self./cls. call the call graph could not resolve to an indexed method is disclosed too (the one call shape that gets neither a resolved nor an external:: edge — never silently assumed exception-free); a re-raise/throw of unknowable static type is <dynamic>, never dropped; Python typed except is matched by exact name only (no subclass hierarchy), disclosed; maxDepth/function-cap truncation is disclosed. Reuses the CFG overlay's throw/try node-type knowledge (no new grammar) and is computed live from the cached graph + a source re-read (no new artifact, no schema change). Also openlore error-propagation [--symbol <name>] [--max-depth <n>] [--json] (change: add-error-propagation-graph) |
"What breaks if I remove or rename this env var?" / "who reads DATABASE_URL and what's the blast radius?" |
analyze_env_impact (opt-in --preset full) — the configuration analogue of analyze_impact: given an env var name, returns the line-precise readSites (file/line/enclosing function; a read outside any function is reported module-level), affectedFunctions (upstream callers that transitively reach a read — the blast radius), reachingTests to run, declaredInEnvFile, and per-site required (a read with no site-local fallback ??/` |
| "A lot changed in this repo since I last looked — what actually matters?" (review / catch-up / onboarding) | briefing_since (opt-in --preset full) — the catch-up counterpart to blast_radius/change_impact_certificate (which brief your own pending diff): given a base ref, returns the changed production symbols SINCE it, ranked into a fixed tier order — surprising-change (a high-fan-in hub whose file rarely changed before) > hub-change (a broad high-fan-in/high-fan-out hub) > chokepoint-change (a high-fan-in funnel) > ordinary-change. Tiers come ENTIRELY from existing classifiers (landmark-signals hub/orchestrator/chokepoint + the volatilityLevel churn classifier) plus raw evidence (fan-in, fan-out, prior churn) — NO weighted score, NO new tuning constant. HONEST: changed symbols are file-granular (disclosed); the surprising-change label is WITHHELD when history is too shallow (< 2 non-bulk commits) to say "rarely changed before"; a bounded briefing carries a truncation receipt (omitted count + lowest tier) and NEVER drops a higher tier for a lower one; a silent base-ref fallback is disclosed (a baseRef git can't resolve reports baseRefFallback, not a quiet brief against main); the file-path-exact churn join (git doesn't follow renames) is caveated when it could over-flag a renamed file; scope is hand-authored source code (IaC/generated/vendored excluded — same candidate set as report_coverage_gaps). Grouped by region, with the tests to run for the whole change set (via select_tests). The cursor is the base ref, never wall-clock time. Also openlore briefing-since [--base <ref>] [--file-pattern <substr>] [--max <n>] [--json] (change: add-change-significance-briefing) |
| "Which of these N tasks can I run in parallel across agents/worktrees, and in what order?" | plan_parallel_work (opt-in coordination preset) — given a caller-supplied task list ({ id, seedSymbols?, seedFiles?, writeMode? }), returns the computed plan: a hazard-typed conflict graph (WAW / shared-append / RAW / WAR / soft-coupling), a wave schedule (wave 1 = dispatch now), and the critical path (minimum sequential rounds with unlimited agents). Stateless and advisory — re-invoke with the remaining tasks to re-plan; no lease, no dispatch. Mark registration-site touches (a dispatcher case, a registry array) writeMode:"append" so they are not falsely serialized. WAW conflicts and unorderable RAW cycles surface as policy-shaped governance findings (parallel-work-conflict / parallel-work-cycle) the invoking caller can gate on via resolveEnforcementClass; the bundled openlore enforce commit gate does not run the planner, so it never blocks on them |
| "Which changes already in flight — humans' branches/PRs and my agents' tasks — collide right now, within or across the federation?" | map_in_flight_conflicts (opt-in coordination/federation preset) — the team version of plan_parallel_work: instead of a caller-supplied task list it harvests every in-flight change (local branches, open PRs via gh, plus any supplied agent task descriptors) and runs the same hazard classifier across all of them. Each footprint is derived from the change's ACTUAL diff — per-symbol append vs modify read off the hunks — so two PRs appending disjoint registry entries resolve to shared-append, not a false WAW, with no writeMode declaration. Returns per conflict: the two actors, hazard class, shared symbols, and a suggested landing order ("land #210 first; it shares resolveCallSite's write-set"). A change whose diff can't be fetched or whose symbols don't resolve is labeled "not assessed", never "no conflict". Read-only, stateless (no watcher/poll/store), advisory; opt-in federation matches across repo boundaries by stable id. WAW pairs surface as the policy-shaped cross-actor-conflict finding a CI check can gate on |
| "A structural result for a file looks empty — is the language even supported for that?" / "what does OpenLore extract for language L?" | get_language_support (opt-in --preset full) — the deterministic per-language capability matrix (signatures, callGraph, imports, cfgOverlay, typeInference, styleFingerprint, iacProjection, crossServiceHttp, errorPropagation) for the repo's detected languages, or a named language (a pure registry lookup; an unknown language returns an honest all-unsupported record). Makes a quiet result interpretable — "calls unsupported for L" vs. "no callers". Fail-soft: an unsupported capability yields nothing, never a guess. Registry is DERIVED from the live extractors so the matrix can't over-claim. See docs/language-support.md for the "add a language" checklist |
Changes
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 4d ago First seen · 100 lines · 5,602 tokens per session scan A bd2033ddb9c6
OpenLore CLAUDE.md is an instructions file published in the GitHub repository clay-good/OpenLore (292 stars, last pushed today), licensed MIT. It adds 5,602 tokens to every session, about $0.0280 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.
Related
Other instructions, from other repositories
project-orchestration-skills CLAUDE.md
Instructions for jrjsmrtn/project-orchestration-skills, covering ai-assisted project orchestration skills, project structure, skill file format, skills overview and development conventions.
spec-driven-development-template sdd-specs.instructions.md
Instructions for juanklagos/spec-driven-development-template, a project described as: Operational SDD framework with AI guidance, GitHub Spec Kit workflows, and MCP support.
Maestro CLAUDE.md
Instructions for aaryansinha16/Maestro, covering maestro — claude.md, project identity, core operating principles, how it works and the conductor (brain).
deckhand CLAUDE.md
Instructions for jonthebeef/deckhand, covering deckhand, layout, versioning and releases, how updates reach users and repo conventions.
ESAA-Core AGENTS.md
Instructions for elzobrito/ESAA-Core, covering agents.md — contrato operacional codex/esaa, 1. autoridade e termos, 2. cli e runner, ou configure o runner uma vez por sessão and 3. concorrência.
codecrucible AGENTS.md
Instructions for block/codecrucible, covering agent instructions, quick reference and landing the plane (session completion).