ashlr-plugin 1.36.4

package/hooks/stop-accounting.ts

@@ -0,0 +1,152 @@
+#!/usr/bin/env bun
+/**
+ * stop-accounting.ts — Stop hook.
+ *
+ * Deterministic session finalization that complements SessionEnd.
+ *
+ * Idempotency guard: before appending to ~/.ashlr/session-log.jsonl, reads
+ * the last ~3 lines and skips if a session_end/stop entry for this session
+ * already exists within the last 60 seconds.
+ *
+ * Stop is a decision-control event: it does NOT support hookSpecificOutput /
+ * additionalContext. This hook does its side effect (the idempotent session-log
+ * write) and exits silently. Per-session savings are surfaced via the status
+ * line and /ashlr-savings — Stop fires every turn, so a summary here is noise.
+ *
+ * Env toggles:
+ *   ASHLR_SESSION_LOG=0 — skip log append entirely
+ *
+ * Contract: never throws, always exits 0.
+ */
+
+import { appendFile, readFile } from "fs/promises";
+import { homedir } from "os";
+import { join, dirname } from "path";
+
+import { noteHookError } from "./_hook-errors";
+import { currentSessionId } from "../servers/_stats";
+
+interface LogEntry {
+  ts?: string;
+  event?: string;
+  session?: string;
+  [key: string]: unknown;
+}
+
+interface StopPayload {
+  session_id?: string;
+  [key: string]: unknown;
+}
+
+const IDEMPOTENCY_WINDOW_MS = 60_000;
+
+/** Read the last N lines from a file. Returns [] if the file doesn't exist. */
+async function readLastLines(path: string, n: number): Promise<string[]> {
+  try {
+    const raw = await readFile(path, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    return lines.slice(-n);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a session_end or stop entry for `sessionId` already exists
+ * within the last 60 seconds in the last 3 lines.
+ */
+export function isAlreadyRecorded(lines: string[], sessionId: string): boolean {
+  const cutoff = Date.now() - IDEMPOTENCY_WINDOW_MS;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line) as LogEntry;
+      if (
+        entry.session === sessionId &&
+        (entry.event === "session_end" || entry.event === "stop") &&
+        entry.ts &&
+        new Date(entry.ts).getTime() >= cutoff
+      ) {
+        return true;
+      }
+    } catch { /* skip malformed lines */ }
+  }
+  return false;
+}
+
+async function main(): Promise<void> {
+  try {
+    let payload: StopPayload = {};
+    // Drain stdin defensively. Codex includes session_id in this payload.
+    try {
+      if (!process.stdin.isTTY) {
+        const chunks: Buffer[] = [];
+        await Promise.race([
+          (async () => {
+            for await (const chunk of process.stdin as AsyncIterable<Buffer>) {
+              chunks.push(chunk);
+            }
+          })(),
+          new Promise((r) => setTimeout(r, 50)),
+        ]);
+        const raw = Buffer.concat(chunks).toString("utf-8").trim();
+        if (raw) payload = JSON.parse(raw) as StopPayload;
+      }
+    } catch { /* ignore */ }
+
+    const sessionId = typeof payload.session_id === "string" && payload.session_id
+      ? payload.session_id
+      : currentSessionId();
+    const logPath = join(process.env.HOME ?? homedir(), ".ashlr", "session-log.jsonl");
+
+    // Read session stats.
+    let tokensSaved = 0;
+    let calls = 0;
+    let topTool: string | null = null;
+    let topCalls = 0;
+    try {
+      const statsPath = join(
+        process.env.CLAUDE_PLUGIN_ROOT ?? join(dirname(import.meta.url.replace("file://", "")), ".."),
+        "servers",
+        "_stats",
+      );
+      const { readCurrentSession } = await import(statsPath) as {
+        readCurrentSession: (id?: string) => Promise<{ tokensSaved: number; calls: number; byTool: Record<string, { calls: number }> }>;
+      };
+      const sess = await readCurrentSession(sessionId);
+      tokensSaved = sess.tokensSaved;
+      calls = sess.calls;
+      for (const [tool, pt] of Object.entries(sess.byTool ?? {})) {
+        if (pt.calls > topCalls) { topCalls = pt.calls; topTool = tool; }
+      }
+    } catch { /* best-effort */ }
+
+    // Idempotency + log append.
+    if (process.env.ASHLR_SESSION_LOG !== "0") {
+      try {
+        const lastLines = await readLastLines(logPath, 3);
+        if (!isAlreadyRecorded(lastLines, sessionId)) {
+          const entry = {
+            ts: new Date().toISOString(),
+            event: "stop",
+            session: sessionId,
+            tokens_saved: tokensSaved,
+            calls,
+            top_tool: topTool,
+          };
+          await appendFile(logPath, JSON.stringify(entry) + "\n");
+        }
+      } catch (e) {
+        noteHookError("stop-accounting", "append-log", e);
+      }
+    }
+
+    // Stop is a decision-control event: it supports no additionalContext.
+    // Side effects are done; exit silently (exit 0, no stdout).
+  } catch (e) {
+    noteHookError("stop-accounting", "main", e);
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/subagent-stop-rollup.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+/**
+ * subagent-stop-rollup.ts — SubagentStop hook.
+ *
+ * When a subagent finishes:
+ *   1. Reads stdin payload for Claude task_id/subagent_session_id or Codex
+ *      agent_id/session_id.
+ *   2. Appends a rollup line to ~/.ashlr/session-log.jsonl (unless ASHLR_SESSION_LOG=0).
+ *   3. Fire-and-forget genome consolidation for the cwd (unless ASHLR_GENOME_AUTO=0).
+ *
+ * SubagentStop is a decision-control event: it does NOT support
+ * hookSpecificOutput / additionalContext, so this hook only does its side
+ * effects and exits silently.
+ *
+ * Contract: never throws, always exits 0.
+ *
+ * Env toggles:
+ *   ASHLR_SESSION_LOG=0   — skip appending to session-log.jsonl
+ *   ASHLR_GENOME_AUTO=0   — skip genome consolidation
+ */
+
+import { appendFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+interface SubagentStopPayload {
+  task_id?: string;
+  subagent_session_id?: string;
+  agent_id?: string;
+  agent_type?: string;
+  session_id?: string;
+  [key: string]: unknown;
+}
+
+export interface RollupLine {
+  ts: string;
+  event: "subagent_stop";
+  task_id: string | null;
+  subagent_session_id: string | null;
+  agent_id?: string | null;
+  agent_type?: string | null;
+  tokens_saved: number;
+  calls: number;
+  top_tool: string | null;
+}
+
+export interface SubagentSummary {
+  tokensSaved: number;
+  calls: number;
+  topTool: string | null;
+}
+
+/** Build the JSONL rollup line for a finished subagent. */
+export function buildRollupLine(opts: {
+  taskId: string | null;
+  subagentSessionId: string | null;
+  agentId?: string | null;
+  agentType?: string | null;
+  summary: SubagentSummary;
+  ts?: string;
+}): RollupLine {
+  return {
+    ts: opts.ts ?? new Date().toISOString(),
+    event: "subagent_stop",
+    task_id: opts.taskId,
+    subagent_session_id: opts.subagentSessionId,
+    agent_id: opts.agentId ?? null,
+    agent_type: opts.agentType ?? null,
+    tokens_saved: opts.summary.tokensSaved,
+    calls: opts.summary.calls,
+    top_tool: opts.summary.topTool,
+  };
+}
+
+/** Read and parse stdin with a 200ms timeout. Returns {} on failure. */
+async function readStdinPayload(): Promise<SubagentStopPayload> {
+  try {
+    if (process.stdin.isTTY) return {};
+    const chunks: Buffer[] = [];
+    await Promise.race([
+      (async () => {
+        for await (const chunk of process.stdin as AsyncIterable<Buffer>) {
+          chunks.push(chunk);
+        }
+      })(),
+      new Promise((r) => setTimeout(r, 200)),
+    ]);
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw) return {};
+    return JSON.parse(raw) as SubagentStopPayload;
+  } catch {
+    return {};
+  }
+}
+
+async function main(): Promise<void> {
+  try {
+    const payload = await readStdinPayload();
+    const taskId = payload.task_id ?? payload.agent_id ?? null;
+    const subagentSessionId = payload.subagent_session_id ?? payload.session_id ?? null;
+    const agentId = payload.agent_id ?? null;
+    const agentType = payload.agent_type ?? null;
+
+    // Read subagent session stats.
+    let summary: SubagentSummary = { tokensSaved: 0, calls: 0, topTool: null };
+    try {
+      const statsPath = join(
+        process.env.CLAUDE_PLUGIN_ROOT ?? process.env.CODEX_PLUGIN_ROOT ?? join(dirname(import.meta.url.replace("file://", "")), ".."),
+        "servers",
+        "_stats",
+      );
+      const { readCurrentSession } = await import(statsPath) as {
+        readCurrentSession: (id?: string) => Promise<{ tokensSaved: number; calls: number; byTool: Record<string, { calls: number }> }>;
+      };
+      const sess = await readCurrentSession(subagentSessionId ?? undefined);
+      let topTool: string | null = null;
+      let topCalls = 0;
+      for (const [tool, pt] of Object.entries(sess.byTool ?? {})) {
+        if (pt.calls > topCalls) { topCalls = pt.calls; topTool = tool; }
+      }
+      summary = { tokensSaved: sess.tokensSaved, calls: sess.calls, topTool };
+    } catch { /* best-effort */ }
+
+    // 1. Append rollup line to session-log.jsonl.
+    if (process.env.ASHLR_SESSION_LOG !== "0") {
+      try {
+        const logPath = join(process.env.HOME ?? homedir(), ".ashlr", "session-log.jsonl");
+        const line = buildRollupLine({ taskId, subagentSessionId, agentId, agentType, summary });
+        await appendFile(logPath, JSON.stringify(line) + "\n");
+      } catch (e) {
+        noteHookError("subagent-stop-rollup", "append-log", e);
+      }
+    }
+
+    // 2. Fire-and-forget genome consolidation.
+    if (process.env.ASHLR_GENOME_AUTO !== "0") {
+      try {
+        const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT ?? process.env.CODEX_PLUGIN_ROOT ?? join(dirname(import.meta.url.replace("file://", "")), "..");
+        const consolidateTs = join(pluginRoot, "scripts", "genome-auto-consolidate.ts");
+        if (existsSync(consolidateTs)) {
+          Bun.spawn(["bun", "run", consolidateTs, "--dir", process.cwd()], {
+            stdin: "ignore",
+            stdout: "ignore",
+            stderr: "pipe",
+          });
+        }
+      } catch { /* best-effort */ }
+    }
+
+    // SubagentStop is a decision-control event: it supports no additionalContext.
+    // Side effects are done; exit silently (exit 0, no stdout).
+  } catch (e) {
+    noteHookError("subagent-stop-rollup", "main", e);
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/userpromptsubmit-brief-trigger.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env bun
+/**
+ * userpromptsubmit-brief-trigger.ts — UserPromptSubmit hook that watches for
+ * natural-language activation phrases and toggles ashlr-brief in response.
+ *
+ * Activation phrases (case-insensitive, matches anywhere in prompt):
+ *   "be brief", "be terse", "less tokens", "fewer tokens", "tldr",
+ *   "/brief on", "brief mode on"
+ *
+ * Deactivation phrases:
+ *   "stop being brief", "normal mode", "verbose mode", "brief off",
+ *   "/brief off"
+ *
+ * Updates ~/.ashlr/brief.json and emits a status nudge in additionalContext
+ * so the user sees confirmation of the toggle.
+ *
+ * Hook contract (UserPromptSubmit):
+ *   stdin  → { prompt: string, ... }
+ *   stdout → { hookSpecificOutput: { hookEventName: "UserPromptSubmit",
+ *                                    additionalContext?: string } }
+ *
+ * Design:
+ *   - Never blocks (always exits 0).
+ *   - Best-effort stdin parse — falls through silently on any error.
+ *   - Writes only when the toggle actually changes state.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "UserPromptSubmit";
+    additionalContext?: string;
+  };
+}
+
+interface BriefConfig {
+  level?: "off" | "lite" | "standard" | "concise";
+  source?: "user" | "project";
+  setAt?: string;
+}
+
+const ON_PATTERNS: Array<{ re: RegExp; level: "lite" | "standard" | "concise" }> = [
+  { re: /\bbrief\s+(?:mode\s+)?on\b/i, level: "standard" },
+  { re: /\bbe\s+brief\b/i,             level: "standard" },
+  { re: /\bbe\s+terse\b/i,             level: "standard" },
+  { re: /\bless\s+tokens?\b/i,         level: "standard" },
+  { re: /\bfewer\s+tokens?\b/i,        level: "standard" },
+  { re: /\btl;?dr\b/i,                 level: "concise" },
+  { re: /\/brief\s+on\b/i,             level: "standard" },
+];
+
+const OFF_PATTERNS: RegExp[] = [
+  /\bstop\s+(?:being\s+)?brief\b/i,
+  /\bnormal\s+mode\b/i,
+  /\bverbose\s+mode\b/i,
+  /\bbrief\s+off\b/i,
+  /\/brief\s+off\b/i,
+];
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+function briefConfigPath(homeDir: string): string {
+  return join(homeDir, ".ashlr", "brief.json");
+}
+
+function readConfig(homeDir: string): BriefConfig {
+  const path = briefConfigPath(homeDir);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as BriefConfig;
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(homeDir: string, cfg: BriefConfig): void {
+  const path = briefConfigPath(homeDir);
+  mkdirSync(join(homeDir, ".ashlr"), { recursive: true });
+  writeFileSync(path, JSON.stringify({ ...cfg, setAt: new Date().toISOString(), source: "user" }, null, 2));
+}
+
+/** Returns the new level and a human-readable message, or null when no toggle was triggered. */
+export function detectToggle(prompt: string): { level: "off" | "lite" | "standard" | "concise"; reason: string } | null {
+  // OFF patterns first (so "stop being brief" beats "be brief")
+  for (const re of OFF_PATTERNS) {
+    if (re.test(prompt)) {
+      return { level: "off", reason: `matched: ${re}` };
+    }
+  }
+  // Explicit level via "brief = concise" / "brief on lite" / "/brief on lite" / etc.
+  // Allow either "brief = LEVEL", "brief on LEVEL", "brief LEVEL", or "/brief on LEVEL".
+  const levelMatch = prompt.match(/\/?\bbrief(?:\s*=\s*|\s+(?:mode\s+)?on\s+|\s+)(lite|standard|concise)\b/i);
+  if (levelMatch && levelMatch[1]) {
+    return { level: levelMatch[1].toLowerCase() as "lite" | "standard" | "concise", reason: "explicit level" };
+  }
+  for (const { re, level } of ON_PATTERNS) {
+    if (re.test(prompt)) {
+      return { level, reason: `matched: ${re}` };
+    }
+  }
+  return null;
+}
+
+async function main(): Promise<void> {
+  try {
+    let stdin = "";
+    process.stdin.setEncoding("utf-8");
+    for await (const chunk of process.stdin) stdin += chunk;
+    if (!stdin.trim()) {
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit" } }));
+      return;
+    }
+    const payload = JSON.parse(stdin) as { prompt?: string };
+    const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
+
+    const toggle = detectToggle(prompt);
+    if (!toggle) {
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit" } }));
+      return;
+    }
+
+    const h = home();
+    const cfg = readConfig(h);
+    const previous = cfg.level ?? "off";
+    if (previous === toggle.level) {
+      // No state change.
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit" } }));
+      return;
+    }
+
+    writeConfig(h, { level: toggle.level });
+
+    const note = toggle.level === "off"
+      ? "[ashlr-brief] disabled — full verbosity restored for the next response."
+      : `[ashlr-brief] activated at level "${toggle.level}". Code blocks, errors, and destructive-action confirmations remain in full grammar. Toggle off with: stop being brief.`;
+
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: note,
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch {
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "ashlr-plugin",
+  "version": "1.36.4",
+  "description": "Multi-host AI coding efficiency layer for Codex and Claude Code, powered by @ashlr/core-efficiency.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ashlr-plugin": "./scripts/cli.ts",
+    "ashlr-mcp": "./scripts/ashlr-mcp.ts"
+  },
+  "files": [
+    ".agents/plugins/marketplace.json",
+    ".claude-plugin/",
+    ".codex/agents/",
+    ".codex-plugin/",
+    ".mcp.json",
+    "agents/",
+    "bench/",
+    "commands/",
+    "docs/",
+    "hooks/",
+    "ports/",
+    "scripts/",
+    "servers/",
+    "skills/"
+  ],
+  "scripts": {
+    "server": "bun run servers/_router.ts",
+    "check": "bun run smoke:tools && bun run typecheck && bun run mdx-lint && bun run test && cd server && bun run check && cd ../site && bun run check && cd ../vscode && bun run check",
+    "smoke:tools": "bun run scripts/smoke-tools.ts",
+    "bench": "bun run scripts/run-benchmark.ts",
+    "test": "bun run scripts/run-root-tests.ts",
+    "typecheck": "bunx tsc --noEmit",
+    "mdx-lint": "bun run scripts/mdx-angle-bracket-lint.ts",
+    "brief-eval": "bun run scripts/brief-eval.ts",
+    "publish:github": "bash scripts/publish.sh",
+    "install-onnx-model": "bun run scripts/install-onnx-model.ts",
+    "version:bump": "bun run scripts/bump-version.ts",
+    "version:check": "bun run scripts/check-version-sync.ts"
+  },
+  "dependencies": {
+    "@ashlr/core-efficiency": "github:ashlrai/ashlr-core-efficiency#275610156ee314c3335025f0ba0c2379089e068c",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "minimatch": "^10.2.5",
+    "postgres": "^3.4.9",
+    "tree-sitter-wasms": "^0.1.13",
+    "web-tree-sitter": "0.22.6"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "optionalDependencies": {
+    "onnxruntime-node": "^1.20.0"
+  }
+}

package/ports/README.md

@@ -0,0 +1,108 @@
+# ashlr in other MCP hosts
+
+Ashlr is a suite of MCP servers. The servers speak the standard Model Context
+Protocol over stdio and work in any MCP-compatible host, not just Claude Code.
+
+This directory contains ready-made config snippets for Cursor and Goose. Codex
+uses the repo-root `.codex-plugin/plugin.json` and `.mcp.json` files instead.
+
+---
+
+## Install
+
+1. Clone the repository and install dependencies:
+
+   ```bash
+   git clone https://github.com/ashlrai/ashlr-plugin
+   cd ashlr-plugin
+   bun install
+   ```
+
+2. Note the absolute path to your clone. You will substitute it for
+   `<ASHLR_PLUGIN_ROOT>` in the config files below.
+
+The preferred MCP entry point is `scripts/ashlr-mcp.ts` or the package bin
+`ashlr-mcp`. It launches the single router process with all 40 tools. The
+legacy `scripts/mcp-entrypoint.sh` snippets are retained for older host
+configs that still expect individual server files.
+
+---
+
+## Cursor
+
+Cursor reads MCP server config from `.cursor/mcp.json` in your project, or from
+`~/.cursor/mcp.json` globally.
+
+Copy `ports/cursor/mcp.json` to one of those locations, then replace every
+occurrence of `<ASHLR_PLUGIN_ROOT>` with the absolute path to your clone:
+
+```bash
+# Example using sed
+ASHLR_ROOT="/home/you/ashlr-plugin"
+sed "s|<ASHLR_PLUGIN_ROOT>|$ASHLR_ROOT|g" \
+  ports/cursor/mcp.json > ~/.cursor/mcp.json
+```
+
+Restart Cursor. The 40 ashlr tools will appear in the MCP panel.
+
+---
+
+## Goose
+
+Goose reads extensions from a recipe file passed at run time.
+
+Copy `ports/goose/recipe.yaml`, replace `<ASHLR_PLUGIN_ROOT>`, then run:
+
+```bash
+ASHLR_ROOT="/home/you/ashlr-plugin"
+sed "s|<ASHLR_PLUGIN_ROOT>|$ASHLR_ROOT|g" \
+  ports/goose/recipe.yaml > my-ashlr-recipe.yaml
+
+goose run --recipe my-ashlr-recipe.yaml
+```
+
+---
+
+## Caveats
+
+The following features are host-specific and are not available in Cursor or
+Goose:
+
+- **Claude slash commands** (`/ashlr-savings`, `/ashlr-genome-init`, etc.) —
+  defined in `.claude-plugin/plugin.json`. Codex has separate workflow skills
+  under `skills/` via `.codex-plugin/plugin.json`.
+- **Status line** — the animated token-savings counter in the Claude Code
+  terminal is wired to Claude Code's `statusLine` hook.
+- **Claude redirect hooks** — automatic redirect mode is Claude-only. Codex has
+  nudge-first hooks; Cursor and Goose expose MCP tools directly.
+
+The underlying MCP tools (`ashlr__read`, `ashlr__grep`, `ashlr__edit`, etc.)
+work identically in any host. Token savings are still tracked: the stats server
+writes to `~/.ashlr/stats.json` on every call regardless of the host.
+
+### Shell prompt integration
+
+If you want a savings counter in your shell prompt, run the status-line script
+as a subshell command:
+
+```bash
+# bash / zsh — add to PS1 or PROMPT
+PS1='$(bun run /path/to/ashlr-plugin/scripts/savings-status-line.ts) \$ '
+```
+
+The script reads `~/.ashlr/stats.json` and prints a compact savings summary
+suitable for embedding in any shell prompt.
+
+---
+
+## Tools included
+
+The current router exposes 40 tools from one MCP server. Run:
+
+```bash
+ashlr-plugin tools
+```
+
+Core tools include `ashlr__read`, `ashlr__grep`, `ashlr__edit`,
+`ashlr__multi_edit`, `ashlr__bash`, `ashlr__tree`, `ashlr__savings`, and the
+genome tools.

package/ports/cursor/mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "ashlr": {
+      "command": "bun",
+      "args": ["run", "<ASHLR_PLUGIN_ROOT>/scripts/ashlr-mcp.ts"],
+      "env": {
+        "ASHLR_MCP_HOST": "generic"
+      }
+    }
+  }
+}

package/ports/goose/recipe.yaml

@@ -0,0 +1,26 @@
+# Goose recipe: ashlr MCP router
+# Replace <ASHLR_PLUGIN_ROOT> with the absolute path to your ashlr-plugin clone.
+# Example: /home/you/ashlr-plugin
+#
+# Usage:
+#   goose run --recipe ports/goose/recipe.yaml
+#
+# One stdio extension registers the ashlr router with all 40 MCP tools.
+
+version: "1.0"
+title: ashlr token-efficiency suite
+description: >
+  Registers the ashlr MCP router as one Goose extension.
+  Provides token-efficient Read/Grep/Edit/MultiEdit, SQL, Bash,
+  Tree, HTTP, Diff, Logs, Genome, Orient, GitHub, Glob, WebFetch,
+  Ask, savings, and orchestration tools.
+
+extensions:
+  - name: ashlr
+    type: stdio
+    cmd: bun
+    args:
+      - "run"
+      - "<ASHLR_PLUGIN_ROOT>/scripts/ashlr-mcp.ts"
+    env:
+      ASHLR_MCP_HOST: generic