ashlr-plugin 1.36.4

package/bench/refs/rust-project/tokio/src/io/util/buf_writer.rs

@@ -0,0 +1,310 @@
+use crate::io::util::DEFAULT_BUF_SIZE;
+use crate::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+
+use pin_project_lite::pin_project;
+use std::fmt;
+use std::io::{self, IoSlice, SeekFrom, Write};
+use std::pin::Pin;
+use std::task::{ready, Context, Poll};
+
+pin_project! {
+    /// Wraps a writer and buffers its output.
+    ///
+    /// It can be excessively inefficient to work directly with something that
+    /// implements [`AsyncWrite`]. A `BufWriter` keeps an in-memory buffer of data and
+    /// writes it to an underlying writer in large, infrequent batches.
+    ///
+    /// `BufWriter` can improve the speed of programs that make *small* and
+    /// *repeated* write calls to the same file or network socket. It does not
+    /// help when writing very large amounts at once, or writing just one or a few
+    /// times. It also provides no advantage when writing to a destination that is
+    /// in memory, like a `Vec<u8>`.
+    ///
+    /// When the `BufWriter` is dropped, the contents of its buffer will be
+    /// discarded. Creating multiple instances of a `BufWriter` on the same
+    /// stream can cause data loss. If you need to write out the contents of its
+    /// buffer, you must manually call flush before the writer is dropped.
+    ///
+    /// [`AsyncWrite`]: AsyncWrite
+    /// [`flush`]: super::AsyncWriteExt::flush
+    ///
+    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
+    pub struct BufWriter<W> {
+        #[pin]
+        pub(super) inner: W,
+        pub(super) buf: Vec<u8>,
+        pub(super) written: usize,
+        pub(super) seek_state: SeekState,
+    }
+}
+
+impl<W: AsyncWrite> BufWriter<W> {
+    /// Creates a new `BufWriter` with a default buffer capacity. The default is currently 8 KB,
+    /// but may change in the future.
+    pub fn new(inner: W) -> Self {
+        Self::with_capacity(DEFAULT_BUF_SIZE, inner)
+    }
+
+    /// Creates a new `BufWriter` with the specified buffer capacity.
+    pub fn with_capacity(cap: usize, inner: W) -> Self {
+        Self {
+            inner,
+            buf: Vec::with_capacity(cap),
+            written: 0,
+            seek_state: SeekState::Init,
+        }
+    }
+
+    fn flush_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut me = self.project();
+
+        let len = me.buf.len();
+        let mut ret = Ok(());
+        while *me.written < len {
+            match ready!(me.inner.as_mut().poll_write(cx, &me.buf[*me.written..])) {
+                Ok(0) => {
+                    ret = Err(io::Error::new(
+                        io::ErrorKind::WriteZero,
+                        "failed to write the buffered data",
+                    ));
+                    break;
+                }
+                Ok(n) => *me.written += n,
+                Err(e) => {
+                    ret = Err(e);
+                    break;
+                }
+            }
+        }
+        if *me.written > 0 {
+            me.buf.drain(..*me.written);
+        }
+        *me.written = 0;
+        Poll::Ready(ret)
+    }
+
+    /// Gets a reference to the underlying writer.
+    pub fn get_ref(&self) -> &W {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying writer.
+    ///
+    /// It is inadvisable to directly write to the underlying writer.
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.inner
+    }
+
+    /// Gets a pinned mutable reference to the underlying writer.
+    ///
+    /// It is inadvisable to directly write to the underlying writer.
+    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
+        self.project().inner
+    }
+
+    /// Consumes this `BufWriter`, returning the underlying writer.
+    ///
+    /// Note that any leftover data in the internal buffer is lost.
+    pub fn into_inner(self) -> W {
+        self.inner
+    }
+
+    /// Returns a reference to the internally buffered data.
+    pub fn buffer(&self) -> &[u8] {
+        &self.buf
+    }
+}
+
+impl<W: AsyncWrite> AsyncWrite for BufWriter<W> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if self.buf.len() + buf.len() > self.buf.capacity() {
+            ready!(self.as_mut().flush_buf(cx))?;
+        }
+
+        let me = self.project();
+        if buf.len() >= me.buf.capacity() {
+            me.inner.poll_write(cx, buf)
+        } else {
+            Poll::Ready(me.buf.write(buf))
+        }
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        mut bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        if self.inner.is_write_vectored() {
+            let total_len = bufs
+                .iter()
+                .fold(0usize, |acc, b| acc.saturating_add(b.len()));
+            if total_len > self.buf.capacity() - self.buf.len() {
+                ready!(self.as_mut().flush_buf(cx))?;
+            }
+            let me = self.as_mut().project();
+            if total_len >= me.buf.capacity() {
+                // It's more efficient to pass the slices directly to the
+                // underlying writer than to buffer them.
+                // The case when the total_len calculation saturates at
+                // usize::MAX is also handled here.
+                me.inner.poll_write_vectored(cx, bufs)
+            } else {
+                bufs.iter().for_each(|b| me.buf.extend_from_slice(b));
+                Poll::Ready(Ok(total_len))
+            }
+        } else {
+            // Remove empty buffers at the beginning of bufs.
+            while bufs.first().map(|buf| buf.len()) == Some(0) {
+                bufs = &bufs[1..];
+            }
+            if bufs.is_empty() {
+                return Poll::Ready(Ok(0));
+            }
+            // Flush if the first buffer doesn't fit.
+            let first_len = bufs[0].len();
+            if first_len > self.buf.capacity() - self.buf.len() {
+                ready!(self.as_mut().flush_buf(cx))?;
+                debug_assert!(self.buf.is_empty());
+            }
+            let me = self.as_mut().project();
+            if first_len >= me.buf.capacity() {
+                // The slice is at least as large as the buffering capacity,
+                // so it's better to write it directly, bypassing the buffer.
+                debug_assert!(me.buf.is_empty());
+                return me.inner.poll_write(cx, &bufs[0]);
+            } else {
+                me.buf.extend_from_slice(&bufs[0]);
+                bufs = &bufs[1..];
+            }
+            let mut total_written = first_len;
+            debug_assert!(total_written != 0);
+            // Append the buffers that fit in the internal buffer.
+            for buf in bufs {
+                if buf.len() > me.buf.capacity() - me.buf.len() {
+                    break;
+                } else {
+                    me.buf.extend_from_slice(buf);
+                    total_written += buf.len();
+                }
+            }
+            Poll::Ready(Ok(total_written))
+        }
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        ready!(self.as_mut().flush_buf(cx))?;
+        self.get_pin_mut().poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        ready!(self.as_mut().flush_buf(cx))?;
+        self.get_pin_mut().poll_shutdown(cx)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(super) enum SeekState {
+    /// `start_seek` has not been called.
+    Init,
+    /// `start_seek` has been called, but `poll_complete` has not yet been called.
+    Start(SeekFrom),
+    /// Waiting for completion of `poll_complete`.
+    Pending,
+}
+
+/// Seek to the offset, in bytes, in the underlying writer.
+///
+/// Seeking always writes out the internal buffer before seeking.
+impl<W: AsyncWrite + AsyncSeek> AsyncSeek for BufWriter<W> {
+    fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
+        // We need to flush the internal buffer before seeking.
+        // It receives a `Context` and returns a `Poll`, so it cannot be called
+        // inside `start_seek`.
+        *self.project().seek_state = SeekState::Start(pos);
+        Ok(())
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let pos = match self.seek_state {
+            SeekState::Init => {
+                return self.project().inner.poll_complete(cx);
+            }
+            SeekState::Start(pos) => Some(pos),
+            SeekState::Pending => None,
+        };
+
+        // Flush the internal buffer before seeking.
+        ready!(self.as_mut().flush_buf(cx))?;
+
+        let mut me = self.project();
+        if let Some(pos) = pos {
+            // Ensure previous seeks have finished before starting a new one
+            ready!(me.inner.as_mut().poll_complete(cx))?;
+            if let Err(e) = me.inner.as_mut().start_seek(pos) {
+                *me.seek_state = SeekState::Init;
+                return Poll::Ready(Err(e));
+            }
+        }
+        match me.inner.poll_complete(cx) {
+            Poll::Ready(res) => {
+                *me.seek_state = SeekState::Init;
+                Poll::Ready(res)
+            }
+            Poll::Pending => {
+                *me.seek_state = SeekState::Pending;
+                Poll::Pending
+            }
+        }
+    }
+}
+
+impl<W: AsyncWrite + AsyncRead> AsyncRead for BufWriter<W> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        self.get_pin_mut().poll_read(cx, buf)
+    }
+}
+
+impl<W: AsyncWrite + AsyncBufRead> AsyncBufRead for BufWriter<W> {
+    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
+        self.get_pin_mut().poll_fill_buf(cx)
+    }
+
+    fn consume(self: Pin<&mut Self>, amt: usize) {
+        self.get_pin_mut().consume(amt);
+    }
+}
+
+impl<W: fmt::Debug> fmt::Debug for BufWriter<W> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BufWriter")
+            .field("writer", &self.inner)
+            .field(
+                "buffer",
+                &format_args!("{}/{}", self.buf.len(), self.buf.capacity()),
+            )
+            .field("written", &self.written)
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_unpin() {
+        crate::is_unpin::<BufWriter<()>>();
+    }
+}

package/bench/refs/rust-project/tokio/src/io/util/chain.rs

@@ -0,0 +1,144 @@
+use crate::io::{AsyncBufRead, AsyncRead, ReadBuf};
+
+use pin_project_lite::pin_project;
+use std::fmt;
+use std::io;
+use std::pin::Pin;
+use std::task::{ready, Context, Poll};
+
+pin_project! {
+    /// Stream for the [`chain`](super::AsyncReadExt::chain) method.
+    #[must_use = "streams do nothing unless polled"]
+    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
+    pub struct Chain<T, U> {
+        #[pin]
+        first: T,
+        #[pin]
+        second: U,
+        done_first: bool,
+    }
+}
+
+pub(super) fn chain<T, U>(first: T, second: U) -> Chain<T, U>
+where
+    T: AsyncRead,
+    U: AsyncRead,
+{
+    Chain {
+        first,
+        second,
+        done_first: false,
+    }
+}
+
+impl<T, U> Chain<T, U>
+where
+    T: AsyncRead,
+    U: AsyncRead,
+{
+    /// Gets references to the underlying readers in this `Chain`.
+    pub fn get_ref(&self) -> (&T, &U) {
+        (&self.first, &self.second)
+    }
+
+    /// Gets mutable references to the underlying readers in this `Chain`.
+    ///
+    /// Care should be taken to avoid modifying the internal I/O state of the
+    /// underlying readers as doing so may corrupt the internal state of this
+    /// `Chain`.
+    pub fn get_mut(&mut self) -> (&mut T, &mut U) {
+        (&mut self.first, &mut self.second)
+    }
+
+    /// Gets pinned mutable references to the underlying readers in this `Chain`.
+    ///
+    /// Care should be taken to avoid modifying the internal I/O state of the
+    /// underlying readers as doing so may corrupt the internal state of this
+    /// `Chain`.
+    pub fn get_pin_mut(self: Pin<&mut Self>) -> (Pin<&mut T>, Pin<&mut U>) {
+        let me = self.project();
+        (me.first, me.second)
+    }
+
+    /// Consumes the `Chain`, returning the wrapped readers.
+    pub fn into_inner(self) -> (T, U) {
+        (self.first, self.second)
+    }
+}
+
+impl<T, U> fmt::Debug for Chain<T, U>
+where
+    T: fmt::Debug,
+    U: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Chain")
+            .field("t", &self.first)
+            .field("u", &self.second)
+            .finish()
+    }
+}
+
+impl<T, U> AsyncRead for Chain<T, U>
+where
+    T: AsyncRead,
+    U: AsyncRead,
+{
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let me = self.project();
+
+        if !*me.done_first {
+            let rem = buf.remaining();
+            ready!(me.first.poll_read(cx, buf))?;
+            if buf.remaining() == rem {
+                *me.done_first = true;
+            } else {
+                return Poll::Ready(Ok(()));
+            }
+        }
+        me.second.poll_read(cx, buf)
+    }
+}
+
+impl<T, U> AsyncBufRead for Chain<T, U>
+where
+    T: AsyncBufRead,
+    U: AsyncBufRead,
+{
+    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
+        let me = self.project();
+
+        if !*me.done_first {
+            match ready!(me.first.poll_fill_buf(cx)?) {
+                [] => {
+                    *me.done_first = true;
+                }
+                buf => return Poll::Ready(Ok(buf)),
+            }
+        }
+        me.second.poll_fill_buf(cx)
+    }
+
+    fn consume(self: Pin<&mut Self>, amt: usize) {
+        let me = self.project();
+        if !*me.done_first {
+            me.first.consume(amt)
+        } else {
+            me.second.consume(amt)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_unpin() {
+        crate::is_unpin::<Chain<(), ()>>();
+    }
+}

package/commands/_spawn-patterns.json

@@ -0,0 +1,32 @@
+{
+  "triage-issues": {
+    "subagent_type": "ashlr:ashlr:explore",
+    "model": "haiku",
+    "prompt_template": "You are triaging GitHub issues for a codebase. Classify each issue by: severity (critical/high/medium/low), label category (bug/feature/docs/chore), and age bucket (<7d / 7-30d / 30-90d / 90d+).\n\nFor each issue produce one line: `#<id> [<severity>] [<label>] [<age>] — <one-sentence summary>`.\n\nAt the end output a counts table:\n```\nseverity  | count\ncritical  | N\nhigh      | N\nmedium    | N\nlow       | N\n```\n\nArgs: {{args}}",
+    "fanout_strategy": "batch"
+  },
+  "refactor-files": {
+    "subagent_type": "ashlr:ashlr:code",
+    "model": "sonnet",
+    "prompt_template": "Refactor the following files according to this description:\n\n> {{args}}\n\nFiles to refactor: {{files}}\n\nFor each file:\n1. Read the current content.\n2. Apply the described refactor.\n3. Write the updated file.\n4. Summarize changes in one line per file.\n\nDo NOT change public interfaces unless the refactor description explicitly requires it. Preserve existing tests.",
+    "fanout_strategy": "parallel-per-file"
+  },
+  "codebase-explain": {
+    "subagent_type": "ashlr:ashlr:explore",
+    "model": "haiku",
+    "prompt_template": "Explain the following area of this codebase: {{args}}\n\nUse the standard explore output shape:\n\n## What it does\n[2-4 sentences.]\n\n## Key files\n- path/to/file.ts:L42–58 — [role]\n\n## Flow\n1. entry → [fn] at [path:line]\n2. → [fn] at [path:line]\n\n## Gotchas / risks\n- [concrete, cited]\n\n## Unknowns\n- [what you'd need to read to go deeper]\n\nStay within 400 words. Cite file:line for every claim.",
+    "fanout_strategy": "tiered"
+  },
+  "pr-review-sweep": {
+    "subagent_type": "ashlr:ashlr:code",
+    "model": "sonnet",
+    "prompt_template": "Review PR #{{args}} for correctness, security, and style.\n\nFor each changed file:\n- Note bugs, logic errors, or security issues (cite file:line).\n- Note style violations or naming inconsistencies.\n- Suggest concrete improvements (show the diff, not just prose).\n\nOutput format per file:\n```\n### path/to/file.ts\n- [severity: critical|high|medium|low] file:line — issue description\n  Suggestion: <concrete fix>\n```\n\nAt the end: overall LGTM / Request Changes verdict with 1-sentence rationale.",
+    "fanout_strategy": "parallel-per-file-changed"
+  },
+  "parallel-test-fix": {
+    "subagent_type": "ashlr:ashlr:code",
+    "model": "sonnet",
+    "prompt_template": "Fix failing tests in: {{files}}\n\nFor each failing test file:\n1. Read the test file and the source file it tests.\n2. Identify the root cause of each failure.\n3. Fix the source (not the test) unless the test expectation is clearly wrong.\n4. Verify the fix is consistent with other tests in the file.\n5. Report: `<file> — <N> failures fixed, root cause: <one line>`.\n\nDo NOT add new tests. Do NOT change test expectations without a clear reason. Preserve all passing tests.",
+    "fanout_strategy": "parallel-per-file"
+  }
+}

package/commands/ashlr-allow.md

@@ -0,0 +1,21 @@
+---
+name: ashlr-allow
+description: Auto-approve every ashlr MCP tool so Claude Code stops prompting in bypass-permissions mode.
+---
+
+Run the permissions installer and render its output.
+
+```sh
+bun run "${CLAUDE_PLUGIN_ROOT}/scripts/install-permissions.ts"
+```
+
+Capture stdout and display it to the user verbatim.
+
+Then tell the user:
+
+- Which entries were added (or that all were already present).
+- That Claude Code must be **restarted** (or `/reload-plugins` run) to pick up the settings change before the prompts disappear.
+- If they want to undo, they can run: `bun run "${CLAUDE_PLUGIN_ROOT}/scripts/install-permissions.ts" --remove`
+- If they want to preview without writing, they can run with `--dry-run`.
+
+Do not paraphrase the installer output — show it as-is, then add the above notes only if the installer did not already mention them.

package/commands/ashlr-benchmark.md

@@ -0,0 +1,53 @@
+---
+name: ashlr-benchmark
+description: Run the ashlr-plugin token-savings benchmark against the current project.
+---
+
+Benchmark the plugin's `snipCompact` savings on the user's actual code.
+
+Steps:
+
+1. Determine a target directory:
+   - Prefer `<cwd>/src` if it exists.
+   - Otherwise try `<cwd>/lib`, `<cwd>/app`, then `<cwd>` itself.
+   - If none of these contain any `.ts`, `.tsx`, `.js`, `.jsx`, `.py`, `.go`,
+     `.rs`, `.java`, or similar source files, tell the user:
+
+     ```
+     ashlr-benchmark: no source files detected in <cwd>.
+     Run it against a specific file instead, e.g.:
+       bun run ${CLAUDE_PLUGIN_ROOT}/servers/bench.ts --path <file>
+     ```
+
+     and stop.
+
+2. Run via Bash. The plugin root is exposed to hooks and commands via the
+   `${CLAUDE_PLUGIN_ROOT}` environment variable. If that variable is empty or
+   unset, the plugin is not loaded — abort with this exact message and stop:
+
+   ```
+   ashlr plugin not loaded — run /plugin install ashlr@ashlr-marketplace first.
+   ```
+
+   Otherwise:
+
+   ```
+   bun run ${CLAUDE_PLUGIN_ROOT}/servers/bench.ts --dir <target-dir>
+   ```
+
+3. Parse the output. The bench script prints a table of files with their raw
+   byte counts vs. snipCompact byte counts and a percent saved. Reproduce the
+   table in the response, then prepend a one-line headline:
+
+   ```
+   mean savings on files ≥ 2KB: X%
+   ```
+
+   Compute the mean across only files whose raw size is ≥ 2048 bytes (smaller
+   files are pass-through in the redirect hook and skew the average).
+
+4. If the bench script fails (missing file, exit non-zero), surface stderr
+   verbatim and suggest running with `--path <single-file>` to narrow the
+   problem.
+
+No preamble, no trailing summary — just the headline plus the table.

package/commands/ashlr-brief.md

@@ -0,0 +1,97 @@
+---
+name: ashlr-brief
+description: Toggle response-shortening (caveman-inspired, ashlr-flavored) with three intensity levels. Trims filler from Claude's prose to save 30–55% on output tokens while keeping code blocks, errors, and destructive-action confirmations in full grammar.
+argument-hint: "on [lite|standard|concise] | off | status | --project [level]"
+---
+
+Toggle ashlr-brief — a tunable, opt-in response-shortening layer. Free users get user-level preferences; Pro/Team users get project-level enforcement.
+
+## Usage
+
+```
+/ashlr-brief on                    # enable at default level (standard)
+/ashlr-brief on lite               # mild trim — keeps full grammar
+/ashlr-brief on standard           # default — drop padding
+/ashlr-brief on concise            # max — fragments + arrows allowed
+/ashlr-brief off                   # disable
+/ashlr-brief status                # show current level + active source
+/ashlr-brief --project standard    # write `.ashlr/brief.json` (Pro/Team only)
+```
+
+## What it does
+
+| Level | Reduction | Effect |
+|-------|-----------|--------|
+| `lite` | ~25–35% | Drops filler; keeps full grammar |
+| `standard` (default) | ~35–45% | Drops padding + transitions; keeps grammar |
+| `concise` | ~50–60% | Fragments + arrows OK; abbreviations allowed for prose only |
+
+Code blocks, error messages, file paths, and destructive-action confirmations are always rendered in full grammar regardless of level. See `skills/ashlr-brief/SKILL.md` for the full ruleset.
+
+## Steps
+
+### `on [level]`
+
+1. Default level if omitted: `standard`. Validate level is one of `lite | standard | concise`.
+2. Write to `~/.ashlr/brief.json`:
+   ```json
+   { "level": "standard", "setAt": "<ISO8601>", "source": "user" }
+   ```
+   Use `mkdir -p ~/.ashlr` first if needed.
+3. Print:
+   ```
+   ashlr-brief: <level> ON. Effective on the next response.
+   - Code blocks, errors, and destructive confirmations remain in full grammar.
+   - Status line shows `[brief: <level>]` while active.
+   Toggle off with: /ashlr-brief off
+   ```
+
+### `off`
+
+1. Write to `~/.ashlr/brief.json`:
+   ```json
+   { "level": "off", "setAt": "<ISO8601>", "source": "user" }
+   ```
+2. Print: `ashlr-brief: OFF. Default verbosity restored.`
+
+### `status`
+
+1. Read `~/.ashlr/brief.json` (level field).
+2. Read `<repo-root>/.ashlr/brief.json` if present (project override).
+3. Print:
+   ```
+   ashlr-brief status
+     user-level:    <level> (~/.ashlr/brief.json)
+     project-level: <level> (.ashlr/brief.json) — Pro-enforced
+     effective:     <project wins if Pro-set, else user>
+   ```
+   If no file exists for either, show `<not set>`.
+
+### `--project [level]`
+
+1. Check Pro/Team tier via `bun run ${CLAUDE_PLUGIN_ROOT}/scripts/check-tier.ts` (or read `~/.ashlr/pro-token-cache.json`). If free, print:
+   ```
+   ashlr-brief: --project requires Pro or Team tier.
+   Run /ashlr-upgrade to enable project-level enforcement.
+   ```
+   and stop.
+2. Otherwise write `.ashlr/brief.json` in the current repo root with:
+   ```json
+   { "level": "<level>", "setAt": "<ISO8601>", "source": "project", "writtenBy": "<email>" }
+   ```
+3. Print:
+   ```
+   ashlr-brief: project-level <level> written to .ashlr/brief.json.
+   Commit this file so teammates pick it up. Project setting overrides user-level.
+   ```
+
+### No argument
+
+Show `status` (above).
+
+## Notes
+
+- The skill content is in `skills/ashlr-brief/SKILL.md` and is auto-injected into session context by `hooks/sessionstart-brief.ts`.
+- Natural-language activators ("be brief", "tldr", "less tokens", "stop being brief") are handled by `hooks/userpromptsubmit-brief-trigger.ts` — no slash command required.
+- `/ashlr-eco-mode on` auto-activates `standard` if user hasn't already chosen a level.
+- Real-data evaluation: `bun run scripts/brief-eval.ts` runs a 3-arm comparison (verbose / brief / "be terse" raw instruction) to verify reduction claims with real token counts.