ashlr-plugin 1.36.4

package/skills/ashlr-genome-author/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: ashlr-genome-author
+description: Guidelines for when and how to call ashlr__genome_propose to keep the project genome accurate. Covers post-architectural-decision proposals, correct summary format, and what NOT to propose. Keeps the genome signal-rich without noise.
+---
+
+# Ashlr Genome Author
+
+The genome is the project's living architectural memory. `ashlr__genome_propose` adds new knowledge to it. This skill governs when and how to call it so the genome stays signal-rich.
+
+## When to call `ashlr__genome_propose`
+
+Call it after:
+
+- **A new module is added** — new file(s) that introduce a concept, service, or subsystem not previously in the genome.
+- **A schema change** — database table added/dropped/migrated, or a core TypeScript interface redefined.
+- **An auth or security change** — new middleware, permission model, token strategy, or RLS policy.
+- **A routing change** — new API endpoint, route group, or server registered.
+- **An architectural decision** — choosing a pattern, library, or data model that future contributors need to understand.
+
+## Summary format
+
+Write a **2–5 sentence past-tense summary** that describes:
+1. What was changed or added.
+2. Why (the intent or problem it solves).
+3. Where: end with the relevant file paths.
+
+Example:
+> "Added `hooks/stop-accounting.ts` to finalize session stats on the Stop event. This complements the existing SessionEnd GC path with an idempotency guard so duplicate entries are never written. Files: `hooks/stop-accounting.ts`, `hooks/hooks.json`."
+
+## When NOT to call `ashlr__genome_propose`
+
+- Routine edits (bug fixes, typo corrections, test updates) that don't change the architecture.
+- Edits to files already well-described in the genome with no structural change.
+- Mid-task (wait until the change is complete and stable).
+- More than once per logical change — one proposal per architectural event.
+
+## Section names
+
+Use existing manifest section names when the change belongs to an existing area. Only introduce a new section name when the change is genuinely a new architectural concept.
+
+## Activation
+
+Enable via `/ashlr-genome-author on` or by writing `{"enabled":true}` to `~/.ashlr/genome-author.json`. Toggle off with `/ashlr-genome-author off`.

package/skills/ashlr-lean-tools/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: ashlr-lean-tools
+description: Highest-impact token-saving habits for Claude Code tool use. Read-once, batch edits, orient-before-search, skip verification reads, grep-before-read, concise output at high spend. Reduces session token cost 30–60%.
+---
+
+# Ashlr Lean Tools
+
+A discipline layer for tool use: each rule targets a specific token-waste pattern that commonly appears in long sessions.
+
+## Rules (active when this skill is enabled)
+
+### 1. Read-once
+Do not re-read a file that is already in context. If you opened `src/auth.ts` earlier this session and haven't been told it changed, use the content you already have. Re-reads are the single largest source of avoidable input-token spend.
+
+### 2. Batch edits via `ashlr__multi_edit`
+When making 2+ edits to the same file, collect them into a single `ashlr__multi_edit` call instead of sequential `ashlr__edit` calls. Multi-edit applies all changes in one round-trip and returns a single compact diff.
+
+### 3. Orient before searching
+Run `ashlr__orient` once at the start of each task. The genome overview typically resolves "where does X live?" without any file reads. Skip orient only when continuing work in a file you already have open.
+
+### 4. Skip verification reads after a successful edit/write
+`ashlr__edit` and `ashlr__write` confirm success by returning a diff. Do not read the file again just to confirm the change landed — that's redundant and costs the full file content in tokens.
+
+### 5. Grep-before-read
+Before opening a file to find something, run `ashlr__grep` first. If the grep result shows the relevant lines, use them directly — no full file read needed.
+
+### 6. Shift to concise output when session spend is high
+When the session has accumulated >5,000 tokens of tool-call output, prefer shorter responses: skip preamble, use `file:line` citations instead of quoted blocks, and omit trailing summaries when the diff speaks for itself.
+
+### 7. Prefer `ashlr__bash` over native `Bash` for verbose commands
+`ashlr__bash` auto-compresses long stdout (test runners, git log, find, npm ls) — 60–90% token savings on large output.
+
+## Anti-patterns
+
+- Re-reading a file that hasn't changed since you last read it
+- Two sequential `ashlr__edit` calls on the same file (use `ashlr__multi_edit`)
+- Opening a file just to confirm an edit you just made
+- Running `Read` before `Grep` to find a function
+- Quoting large file contents in prose when a `file:line` reference suffices
+
+## Activation
+
+Enable via `/ashlr-lean-tools on` or by writing `{"enabled":true}` to `~/.ashlr/lean-tools.json`. Toggle off with `/ashlr-lean-tools off`.

package/skills/ashlr-search/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: ashlr-search
+description: Genome-aware search habits for Claude Code. Prefer ashlr__grep and ashlr__glob over native scans; compose multi-term queries; trust genome summaries; orient once before searching. Reduces redundant reads and search token cost 40–70%.
+---
+
+# Ashlr Search
+
+Shift every search operation to the genome-aware layer so redundant file reads are eliminated before they happen.
+
+## Core rules (active when this skill is enabled)
+
+1. **Orient first.** Run `ashlr__orient` once at the start of each task — before any grep or glob. The genome overview often answers the "where does X live?" question without a single file read.
+
+2. **Prefer `ashlr__grep` over native `Grep`.** `ashlr__grep` is genome-aware: when a `.ashlrcode/genome/` directory exists it returns pre-summarized relevant sections instead of raw ripgrep output. The token cost is 70–90% lower on large repos.
+
+3. **Prefer `ashlr__glob` over native `Glob`.** Same reason — genome-aware glob filters to relevant paths and avoids returning thousands of lines for broad patterns.
+
+4. **Compose multi-term queries with `|` alternation.** A single call `ashlr__grep("auth|session|token")` is cheaper than three sequential calls. Combine related terms whenever the goal is "find anything touching X".
+
+5. **Trust genome section summaries.** When `ashlr__grep` returns a genome section match with a summary, read the summary — do NOT immediately open the referenced file unless you need exact line content for an edit. Genome summaries are curated; they reflect what actually matters in that section.
+
+6. **Do not re-search what's already in context.** If a previous tool call already returned content for a file or pattern, use that result. Re-running the same grep costs tokens and returns nothing new.
+
+## Anti-patterns
+
+- Running native `Grep` when `ashlr__grep` is available
+- Running 3+ sequential single-term greps instead of one combined query
+- Reading a full file after a genome summary already answered the question
+- Globbing broad patterns (`**/*.ts`) without first checking the genome manifest
+
+## Example
+
+```
+# Good: orient first, then one composed grep
+ashlr__orient()
+ashlr__grep("authMiddleware|verifyToken|session.userId")
+
+# Bad: three native greps, no orient
+Grep("authMiddleware")
+Grep("verifyToken")
+Grep("session.userId")
+```
+
+## Activation
+
+Enable via `/ashlr-search on` or by writing `{"enabled":true}` to `~/.ashlr/search.json`. Toggle off with `/ashlr-search off`.