ashlr-plugin 1.36.4

package/.agents/plugins/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "ashlr-marketplace",
+  "interface": {
+    "displayName": "Ashlr"
+  },
+  "plugins": [
+    {
+      "name": "ashlr",
+      "source": {
+        "source": "local",
+        "path": "."
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}

package/.claude-plugin/marketplace.json

@@ -0,0 +1,39 @@
+{
+  "name": "ashlr-marketplace",
+  "owner": {
+    "name": "AshlrAI",
+    "url": "https://github.com/ashlrai"
+  },
+  "metadata": {
+    "description": "Open-source Claude Code plugin — 40 token-efficient MCP tools, 34 slash commands, GitHub OAuth sign-in, auto-genome from public repos, cloud-genome pull, per-session accounting, animated status line. MIT, opt-in telemetry.",
+    "version": "1.36.4"
+  },
+  "plugins": [
+    {
+      "name": "ashlr",
+      "source": {
+        "source": "url",
+        "url": "https://github.com/ashlrai/ashlr-plugin.git"
+      },
+      "description": "Token-efficient MCP tools for Claude Code — open-source WOZCODE alternative. Mean -57% savings overall on real codebases.",
+      "version": "1.36.4",
+      "author": {
+        "name": "Mason Wyatt",
+        "url": "https://github.com/ashlrai"
+      },
+      "homepage": "https://plugin.ashlr.ai/",
+      "repository": "https://github.com/ashlrai/ashlr-plugin",
+      "license": "MIT",
+      "category": "token-efficiency",
+      "keywords": [
+        "claude-code",
+        "mcp",
+        "token-efficiency",
+        "wozcode-alternative",
+        "github-oauth",
+        "genome",
+        "cloud-genome"
+      ]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,36 @@
+{
+  "name": "ashlr",
+  "version": "1.36.4",
+  "description": "Open-source Claude Code plugin — 40 MCP tools and 34 slash commands, hybrid LLM summarization (Anthropic Haiku 4.5 default + ONNX offline + local opt-in), GitHub OAuth sign-in, auto-genome from public repos, cloud-genome pull on session start, PreToolUse redirect hooks (ASHLR_HOOK_MODE), unified $/MTok pricing (ASHLR_PRICING_MODEL), per-session token accounting, opt-in telemetry, animated status line, shareable SVG savings badge. MIT.",
+  "author": {
+    "name": "Mason Wyatt",
+    "url": "https://github.com/ashlrai"
+  },
+  "homepage": "https://plugin.ashlr.ai/",
+  "repository": "https://github.com/ashlrai/ashlr-plugin",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "token-efficiency",
+    "mcp",
+    "ashlrcode",
+    "wozcode-alternative",
+    "github-oauth",
+    "genome",
+    "cloud-genome"
+  ],
+  "statusLine": {
+    "type": "command",
+    "command": "bun run ${CLAUDE_PLUGIN_ROOT}/scripts/savings-status-line.ts"
+  },
+  "mcpServers": {
+    "ashlr": {
+      "command": "node",
+      "args": [
+        "${CLAUDE_PLUGIN_ROOT}/scripts/bootstrap.mjs",
+        "servers/_router.ts"
+      ]
+    }
+  }
+}

package/.codex/agents/README.md

@@ -0,0 +1,9 @@
+# Ashlr Codex Agents
+
+These are Codex-native companion prompts for Ashlr workflows:
+
+- `ashlr-explorer.md` maps unfamiliar code with read-only, low-token habits.
+- `ashlr-worker.md` implements scoped, disjoint slices when parallel work is useful.
+
+They are intentionally separate from the Claude Code agent prompts under
+`agents/`, which use Claude-specific model and `Task` terminology.

package/.codex/agents/ashlr-explorer.md

@@ -0,0 +1,36 @@
+---
+name: ashlr-explorer
+type: explorer
+description: Read-only Codex explorer for token-efficient codebase mapping with Ashlr MCP tools.
+---
+
+# Ashlr Explorer
+
+Use this agent for bounded, read-only research before implementation.
+
+## Rules
+
+- Stay read-only. Do not edit files, stage changes, commit, delete, or mutate config.
+- Prefer `ashlr__orient`, `ashlr__tree`, `ashlr__grep`, and `ashlr__read` before native scans when they reduce context.
+- Use native tools only for tiny files, exact line inspection, or when an Ashlr MCP tool is unavailable.
+- Keep the answer short, cited, and actionable.
+
+## Workflow
+
+1. Start with `git status --short` and the smallest relevant tree or orient call.
+2. Identify entrypoints, ownership boundaries, existing helpers, and tests.
+3. Read only files that answer the assigned question.
+4. Return concrete findings with `path:line` references and remaining uncertainty.
+
+## Output
+
+```text
+Findings
+- path/to/file.ts:42 - concrete observation and why it matters.
+
+Risks
+- path/to/file.ts:88 - edge case or integration risk.
+
+Next
+- The parent agent should inspect or change ...
+```

package/.codex/agents/ashlr-worker.md

@@ -0,0 +1,38 @@
+---
+name: ashlr-worker
+type: worker
+description: Scoped Codex worker for disjoint Ashlr implementation slices.
+---
+
+# Ashlr Worker
+
+Use this agent only when the parent assigns a concrete implementation slice with an explicit file or module ownership boundary.
+
+## Rules
+
+- You are not alone in the codebase. Do not revert or overwrite changes outside your assigned scope.
+- Keep edits limited to the files or modules named by the parent.
+- Prefer existing repo helpers and patterns. Avoid new abstractions unless they remove real complexity.
+- Use Ashlr MCP tools for large reads/searches; use native patching for precise edits.
+- Run the narrowest useful verification for your slice and report exact commands.
+
+## Workflow
+
+1. Re-read the assigned files and nearby tests.
+2. Make the smallest complete change for the assigned slice.
+3. Add or update focused tests when behavior changes.
+4. Run verification.
+5. Report changed files, verification, and any unresolved risk.
+
+## Output
+
+```text
+Changed
+- path/to/file.ts - what changed.
+
+Verified
+- command - result.
+
+Notes
+- Any follow-up the parent must integrate.
+```

package/.codex-plugin/plugin.json

@@ -0,0 +1,45 @@
+{
+  "name": "ashlr",
+  "version": "1.36.4",
+  "description": "Multi-host AI coding efficiency layer for Codex and Claude Code: 40 MCP tools, Codex skills, nudge-first hooks, genome memory, and token savings accounting.",
+  "author": {
+    "name": "Mason Wyatt",
+    "url": "https://github.com/ashlrai"
+  },
+  "homepage": "https://plugin.ashlr.ai/",
+  "repository": "https://github.com/ashlrai/ashlr-plugin",
+  "license": "MIT",
+  "keywords": [
+    "codex",
+    "claude-code",
+    "mcp",
+    "token-efficiency",
+    "ashlrcode",
+    "genome",
+    "cloud-genome"
+  ],
+  "skills": "./skills/",
+  "hooks": "./hooks/codex-hooks.json",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "Ashlr",
+    "shortDescription": "Token-efficient MCP tools and workflow skills for Codex.",
+    "longDescription": "Ashlr gives Codex a first-class efficiency layer: 40 MCP tools for compact read/search/edit/bash workflows, skills for lean coding habits, nudge-first hooks, genome memory, and local savings accounting. Claude Code remains fully supported with its richer slash-command and status-line surfaces.",
+    "developerName": "AshlrAI",
+    "category": "Productivity",
+    "capabilities": [
+      "MCP",
+      "Skills",
+      "Hooks"
+    ],
+    "websiteURL": "https://plugin.ashlr.ai/",
+    "privacyPolicyURL": "https://plugin.ashlr.ai/privacy",
+    "termsOfServiceURL": "https://plugin.ashlr.ai/terms",
+    "defaultPrompt": [
+      "Use Ashlr tools to inspect this repo efficiently.",
+      "Run an Ashlr doctor check for Codex.",
+      "Refresh the project genome after this change."
+    ],
+    "brandColor": "#0F766E"
+  }
+}

package/.mcp.json

@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "ashlr": {
+      "command": "ashlr-mcp",
+      "args": [],
+      "cwd": ".",
+      "env": {
+        "ASHLR_MCP_HOST": "codex-cli",
+        "ASHLR_CODEX_HOOK_MODE": "nudge"
+      },
+      "instructions": "Prefer Ashlr tools when they reduce context: use ashlr__read for large files, ashlr__grep for search, ashlr__tree for directory maps, ashlr__bash for verbose shell output, ashlr__savings for token/cost accounting, and ashlr__genome_* tools for project memory. Pass cwd explicitly or set ASHLR_ALLOW_PROJECT_PATHS for workspaces outside the MCP launch cwd."
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AshlrAI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,311 @@
+# ashlr-plugin
+
+> **Cut Codex and Claude Code token usage by −57% on real codebases.**
+> _TS −62% · Python −65% · Rust −44%_ — measured on `vercel/ai`, `pandas`, and `tokio`.
+> 95% CI reported by the benchmark runner. Reproduce with `bun run scripts/run-benchmark.ts --compare`. ([full methodology](docs/benchmarks.md))
+
+40 MCP tools that replace high-volume `Read` / `Grep` / `Edit` / `Bash` workflows with versions that return **less** without losing what matters. Claude Code gets automatic PreToolUse redirects (`ASHLR_HOOK_MODE=redirect`); Codex gets first-class plugin packaging, MCP, skills, and nudge-first hooks.
+
+> **Requires [Bun ≥ 1.3](https://bun.sh/)** — interactive installers can offer to install Bun; piped/non-interactive installs skip that prompt and rely on MCP bootstrap if Bun is missing. Verify with `bun --version` first.
+>
+> ```bash
+> curl -fsSL https://bun.sh/install | bash
+> ```
+
+```bash
+# macOS / Linux
+curl -fsSL https://plugin.ashlr.ai/install.sh | bash
+
+# Windows (PowerShell)
+irm https://raw.githubusercontent.com/ashlrai/ashlr-plugin/main/docs/install.ps1 | iex
+```
+
+The npm package exposes `ashlr-plugin` for CLI workflows and `ashlr-mcp` for MCP hosts. It requires Bun. From v1.36.4, use `ashlr-plugin stats`, `ashlr-plugin tools`, and other Plugin commands in place of the former `ashlr` alias; `ashlr` remains available to Ashlr Hub. MCP server registration names and tool names are unchanged.
+
+**Landing page:** [plugin.ashlr.ai](https://plugin.ashlr.ai/) · **Docs:** [plugin.ashlr.ai/docs](https://plugin.ashlr.ai/docs) · **Core library:** [`@ashlr/core-efficiency`](https://github.com/ashlrai/ashlr-core-efficiency) · **License:** MIT
+
+> **Open-source and honestly benchmarked.** The −57% headline is reproducible on your own code with `bun run scripts/run-benchmark.ts --compare` ([methodology](docs/benchmarks.md)). Every ashlr savings figure includes a 95% CI. Telemetry is off by default. Compare against closed, self-benchmarked alternatives with `/ashlr-benchmark --compare`.
+
+[![CI (Linux · macOS · Windows)](https://github.com/ashlrai/ashlr-plugin/actions/workflows/ci.yml/badge.svg?branch=main&event=push)](https://github.com/ashlrai/ashlr-plugin/actions/workflows/ci.yml?query=branch%3Amain+event%3Apush)
+
+**Tested on:** Ubuntu 22.04 · macOS 14 (Sonoma) · Windows Server 2022 · TypeScript hooks (no bash required)
+
+---
+
+## What's new in v1.36
+
+- **Codex-native plugin packaging** — `.codex-plugin/plugin.json`, `.mcp.json`, Codex workflow skills, Codex explorer/worker agent guidance, and portable Codex hooks ship in the same package as the Claude Code plugin.
+- **Reliable Codex MCP launch** — `ashlr-mcp` starts the router directly with `ASHLR_MCP_HOST=codex-cli`, workspace-aware `cwd` behavior, and `ASHLR_ALLOW_PROJECT_PATHS` support for non-plugin launch directories.
+- **Codex nudge-first hooks** — Codex hooks now inject compact-tool guidance for Bash, apply_patch, Read/Grep/Glob, Edit/MultiEdit, Write, and high-value Ashlr MCP calls without forcing redirects by default.
+- **Host-neutral CLI workflows** — `ashlr-plugin codex-doctor`, `ashlr-plugin codex-install --dry-run`, `ashlr-plugin codex-start`, `ashlr-plugin codex-resume`, `ashlr-plugin codex-end`, and `ashlr-plugin genome-refresh` give Codex users the same operational surface without writing Claude config.
+- **Four discipline skills** — `/ashlr-search`, `/ashlr-lean-tools`, `/ashlr-genome-author`, `/ashlr-cost-refactor`. Each enforces a specific anti-waste pattern; each persists in `~/.ashlr/<name>.json`. Toggle with `/ashlr-<name> on/off`.
+- **`/ashlr-efficient`** — output structure reshaper. Enforces answer-first (inverted pyramid), inline code for all identifiers, tables for 3+ item comparisons, and no transitional filler. Works standalone or alongside `/ashlr-brief`.
+- **Two lifecycle hooks** — `SubagentStop` rolls up subagent savings to the session log and fires background genome consolidation; `Stop` finalises session stats with an idempotency guard. (Re-orientation after context compaction is handled by the `SessionStart` compact hook, the only event that can inject context.)
+- **API-measured savings mode** — when `ANTHROPIC_API_KEY` is set, token counts upgrade from `(est.)` to `(API-measured)` once ≥10 calls have been verified via the Anthropic API. Fire-and-forget; SHA-256 cached; never blocks a tool call.
+- **Benchmark transparency** — `scripts/run-benchmark.ts` now reports a 95% bootstrap confidence interval alongside the headline. New flags: `--compare` (A/B table), `--validate-tokenizer` (API spot-check of the chars/4 heuristic). See [benchmark methodology](docs/benchmarks.md).
+
+<details>
+<summary>v1.33 highlights</summary>
+
+- **First-call savings projection** — see your annual savings extrapolated on your very first ashlr call.
+- **Multi-host MCP** — works in Codex, Claude Code, Cline, Claude Desktop, Cursor, Goose, and generic MCP hosts (`ASHLR_MCP_HOST` env var).
+- **`/ashlr-orchestrate-status`** — inspect past orchestration runs with per-node timings + tokens.
+- **Orchestration retry + handoff budget** — per-node retry-with-backoff; HANDOFF_PAYLOAD capped at 8KB.
+- **Orchestration central quota accounting** — `orchestration_usage` table for Team-tier soft-throttle.
+- **Bun ≥ 1.3 prereq surfaced** + wizard restart enforcement — closes 2 fatal first-touch cliffs.
+- **Orchestrator overhead bench** — measured ~5-30ms/node, 2.8× parallel speedup vs sequential.
+- **Pre-existing tsc errors fixed** + permanent dashboard date-drift fix via clock injection.
+
+</details>
+
+## What's new in v1.33 (archived)
+
+<details>
+<summary>v1.32 highlights</summary>
+
+- **`/ashlr-orchestrate`** — multi-agent task graphs with parallel execution, dry-run renderer, and tier-gated subprocess wiring.
+- **`/ashlr-orchestrate-status`** — inspect past orchestration runs with per-node telemetry and 2.8× measured parallel speedup.
+- **Live genome** — PR-aware + commit-aware sections via git post-commit hook and GitHub webhook delta sync.
+- **AI-Native discoveries** — LLM synthesizes `discovery` sections from your commit history automatically.
+- **Predictive prefetch** *(Pro/Team)* — background warm-cache on every `ashlr__read` cuts repeat-hit latency.
+- **PR + issue retrieval** — `ashlr__grep --include-prs --include-issues --since-days` pulls live GitHub context.
+- **Freshness badges** in genome retrieval surface staleness so you trust the answer.
+- **Cross-language bench:** TS −61.3% · Python −63.1% · Rust −46.8% (cross-language headline `-57.1%` holds).
+- **Founder WAD-D dashboard** at `/admin/wad-d` — daily-active records + segment breakdown + discovery propagation.
+
+</details>
+
+---
+
+## Multi-host MCP
+
+Works with Codex, Claude Code (default), [Cline](https://github.com/cline/cline), Claude Desktop, Cursor, Goose, and generic MCP hosts. The 40 MCP tools, stats accounting, and genome retrieval are host-agnostic; savings and accounting apply when the host calls Ashlr MCP tools. Codex support is packaged through `.codex-plugin/plugin.json`, `.mcp.json`, Codex skills, and `hooks/codex-hooks.json` in nudge mode. Claude-only extras remain explicitly labeled: auto redirects, status line, slash commands, and OAuth bootstrap. See [plugin.ashlr.ai/docs](https://plugin.ashlr.ai/docs) or [`docs/multi-host-mcp.md`](docs/multi-host-mcp.md) for setup snippets.
+
+---
+
+## Permissions — stop the prompts first
+
+Run this once after install so Claude Code stops asking on every tool call:
+
+```
+/ashlr-allow
+```
+
+That adds ashlr MCP wildcards to `permissions.allow` in `~/.claude/settings.json`. It is idempotent. Run `/reload-plugins` after changing permissions, or fully quit and restart Claude Code if reload is unavailable.
+
+---
+
+## 10-second demo
+
+```
+# 1. Install
+curl -fsSL https://plugin.ashlr.ai/install.sh | bash
+# Inside Claude Code:
+/plugin marketplace add ashlrai/ashlr-plugin
+/plugin install ashlr@ashlr-marketplace
+
+# 2. Use — read a large file (raw would be ~8,400 tokens)
+ashlr__read  { "path": "src/server.ts" }
+# Returns snipCompact view: head + tail, elided middle — ~1,700 tokens
+
+# 3. Check savings
+/ashlr-savings
+```
+
+```
+Session savings  ·  ashlr-plugin v1.36.0
+────────────────────────────────────────
+  ashlr__read      6 calls    −42,180 tok   $0.13
+  ashlr__grep      3 calls    −11,040 tok   $0.03
+  ashlr__edit      2 calls     −3,200 tok   $0.01
+  ─────────────────────────────────────────────
+  Session total               −56,420 tok   $0.17
+  Lifetime total             −284,900 tok   $0.86
+  7-day sparkline   ▁▂▃▃▅▆█
+```
+
+---
+
+## What you get
+
+Core efficiency tools (replace built-ins with lower-token equivalents):
+
+| MCP tool | Description |
+|---|---|
+| `ashlr__read` | `snipCompact` + LLM summary on files > 16 KB (Anthropic Haiku 4.5 default, ONNX/local fallback). Mean **−82.1%** on the v1.22 bench. Line numbers preserved on code files. |
+| `ashlr__grep` | Genome-aware RAG when `.ashlrcode/genome/` or cloud genome exists; ripgrep fallback with LLM summary. |
+| `ashlr__edit` | In-place search/replace — returns diff summary only, not the full file. Levenshtein candidates on miss. |
+| `ashlr__edit_structural` | AST-aware rename (Unicode identifiers: `café`, `π`, CJK) + cross-file rename with `anchorFile` + `maxFiles` + shadowing guard + dryRun + extract-function with return-value detection (0 / 1 / N outputs). `.ts/.tsx/.js/.jsx`. |
+| `ashlr__multi_edit` | Batch multiple search/replace edits in one call. |
+| `ashlr__savings` | Live token-savings dashboard: session + lifetime + per-tool breakdown. |
+
+Shell, data, and web tools:
+
+| MCP tool | Description |
+|---|---|
+| `ashlr__bash` | Shell with auto-compression + pluggable summarizer registry (`servers/_bash-summarizers-registry.ts`) covering `git log`/`git diff`/`git show`, `ls`, `ps`, `npm ls`, unified test-runner output, `tsc`, and npm/bun/yarn/pnpm installs. Long-running commands survive timeouts via process-group SIGKILL. |
+| `ashlr__bash_start` / `_tail` / `_stop` / `_list` | Long-running background command control plane. |
+| `ashlr__sql` | SQLite + Postgres one-shot. `explain` and `schema` modes. LLM summary on 100+ row results. |
+| `ashlr__http` | HTTP fetch with readable-extract (HTML), array-elide (JSON), and private-host safety. |
+| `ashlr__webfetch` | Fetch + extract web pages with token budget. LLM summarization kicks in at 4 KB (web content is denser than code), 100 KB hard cap. |
+| `ashlr__logs` | Tail with level filter + dedupe + LLM summary. |
+| `ashlr__diff` | Adaptive git diff (stat/summary/full) with LLM summary on big diffs. |
+| `ashlr__diff_semantic` | Semantic diff with meaning-aware change grouping. |
+| `ashlr__test` | Structured test-runner output parser — bun/vitest/jest/pytest/go test. Compresses runner noise into one failure block per failure. |
+
+Codebase navigation:
+
+| MCP tool | Description |
+|---|---|
+| `ashlr__tree` | gitignore-aware directory tree with per-dir truncation + size/LOC modes. |
+| `ashlr__glob` | gitignore-aware file glob with size/LOC metadata. |
+| `ashlr__ls` | Directory listing with size metadata. |
+| `ashlr__orient` | Codebase orientation: entry points, key files, dependency graph. |
+
+Genome + GitHub:
+
+| MCP tool | Description |
+|---|---|
+| `ashlr__genome_propose` / `_consolidate` / `_status` | Active genome scribe loop — keeps `.ashlrcode/genome/` current as you code. |
+| `ashlr__issue` / `ashlr__pr` | GitHub issue and PR read ops. |
+| `ashlr__issue_create` / `ashlr__issue_close` | GitHub issue write ops. Self-approval guard + `ASHLR_REQUIRE_GH_CONFIRM=1` opt-in confirmation. |
+| `ashlr__pr_comment` / `ashlr__pr_approve` | GitHub PR write ops. `pr:"current"` resolves via `gh pr view`. No destructive ops (no merge/close/delete). |
+| `ashlr__ask` | Ask a question, get a structured answer with citations. |
+
+See [docs/architecture.md](./docs/architecture.md) for the full tool registry and router layout.
+
+---
+
+## Pro cloud
+
+ashlr Pro connects to a hosted backend at `https://api.ashlr.ai`, unlocking
+features that require server-side state:
+
+| Feature | What it does |
+|---|---|
+| **Cross-machine stats** | Aggregate token savings across all your machines. `GET /v1/stats/aggregate` returns `machine_count` + combined lifetime totals. |
+| **Hosted summarizer** | `POST https://api.ashlr.ai/llm/summarize` — cloud inference via xAI Grok 4.3. Falls back to local summarization or snipCompact when unavailable. |
+| **Team genome** | Encrypted genome sync across teammates. DEKs wrapped with X25519 — only key-holders can decrypt (`/ashlr-genome-team-init`). |
+
+**Privacy:** telemetry is off by default and explicit opt-in only (`ASHLR_TELEMETRY=on`). The `sessionId`
+is an opaque 16-char hex value per session — never your user identity — and
+is stored server-side as a SHA-256 hash. File paths and content are never
+sent. See [plugin.ashlr.ai/docs](https://plugin.ashlr.ai/docs) for the full privacy
+contract (internal: [`docs/telemetry.md`](./docs/telemetry.md)).
+
+**Production URL:** `https://api.ashlr.ai`
+
+The `/ashlr-doctor` command includes a **cloud** check that pings
+`/healthz` with a 3-second timeout and reports latency. Set
+`ASHLR_API_URL_DISABLE=1` to suppress it in offline environments.
+
+---
+
+## Status-line
+
+The status bar shows live session savings with a 7-day Braille sparkline:
+
+```
+┌─────────────────────────────────────────────┐
+│  ashlr  −0 tok  $0.00  ▁▁▁▁▁▁▁  idle       │
+└─────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────┐
+│  ashlr  −12,480 tok  $0.04  ▁▂▃▄▅▆█  ██    │
+└─────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────┐
+│  ashlr  −48,200 tok  $0.14  ▁▃▅▆██  ▓▓▓ !! │
+└─────────────────────────────────────────────┘
+```
+
+`!!` appears when context pressure is high. Install:
+
+```bash
+bun run ~/.claude/plugins/cache/ashlr-marketplace/ashlr/<version>/scripts/install-status-line.ts
+```
+
+---
+
+## Install
+
+**Prerequisites:** **[Bun ≥ 1.3](https://bun.sh)** and at least one supported host: Codex CLI, Claude Code, Cursor, Goose, or another MCP-capable client. Interactive installers can offer to install Bun; piped/non-interactive installs skip that prompt and rely on MCP bootstrap if Bun is missing. Verify with `bun --version` first, or install: `curl -fsSL https://bun.sh/install | bash`. No account, no API key.
+
+```bash
+# Claude Code one-liner
+curl -fsSL https://plugin.ashlr.ai/install.sh | bash
+```
+
+For Codex:
+
+```bash
+git clone https://github.com/ashlrai/ashlr-plugin
+cd ashlr-plugin && bun install
+codex plugin marketplace add ashlrai/ashlr-plugin
+codex plugin add ashlr@ashlr-marketplace
+bun run scripts/cli.ts codex-doctor --json
+```
+
+For Claude Code:
+
+```
+/plugin marketplace add ashlrai/ashlr-plugin
+/plugin install ashlr@ashlr-marketplace
+/reload-plugins
+```
+
+Verify with `/ashlr-status`. If `/reload-plugins` is unavailable or `/ashlr-status` does not see the plugin, fully quit and restart Claude Code.
+
+**Manual install:**
+
+```bash
+git clone https://github.com/ashlrai/ashlr-plugin \
+  ~/.claude/plugins/cache/ashlr-marketplace/ashlr
+cd ~/.claude/plugins/cache/ashlr-marketplace/ashlr && bun install
+# Then inside Claude Code:
+# /plugin marketplace add ashlrai/ashlr-plugin
+# /plugin install ashlr@ashlr-marketplace
+# /reload-plugins
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `/ashlr-help` | List every ashlr slash command grouped by purpose (Onboarding / Token meter / Genome / Upgrade / Diagnostics) |
+| `/ashlr-allow` | Auto-approve every ashlr MCP tool — covers canonical `mcp__plugin_ashlr_ashlr__ashlr__*` names, run once after install |
+| `/ashlr-status` | Plugin health + MCP server reachability + genome detection |
+| `/ashlr-savings` | Live dashboard: session + lifetime + per-tool + 7-day sparkline |
+| `/ashlr-doctor` | 11-check diagnostic — deps, MCP reachability, hooks, settings |
+| `/ashlr-tour` | 60-second guided walkthrough on your current project |
+| `/ashlr-benchmark` | Token-savings benchmark against your current project |
+| `/ashlr-genome-init` | Initialize `.ashlrcode/genome/` for the −84% grep path |
+| `/ashlr-ollama-setup` | Diagnose Ollama for `--summarize`; pull recommended 3B model |
+| `/ashlr-settings` | View or change plugin toggles |
+| `/ashlr-update` | `git pull` + `bun install` + report what changed |
+
+---
+
+## Free vs Pro
+
+The free tier is the product — 40 MCP tools, 34 slash commands, the full genome scribe loop, and every benchmark included. No account required.
+
+Pro ($12/mo, 7-day trial) adds cloud infrastructure for developers who need it: cross-machine stats sync, hosted embedding retrieval, cloud LLM summarizer (no local Ollama required), and a live auto-updating savings badge. Team ($24/user/mo, min 3) adds shared encrypted team genome, org savings dashboard, policy packs, and SSO.
+
+Run `/ashlr-upgrade` to upgrade, or see [plugin.ashlr.ai/docs/pro/pricing](https://plugin.ashlr.ai/docs/pro/pricing) for the full comparison.
+
+---
+
+## Architecture
+
+See [plugin.ashlr.ai/docs/contributing/architecture](https://plugin.ashlr.ai/docs/contributing/architecture) for how the tools, hooks, and genome scribe loop fit together. Internal notes: [`docs/architecture.md`](./docs/architecture.md).
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
+## License
+
+MIT — [LICENSE](./LICENSE).

package/agents/ashlr-code.md

@@ -0,0 +1,69 @@
+---
+name: ashlr:code
+description: Main AshlrCode agent — token-efficient coding, editing, search. Delegates aggressively to ashlr:explore and ashlr:plan when appropriate.
+model: sonnet
+---
+
+You are **ashlr:code**, the main agent of the ashlr-plugin token-efficiency layer.
+
+## Your tools: prefer these over the built-ins
+
+You have three MCP tools that replace Claude Code's defaults with lower-token alternatives. Use them by default:
+
+| When you would use | Call instead |
+|--------------------|--------------|
+| `Read` on a file > 2KB | `ashlr__read` |
+| `Grep` in a repo with `.ashlrcode/genome/` | `ashlr__grep` |
+| `Grep` in a repo without a genome | `ashlr__grep` (falls back to ripgrep + truncation) |
+| `Edit` with > 200 chars of before/after | `ashlr__edit` |
+
+The built-in tools remain available for edge cases (binary files, non-genome `.txt` searches, etc.).
+
+## Delegation — this is the point of the plugin
+
+You have two sub-agents. Spawn them via the `Task` tool with the matching `subagent_type`. **Delegation is how this plugin actually saves tokens** — every delegated call runs on haiku, which is ~1/10 the cost of sonnet.
+
+### Delegate to `ashlr:explore` when:
+
+- The user asks "how does X work?" / "where is Y?" / "why is this here?"
+- You need to understand code you haven't seen yet — any unfamiliar file over ~200 LOC
+- You're about to make changes and don't yet have a mental model of the surrounding system
+- You've opened 3+ files just to orient yourself
+
+**Concrete signal: if you catch yourself calling `ashlr__read` or `Grep` more than 3 times in a row to understand code before making a change, stop and delegate to `ashlr:explore` instead.**
+
+### Delegate to `ashlr:plan` when:
+
+- The task touches 3+ files
+- The task requires architectural judgment (new modules, refactors, interface design)
+- The user asked "how should we..." / "what's the best way to..."
+- You're about to start a multi-step implementation and don't have a clear sequence
+
+**Concrete signal: before any code change that needs more than a single Edit/Write call, ask yourself: "would a quick plan help here?" If yes, delegate to `ashlr:plan` first.**
+
+### Handle yourself:
+
+- Actual code edits (sonnet is worth it for correctness)
+- Running tests / lint / typecheck after changes
+- Git operations (status, diff, commit — but NEVER destructive without explicit user confirmation)
+- Responding to the user's final message
+
+## Savings rhythm
+
+Every ~10 tool calls, or at the end of a meaningful unit of work, call `ashlr__savings` once and include the output in your next message to the user. They're paying for nothing if they can't see what's saved.
+
+## Style
+
+- Terse. No trailing summaries — the diff and the savings output are the summary.
+- `file:line` references when pointing at code, not quoted blocks.
+- If you hit an obstacle, state it plainly. Do not loop on failing calls — diagnose instead.
+
+## Destructive operations — always confirm
+
+Before any of the following, pause and ask the user:
+
+- `rm -rf`, bulk file deletion
+- `git reset --hard`, `git push --force`, branch deletion
+- Dropping tables, deleting data
+- Modifying CI/deploy config
+- Installing/removing system packages