Skip to content

Rules

Set custom instructions for Lunos.

You can provide custom instructions to Lunos by creating an AGENTS.md file. This is similar to Cursor’s rules. It contains instructions that will be included in the LLM’s context to customize its behavior for your specific project.


Initialize

To create a new AGENTS.md file, you can run the /init command in Lunos.

/init scans the important files in your repo, may ask a couple of targeted questions when the codebase cannot answer them, and then creates or updates AGENTS.md with concise project-specific guidance.

It focuses on the things future agent sessions are most likely to need:

  • build, lint, and test commands
  • command order and focused verification steps when they matter
  • architecture and repo structure that are not obvious from filenames alone
  • project-specific conventions, setup quirks, and operational gotchas
  • references to existing instruction sources like Cursor or Copilot rules

If you already have an AGENTS.md, /init will improve it in place instead of blindly replacing it.


Example

You can also just create this file manually. Here’s an example of some things you can put into an AGENTS.md file.

AGENTS.md
# SST v3 Monorepo Project
This is an SST v3 monorepo with TypeScript. The project uses bun workspaces for package management.
## Project Structure
- `packages/` - Contains all workspace packages (functions, core, web, etc.)
- `infra/` - Infrastructure definitions split by service (storage.ts, api.ts, web.ts)
- `sst.config.ts` - Main SST configuration with dynamic imports
## Code Standards
- Use TypeScript with strict mode enabled
- Shared code goes in `packages/core/` with proper exports configuration
- Functions go in `packages/functions/`
- Infrastructure should be split into logical files in `infra/`
## Monorepo Conventions
- Import shared modules using workspace names: `@my-app/core/example`

We are adding project-specific instructions here and this will be shared across your team.


Types

Lunos also supports reading the AGENTS.md file from multiple locations. And this serves different purposes.

Project

Place an AGENTS.md in your project root for project-specific rules. These only apply when you are working in this directory or its sub-directories.

Global

You can also have global rules in a ~/.config/opencode/AGENTS.md file. This gets applied across all Lunos sessions.

Since this isn’t committed to Git or shared with your team, we recommend using this to specify any personal rules that the LLM should follow.

Claude Code Compatibility

For users migrating from Claude Code, Lunos supports Claude Code’s file conventions as fallbacks:

  • Project rules: CLAUDE.md in your project directory (used if no AGENTS.md exists)
  • Global rules: ~/.claude/CLAUDE.md (used if no ~/.config/opencode/AGENTS.md exists)
  • Skills: ~/.claude/skills/ — see Agent Skills for details

To disable Claude Code compatibility, set one of these environment variables:

Terminal window
export OPENCODE_DISABLE_CLAUDE_CODE=1 # Disable all .claude support
export OPENCODE_DISABLE_CLAUDE_CODE_PROMPT=1 # Disable only ~/.claude/CLAUDE.md
export OPENCODE_DISABLE_CLAUDE_CODE_SKILLS=1 # Disable only .claude/skills

Precedence

When Lunos starts, it looks for rule files in this order:

  1. Local files by traversing up from the current directory (AGENTS.md, CLAUDE.md)
  2. Global file at ~/.config/opencode/AGENTS.md
  3. Claude Code file at ~/.claude/CLAUDE.md (unless disabled)

The first matching file wins in each category. For example, if you have both AGENTS.md and CLAUDE.md, only AGENTS.md is used. Similarly, ~/.config/opencode/AGENTS.md takes precedence over ~/.claude/CLAUDE.md.


Custom Instructions

You can specify custom instruction files in your opencode.json or the global ~/.config/opencode/opencode.json. This allows you and your team to reuse existing rules rather than having to duplicate them to AGENTS.md.

Example:

opencode.json
{
"$schema": "https://lunos.tech/config.json",
"instructions": ["CONTRIBUTING.md", "docs/guidelines.md", ".cursor/rules/*.md"]
}

You can also use remote URLs to load instructions from the web.

opencode.json
{
"$schema": "https://lunos.tech/config.json",
"instructions": ["https://raw.githubusercontent.com/my-org/shared-rules/main/style.md"]
}

Remote instructions are fetched with a 5 second timeout.

All instruction files are combined with your AGENTS.md files.


Keeping durable notes

To keep facts that should carry across sessions, such as “deploys go out on Tuesdays” or “the billing service owns the invoices table”, write them as small Markdown files and load them with instructions:

opencode.json
{
"instructions": [".opencode/memory/*.md"]
}
  • Keep one fact per file, so each can be reviewed and deleted on its own.
  • Project notes live in the repo and are reviewed like any other change. Personal notes can live in ~/.config/opencode/memory/, loaded from your global config.
  • These files load alongside AGENTS.md and don’t compete with it.
  • Don’t put secrets in them: their contents are sent to your model provider as part of the prompt.

Long-term memory

Lunos can also keep a knowledge graph of what it learns, and recall the relevant parts in later sessions. It is off unless you turn it on:

opencode.json
{
"memory": {
"enabled": true,
"scope": ["project"],
"model": "small",
"embedding": "local",
"retrieval": { "max_tokens": 1500 },
"limits": { "max_facts": 5000, "max_fact_chars": 2000 },
"retention": { "days": 180, "grace_days": 7 },
"encryption": "off"
}
}

What you need: uv and Python 3.10–3.13. Memory runs Cognee (Apache-2.0) in a local Python process. Lunos never installs Python for you: without it, memory stays off and says why.

Setting it up. In the TUI, /settings → Memory → Set up memory… walks through six steps, each with a recommended answer, so pressing Enter through them gives a working setup:

  1. Turn memory on.
  2. Choose where it’s kept: this machine, or a team Neo4j database, which is checked against your residency policy before anything connects.
  3. Pick the model that extracts facts.
  4. Confirm the first-start download.
  5. Choose how long facts are kept and whether the ledger is encrypted.
  6. Run a check that remembers, recalls and removes a test fact.

A summary then shows what will be saved and where (user or project config, ctrl+s in /settings), and anything that would still override it. Nothing is saved or downloaded before you confirm, and keys your organisation locks are shown as fixed. Below the wizard, the Memory section shows a status line, and every other memory setting is under Advanced. lunos memory setup asks the same questions on the command line (--yes takes every recommended answer, for scripts), and lunos memory check runs the check on its own.

  • Remembering. The agent saves facts with a memory_remember tool. You approve each one: the tool asks by default. It refuses:

    • anything in a turn that used webfetch, websearch, an MCP resource, or read a file outside the project
    • anything that looks like a key, token or password
    • anything shaped like instructions to the model: “ignore all previous instructions”, chat role markers, tool-call syntax
  • Recalling. Relevant facts are added to your message in a <memory> block, each with where and when it was learned, capped at retrieval.max_tokens. The agent can also look things up with memory_search.

  • Your notes. Paragraphs in .opencode/memory/*.md are part of project memory, with no approval needed. When you edit or delete one, memory follows.

    • The agent’s file edits in .opencode/memory/ ask first, and edits to the stored graph are refused by default. This stops the agent from writing memory through a file instead of the tool.
    • Shell commands can still write files, so review changes to that folder like any other change.
  • Which model. memory.model picks the model that extracts facts and relationships: "small" (your small_model, the default), "inherit" (the main model) or "provider/model". It runs through your normal provider setup and data-residency policy. If the policy denies it, memory doesn’t start and the error names memory.model.

  • Embeddings are computed locally ("local"). The embedding model (about 87 MB) is downloaded once, from Hugging Face.

  • Where it’s stored.

    • Project memory: .opencode/memory/graph/, which is never committed. Lunos writes a .gitignore there.
    • "user" scope: in the Lunos data directory.
  • Reviewing it.

    • In the TUI, /memory opens a browser: every fact with where it came from, the entities and relationships around the highlighted fact, ctrl+d twice to forget it, ctrl+s to export and ctrl+o to import.
    • lunos memory list, show <id> and search <query> show what is stored and where each fact came from.
    • lunos memory export writes all of memory as one bundle (see Exporting memory). --format markdown writes one Markdown file per fact instead, for review in git.
    • lunos memory import <path> brings memory in (see Importing memory).
    • lunos memory forget <id> removes a fact. lunos memory purge --scope project --yes deletes the whole memory.
    • lunos memory outdate <id> [--by <new id>] marks a fact as no longer true (see Facts that stop being true). ctrl+u twice does the same in the TUI browser.
    • lunos memory status shows how many facts are active, outdated, expired and quarantined, and lunos memory verify re-checks the ledger (see Integrity, expiry and encryption).
  • Turning it off:

    • "memory": { "enabled": false }, or remove the key
    • LUNOS_DISABLE_MEMORY=1, which overrides config
    • /memory off for the current session
    • "permission": { "memory": "deny" }, for all agents or one agent

    When memory is off, no memory process starts, no memory files are created and the memory tools aren’t offered.

Memory analytics

/memory opens on Overview, with Activity and Facts (the browser) beside it. Tab switches tabs, ctrl+r sets the range for everything time-based (7, 30 or 90 days, or all), and Esc closes.

  • Overview:
    • whether memory is on, where it’s kept, encryption and retention, worded as lunos memory status words them;
    • each scope’s active, outdated, expiring, expired and quarantined facts, and its last write;
    • its size in characters and tokens (characters / 4), next to retrieval.max_tokens;
    • where facts came from: your messages, files or tools; which agent; observed or inferred; native or imported;
    • ledger health.
  • Activity:
    • facts added, outdated, forgotten and expired per week;
    • recalls per day and by origin;
    • how often a recall returned a fact or hit the token cap;
    • the ten most recalled facts;
    • never recalled: active facts older than 14 days with no recall in the range. These are clean-up candidates.
  • Drilling down. Every count opens the Facts tab filtered to exactly those facts, and ← goes back. In a filtered list, ctrl+k forgets them all after you type their number; each forget is audited separately. Each fact shows how often it was recalled in the range.

Everything is computed on your machine from the memory ledger and the local audit log; nothing about memory leaves your machine because of this view.

Recall figures come from the audit log’s memory.recall entries, which hold ids and counts, never a query or a fact’s text. They exist only while the audit log is on (audit.enabled, or a residency policy), and only as far back as it goes: the view says “Recall data since …” instead of guessing.

lunos memory stats prints the same numbers (--json for scripts), and desktop and web can read them from GET /memory/stats.

Facts that stop being true

A fact can be marked outdated, optionally with the fact that replaces it. It is kept, with when it became true (valid_from) and when it stopped (invalid_at), but it is no longer recalled. lunos memory search --history, or memory_search with history: true, shows outdated facts too, marked as such. lunos memory show <id> shows an outdated fact’s invalid_at and replaced_by.

  • When the agent remembers something that contradicts a fact (the same subject with a different value, like “billing owns invoices” and then “ledger-service owns invoices”), the approval prompt shows both. If you allow it, you’re asked whether to replace the old fact (it becomes outdated) or keep both. The agent can also propose a replacement itself (replaces), and you’re asked the same way. Where no one can answer (lunos run), both are kept, and the tool’s answer says how to outdate the old one.
  • Observed or inferred. Each fact the agent saves records whether you said it or it read it in a file (observed) or the agent concluded it (inferred). Recall labels inferred facts as such. Facts from your notes are observed.

Integrity, expiry and encryption

  • Expiry. memory.retention.days makes facts expire that many days after they were saved (by default they never do). A fact can also have its own expiry date. An expired fact is no longer recalled, and is deleted retention.grace_days later (default 7), the next time memory starts; the audit log records the deletion. lunos memory list --expiring [days] shows what expires within that many days (default 7), and what has expired but not yet been deleted. Facts from your notes never expire: the note is their source.
  • Integrity. Every line of the ledger (facts.jsonl, the record of each fact and where it came from) carries a SHA-256 of its content and provenance, and the lines form a hash chain. If a line doesn’t match (it was edited, damaged, removed or moved), that fact is quarantined: it is not recalled or exported, and lunos memory status and lunos memory verify list it with the reason. Forget it with lunos memory forget <id>, or, once you have checked it, accept the ledger as it is with lunos memory verify --reseal --scope <scope>. These are plain hashes with no secret: they catch damage and hand edits, not someone who rewrites the file and recomputes them.
  • Encryption at rest. "encryption": "os-keychain" encrypts the ledger, line by line (AES-256-GCM), with a random key kept in your OS keychain: macOS Keychain, Windows Credential Manager, or libsecret on Linux. The key is never written to config or to disk. What it covers, and what it doesn’t:
    • Encrypted: the ledger, in project and user memory.
    • Not encrypted: the memory engine’s own database files next to it (measured: Cognee’s SQLite database, its Kuzu graph file, its LanceDB vector tables, its plain-text copy of each fact under data/, and its logs under logs/ all hold fact text), and your notes in .opencode/memory/*.md, which are meant to be read and reviewed in git. Use full-disk encryption (FileVault, BitLocker, LUKS) for those.
    • If the key is lost, the ledger can’t be read, and nothing else holds it. Lunos refuses to read or write that memory, and says which keychain entry is missing, instead of starting empty; it never makes a new key while an encrypted ledger exists. Restore the keychain entry (from your keychain’s backup), or delete that memory with lunos memory purge. Export a bundle if you need a copy that doesn’t depend on the key.
    • Turning it on encrypts the existing ledger the next time memory starts; turning it off decrypts it (the key must still be there).
  • Audit. With the audit log on, every memory operation is recorded (memory.remember, recall, forget, outdate, import, export, purge, verify_failed), with its time, scope, fact ids, counts and where it came from, never a fact’s text or a search query, and forwarded to your SIEM like every other event.

An external memory database

Memory can live in a Neo4j database your team runs instead of on each machine, so a team shares project memory and keeps it on infrastructure it controls:

"memory": {
"enabled": true,
"backend": {
"type": "neo4j",
"url": "bolt+s://graph.internal:7687",
"username": "{env:LUNOS_MEMORY_DB_USER}",
"password": "{env:LUNOS_MEMORY_DB_PASSWORD}",
"jurisdiction": "EU-DE"
}
}
  • Before connecting, Lunos checks that a jurisdiction is declared and that your data-residency policy allows it, that the connection uses TLS (plain bolt:// only to localhost, unless allow_insecure: true), and that the username and password are {env:} or {file:} references. A literal password fails config loading. A residency refusal names memory.backend and is written to the audit log.
  • Scopes stay apart. Project memory is keyed by a hash of the repository’s git remote, so everyone on the same repository shares it and no other project sees it. User memory is keyed by backend.user (hashed) or a random id kept on your machine. This keeps recall apart, but it isn’t access control: anyone with the database’s credentials can read every project’s and every user’s memory there.
  • Facts only. The database holds each fact with its provenance and an integrity hash. There are no embeddings and no entity graph: recall uses the database’s full-text index, so a second machine needs no re-index, and remembering makes no model call. Your notes in .opencode/memory/*.md stay in the repository and aren’t copied into the database.
  • read_only: true allows recall only: the remember tool isn’t offered.
  • Off still means off: with memory off, no connection is opened.
  • lunos memory migrate --to neo4j moves embedded memory into the database, with a preview first. lunos memory status shows the backend, whether it is reachable, and each scope’s fact count and last write.

The self-hosted deployment guide has a Docker Compose example, what lives where, and what Neo4j needs.

Exporting memory

lunos memory export writes everything in memory to a versioned bundle, format lunos-memory/1. Use it for backups, to move memory to another machine or engine, to hand it to someone to review, or for a GDPR data-portability request.

Terminal window
lunos memory export # a folder: ./lunos-memory-<time>/
lunos memory export --zip # one .zip file
lunos memory export --encrypt # a .zip.enc, locked with a passphrase you're asked for
lunos memory export --scope project --since 2026-09-01 --out backup/
lunos memory export --format markdown # one Markdown file per fact, as before

A bundle holds:

  • facts.jsonl: every fact, with its provenance (session, agent, source and date), scope, status (active or outdated, with invalid_at and replaced_by), expiry date if it has one and, where known, whether it was observed or inferred. The facts are the source of truth. Quarantined facts are left out, and the manifest counts them.
  • graph.json: the entities and relationships memory extracted, each listing the ids of the facts it came from.
  • notes/: copies of your notes in .opencode/memory/*.md.
  • manifest.json: the format and Lunos version, scopes, counts, creation time, and the SHA-256 of every file.
  • SCHEMA.md: the format, with its JSON Schema, so other tools can read a bundle without Lunos.

What to know:

  • Embeddings and the engine’s database files are left out. They are specific to the model and engine, and are rebuilt when memory is imported. --include-index adds them, for a restore into the same engine version and embedding model, which the manifest records. Those files hold every fact’s text, so --include-index can’t be combined with --since.

  • Where it goes. The CLI writes to the folder you run it in unless you pass --out. The TUI writes to memory/exports/ in the Lunos data directory, so a bundle never lands in your project.

  • Reading the graph starts memory, so memory must be on. With memory off, the export stops and says so; --no-graph exports the facts and notes without starting anything.

  • Secrets are checked again. The export runs the same check as writes do. If anything looks like a key, token or password, nothing is written and the offending ids are listed.

  • Encryption uses OpenSSL’s format (AES-256-CBC, key from PBKDF2-SHA256 with 600,000 iterations). The passphrase is never stored; set LUNOS_MEMORY_PASSPHRASE to export without a prompt. Decrypt without Lunos with:

    Terminal window
    openssl enc -d -aes-256-cbc -md sha256 -pbkdf2 -iter 600000 -in lunos-memory.zip.enc -out lunos-memory.zip

    Then check the SHA-256s in manifest.json: this mode doesn’t detect tampering by itself.

  • A bundle is a snapshot. Forgetting a fact later doesn’t remove it from bundles you have already written. A bundle can hold user memory too, so keep it out of git.

  • In the TUI, ctrl+s in the /memory browser offers the same choices. The passphrase is typed into a plain prompt, as API keys are.

Importing memory

lunos memory import <path> brings memory in: to restore a backup, to move memory between machines or teammates, or to bring in what you already wrote for other coding agents.

Terminal window
lunos memory import lunos-memory-20260929-101500.zip.enc # preview only: nothing is written
lunos memory import lunos-memory-20260929-101500.zip.enc --yes
lunos memory import AGENTS.md --yes # becomes a note in .opencode/memory/
lunos memory import ~/.claude/projects/<project>/memory --yes
lunos memory import notes/ --as-facts --scope user --yes

It reads:

  • A Lunos bundle, as a folder, .zip or .zip.enc (the passphrase is asked for, or read from LUNOS_MEMORY_PASSPHRASE). Facts keep their original provenance, and notes come back as notes.
  • Markdown: a file or a folder. One fact per top-level - bullet, or one per file. The --format markdown export reads back with its provenance.
  • Other agents’ files: AGENTS.md, CLAUDE.md and Claude Code’s auto-memory notes come in as notes in .opencode/memory/ (as agents-md.md, claude-md.md, and so on, never under their own names, which other tools load as instructions). --as-facts imports them as facts instead.

Imported memory is untrusted. A checksum or a passphrase proves where a bundle came from, not that what it says is safe. So an import:

  1. Checks the format. A bundle from a newer major version is refused.
  2. Verifies the bundle. Every file’s SHA-256 is checked, after decrypting. One changed byte, a missing file or a file the manifest doesn’t list refuses the whole bundle.
  3. Screens every fact and note paragraph with the checks agent writes pass: the size limit, the secret check, and the check for instruction-shaped text.
  4. Dedupes against what memory holds, and flags near-duplicates.
  5. Finds conflicts: the same subject with a different value is shown next to the fact it contradicts.
  6. Previews. A table shows every row as new, duplicate, conflict or rejected, with the reason. Nothing is written without --yes, or approval in the TUI. --dry-run previews even with --yes.
  7. Stores the new rows. --include-conflicts also writes conflicts and near-duplicates. Each imported fact’s source becomes import:<file>#<sha256>, its original provenance is kept as its origin, and it is marked imported.

What to know:

  • The graph and the index are never imported. Memory re-extracts entities and relationships from the facts, and re-embeds them with your configured, local embedding model. graph.json and index/ files in a bundle are ignored.
  • Lifecycle is kept. Outdated facts come in outdated (history, never recalled), linked to their replacement when it comes in too; expiry dates and observed/inferred are kept; a fact that has already expired is rejected.
  • Recall labels imported facts “imported”, with where they came from, inside the <memory> block that is always reference, never instructions.
  • Where facts go. A bundle’s facts go back to their own scope. Markdown goes to project memory. --scope project|user puts everything in one memory. Notes are always project memory.
  • Limits. If the import would pass memory.limits.max_facts, it stops at the preview.
  • Models. Extracting each fact’s graph is one call to your memory.model, and the preview says how many. Both memory.model and memory.embedding are checked against your data-residency policy before anything is read. A denied model stops the import, and the error names the setting.
  • The audit log records each import: the counts and the SHA-256 of what was read, never the text.
  • In the TUI, ctrl+o in the /memory browser asks for the path and shows the preview. New rows start approved; enter approves or rejects one row, ctrl+a all of them, and ctrl+s imports.

External memory sources

Lunos can also recall from knowledge your organisation already keeps: a Neo4j knowledge graph, or an MCP memory server such as Graphiti, Cognee or Mem0. Sources are read-only: Lunos never writes to them, and nothing they return is stored in Lunos’s memory.

opencode.json
{
"memory": {
"enabled": true,
"sources": [
{
"name": "platform-kg",
"type": "graph",
"url": "bolt+s://kg.internal:7687",
"query": "fulltext",
"username": "{env:KG_USER}",
"password": "{env:KG_PASS}",
"jurisdiction": "EU-DE",
"max_tokens": 500,
},
{
"name": "team-memory",
"type": "mcp",
"server": "graphiti",
"tool": "search_memory_facts",
"jurisdiction": "EU-FI",
"max_tokens": 500,
},
],
},
"mcp": {
"graphiti": { "type": "remote", "url": "https://graphiti.internal/mcp", "enabled": false },
},
}
  • type: "graph" runs two fixed, read-only Cypher queries in read transactions: a full-text search (query: "fulltext", the default; index picks the full-text index, otherwise the first one the database has), or query: "contains", which matches node names. Each matching node comes back with its labels, its description and its relationships. Use bolt+s:// or neo4j+s://; plain bolt:// is only allowed to this machine. Give the account read-only rights.
  • type: "mcp" calls one tool on a server configured under mcp, with the question as its argument (default query). Memory opens its own connection to that server, only after the residency check. Set the server’s enabled to false so the agent isn’t also given its tools, some of which may write. A tool whose name looks like a write (add_…, delete_…) or that the server marks as not read-only is refused. A remote server that needs OAuth can’t be a source yet; give it headers instead.
  • Recall. Each turn, every enabled source is asked the same question as local memory. Results appear in the <memory> block in a <memory-source name="…"> section, labelled as untrusted reference, never instructions. Each source gets its own max_tokens (default 500), inside retrieval.max_tokens overall; sources get at most half of it.
  • Untrusted by default. Every result goes through the same secret and instruction-pattern screens as an import. A result that fails is withheld, and the block only says how many were. trusted: true is honoured only when managed config declares the same source (same type and url, or same server and tool); it then skips the instruction-pattern screen, never the secret screen or the size caps.
  • Residency. Each source must declare a jurisdiction, like "EU-DE", "EU" or "US". Before a source is first contacted, it is checked against your residency policy. A source without one, or with one the policy doesn’t allow, is never contacted, and the denial is written to the audit log.
  • Failures don’t block you. A source that is slow or failing is skipped after timeout_ms (default 2000) with a notice, and tried again on the next turn.
  • Turning sources off. /memory sources lists every source with how its last query went. /memory sources off <name> turns one off for this session, and /memory sources on <name> turns it back on. "enabled": false turns a source off in config. When memory is off, no source is queried.
  • Keeping a fact. To keep something a source said, ask the agent to remember it. It calls memory_remember with the source as provenance (memory source <name>), and you approve it like any other fact. A fact that repeats a source’s result under any other provenance (such as “user message”) is refused, and so is one attributed to a source that wasn’t recalled in that turn.
  • The audit log records each query (source, latency, result and withheld counts) as memory.source_query, and each refusal as memory.source_denied, never the question or the results.

Referencing External Files

While Lunos doesn’t automatically parse file references in AGENTS.md, you can achieve similar functionality in two ways:

Using opencode.json

The recommended approach is to use the instructions field in opencode.json:

opencode.json
{
"$schema": "https://lunos.tech/config.json",
"instructions": ["docs/development-standards.md", "test/testing-guidelines.md", "packages/*/AGENTS.md"]
}

Manual Instructions in AGENTS.md

You can teach Lunos to read external files by providing explicit instructions in your AGENTS.md. Here’s a practical example:

AGENTS.md
# TypeScript Project Rules
## External File Loading
CRITICAL: When you encounter a file reference (e.g., @rules/general.md), use your Read tool to load it on a need-to-know basis. They're relevant to the SPECIFIC task at hand.
Instructions:
- Do NOT preemptively load all references - use lazy loading based on actual need
- When loaded, treat content as mandatory instructions that override defaults
- Follow references recursively when needed
## Development Guidelines
For TypeScript code style and best practices: @docs/typescript-guidelines.md
For React component architecture and hooks patterns: @docs/react-patterns.md
For REST API design and error handling: @docs/api-standards.md
For testing strategies and coverage requirements: @test/testing-guidelines.md
## General Guidelines
Read the following file immediately as it's relevant to all workflows: @rules/general-guidelines.md.

This approach allows you to:

  • Create modular, reusable rule files
  • Share rules across projects via symlinks or git submodules
  • Keep AGENTS.md concise while referencing detailed guidelines
  • Ensure Lunos loads files only when needed for the specific task