ashlr-plugin 1.36.4

package/commands/ashlr-budget.md

@@ -0,0 +1,76 @@
+---
+name: ashlr-budget
+description: Set, check, or clear a session spend cap. Guards against runaway tool use in long sessions.
+argument-hint: "$X | tokens=N | status | off"
+---
+
+Manage a session budget cap that blocks tool calls when the limit is reached.
+
+## Usage
+
+```
+/ashlr-budget $X            # set USD cap (e.g. /ashlr-budget $2.00 or /ashlr-budget $0.50)
+/ashlr-budget tokens=200000 # set token cap (e.g. /ashlr-budget tokens=200000)
+/ashlr-budget status        # show current usage vs budget
+/ashlr-budget off           # clear the budget cap
+```
+
+`$X` and `tokens=N` are mutually exclusive — setting one clears the other.
+
+## Environment variables
+
+The budget guard hook (`hooks/pretooluse-budget-guard.ts`) reads these env vars:
+
+| Variable | Description |
+|----------|-------------|
+| `ASHLR_SESSION_BUDGET_USD` | USD cap as a decimal string (e.g. `"2.00"`) |
+| `ASHLR_SESSION_BUDGET_TOKENS` | Token cap as an integer string (e.g. `"200000"`) |
+
+The status line shows `$X / $Y · Z%` when `ASHLR_SESSION_BUDGET_USD` is set, or `Nt / Nmax · Z%` when `ASHLR_SESSION_BUDGET_TOKENS` is set.
+
+## Steps
+
+### `$X` — set USD cap
+
+1. Parse the dollar amount (strip `$`, parse as float). Reject if non-positive or non-numeric.
+2. Set environment variable: `ASHLR_SESSION_BUDGET_USD=<amount>` via Bash:
+   ```sh
+   export ASHLR_SESSION_BUDGET_USD=<amount>
+   unset ASHLR_SESSION_BUDGET_TOKENS
+   ```
+3. Confirm: "Budget set to $`<amount>`. The pretooluse-budget-guard hook will warn at 80%, warn loudly at 95%, and block at 100%."
+
+### `tokens=N` — set token cap
+
+1. Parse N as integer. Reject if non-positive.
+2. Set: `ASHLR_SESSION_BUDGET_TOKENS=<N>` via Bash, unset USD cap.
+3. Confirm: "Budget set to `<N>` tokens."
+
+### `status` — print current usage
+
+1. Read `ASHLR_SESSION_BUDGET_USD` and `ASHLR_SESSION_BUDGET_TOKENS` from environment.
+2. Read session-log (`~/.ashlr/session-log.jsonl`) to compute cumulative `input_size` + `output_size` bytes for the current session.
+3. Estimate token usage: `tokens ≈ (input_bytes + output_bytes) / 4`.
+4. Estimate USD: `usd ≈ tokens / 1_000_000 * 12` (blended $4/Mtok input + $20/Mtok output at typical 60/40 mix).
+5. Print:
+   ```
+   Session budget status
+   ─────────────────────
+   USD cap:    $<cap>  (or "not set")
+   Token cap:  <N>     (or "not set")
+   Est. tokens used:   ~<N>
+   Est. USD used:      ~$<X>
+   Usage:              <Z>%
+   ```
+   If no budget is set: "No budget set. Use /ashlr-budget $X or /ashlr-budget tokens=N to set one."
+
+### `off` — clear the budget cap
+
+1. Unset both `ASHLR_SESSION_BUDGET_USD` and `ASHLR_SESSION_BUDGET_TOKENS` via Bash.
+2. Confirm: "Budget cap cleared."
+
+## Budget guard behavior (implemented in hooks/pretooluse-budget-guard.ts)
+
+- At **80%**: emits an `additionalContext` warning: "[ashlr] Budget at 80% — $X of $Y used."
+- At **95%**: emits a louder warning: "[ashlr] Budget at 95% — consider stopping soon."
+- At **100%**: exits non-zero, blocking the tool call with: "[ashlr] Budget exceeded — $X cap reached. Run /ashlr-budget off to clear."

package/commands/ashlr-compact.md

@@ -0,0 +1,54 @@
+---
+name: ashlr-compact
+description: Identify stale tool results accumulating in the conversation history and surface a recompression plan.
+---
+
+Read `~/.ashlr/session-history/<sessionId>.jsonl` using the `ashlr__read` tool (or Bash if the path resolves) and then run the following analysis logic:
+
+1. **Find the session ID**: It is in `~/.ashlr/last-project.json` under the `sessionId` key. Read that file first.
+
+2. **Read the session history**: Read `~/.ashlr/session-history/<sessionId>.jsonl`. Each line is a JSON object with fields: `ts`, `tool`, `sizeBytes`, `contentSha8`, `turn`, `sessionId`.
+
+3. **Compute current turn count**: Count the total number of lines in the history file — this is `currentTurn`.
+
+4. **Classify entries by staleness**:
+   - `turnDelta = currentTurn - entry.turn`
+   - Fresh: `turnDelta < 5` (freshness 1.0)
+   - Stale: `5 ≤ turnDelta < 15` (freshness 0.5)
+   - Very stale: `turnDelta ≥ 15` (freshness 0.2)
+
+5. **Aggregate**:
+   - Total stale results: count of entries where `turnDelta ≥ 5`
+   - Total stale bytes: sum of `sizeBytes` for stale entries
+   - Per-tool breakdown: group by `tool`, show count + bytes
+
+6. **Print the report** to the user in this format:
+   ```
+   ashlr-compact: Stale result analysis
+   ─────────────────────────────────────
+   Session turns:    <currentTurn>
+   Stale results:    <count> (turnDelta ≥ 5)
+   Stale volume:     ~<KB> KB
+
+   By tool:
+     <tool>          <count> results · ~<KB> KB
+     ...
+
+   Recompression opportunity: ~<staleKB> KB could be freed by re-running
+   these reads now (the fresh results would replace stale ones in context).
+
+   Suggested actions:
+   ```
+   Then list the top 5 stale entries (by sizeBytes descending) and suggest
+   re-running the specific tool that produced them (e.g., `re-run ashlr__read
+   on <implied subject>` if tool is ashlr__read or Read).
+
+7. **Inject recompression hint** as your next assistant message context:
+   > "ashlr: The above stale results are from 5+ turns ago. If any are still
+   > needed, consider re-running the relevant reads now with fresh context.
+   > Stale results from earlier turns remain in the conversation history and
+   > count against the context window even when no longer load-bearing."
+
+If the history file does not exist or is empty, tell the user: "No ashlr session history found — the tracker starts recording after the first ashlr__read or ashlr__grep call."
+
+If total stale bytes < 5 KB, tell the user: "Session looks clean — less than 5 KB of stale tool output. No recompression needed yet."

package/commands/ashlr-dashboard.md

@@ -0,0 +1,37 @@
+---
+name: ashlr-dashboard
+description: Rich token-savings dashboard — per-tool bar charts, 7d/30d sparklines, projected annual savings, and cost in dollars.
+---
+
+Run the dashboard script via Bash and show the user its output verbatim.
+
+Steps:
+
+1. Run this command:
+
+   ```
+   bun run ${CLAUDE_PLUGIN_ROOT}/scripts/savings-dashboard.ts
+   ```
+
+   If `$CLAUDE_PLUGIN_ROOT` is unset, fall back to resolving the plugin root by walking up from the current command file to find `.claude-plugin/plugin.json`, or use the path already known from other ashlr commands.
+
+2. Print the script's stdout **verbatim** inside a fenced code block (```) so the ANSI colors, Unicode box-drawing, bar charts, and sparklines all render correctly. The script is self-contained — it reads `~/.ashlr/stats.json` directly and renders a multi-panel view.
+
+3. Do not paraphrase, re-order, or summarize the numbers. The dashboard is the output — the user wants to see it as-is.
+
+4. After the verbatim block, add **at most one** short line of context:
+   - If the dashboard shows the "No stats.json found yet" panel: "Run any `ashlr__read`, `ashlr__grep`, or `ashlr__edit` call and this dashboard will come alive."
+   - If the projection section says "Not enough history yet": "Check back after a few more days of activity — the projection unlocks with ≥3 active days in the last 30."
+   - Otherwise: say nothing extra. The dashboard speaks for itself.
+
+Pricing note (only surface if asked): the dashboard uses a blended $5/M-token rate derived from Claude Sonnet 4.5 pricing ($3/M input, $15/M output) as a rough honest estimate for read-heavy workloads.
+
+If `$ARGUMENTS` contains `--by-tool`, also run:
+
+```sh
+bun run "${CLAUDE_PLUGIN_ROOT}/scripts/session-log-report.ts"
+```
+
+Append its stdout verbatim under a `## By tool` section after the main dashboard block. Display it inside a fenced code block so column alignment renders correctly.
+
+Related: `/ashlr-savings` gives the compact text-only version.

package/commands/ashlr-doctor.md

@@ -0,0 +1,56 @@
+---
+name: ashlr-doctor
+description: Diagnose an ashlr-plugin install — checks plugin path, version, MCP servers, hooks, stats, genome, and settings in under 10 seconds.
+---
+
+Run the diagnostics script and show the user what's wrong (and how to fix it).
+
+Steps:
+
+1. Run this command via Bash:
+
+   ```
+   bun run ${CLAUDE_PLUGIN_ROOT}/scripts/doctor.ts
+   ```
+
+   If `$CLAUDE_PLUGIN_ROOT` is unset, fall back to resolving the plugin root by walking up from the current command file to find `.claude-plugin/plugin.json`, or use the path already known from other ashlr commands.
+
+2. Print the script's stdout verbatim inside a fenced code block. Do not paraphrase, truncate, or re-order lines — the block is designed to be copy-pasted into a GitHub issue.
+
+3. Read the final summary line (`N warnings · M failures`). If either count is nonzero, ask the user a single targeted follow-up:
+
+   > "I see {N} warning(s) and {M} failure(s) above. Want me to apply the suggested fixes?"
+
+   Do not apply fixes without confirmation. Each `⚠` / `✗` line already contains the exact command to run.
+
+4. If the script itself exits non-zero (couldn't find the plugin root at all), print the stderr and stop — nothing else will work until that's resolved.
+
+## Cloud check
+
+The report includes a **cloud** section that pings `GET /healthz` on the
+ashlr backend with a 3-second timeout. Possible status lines:
+
+- `cloud: healthy (Xms)` — backend reachable; X is the round-trip time.
+- `cloud: unreachable (timeout/error)` — backend not responding. This is a
+  **warning only** — it does not mark the install as unhealthy or cause
+  the script to exit 1. The fix line suggests
+  `set ASHLR_API_URL_DISABLE=1 to suppress, or check https://status.ashlr.ai`.
+- `cloud: disabled (ASHLR_API_URL_DISABLE=1)` — check intentionally
+  suppressed. Use this in offline environments or CI runs without internet.
+
+**Env vars that control the cloud check:**
+
+| Variable | Default | Effect |
+|---|---|---|
+| `ASHLR_API_URL` | `https://api.ashlr.ai` | Override the backend URL (e.g., point at staging or localhost). |
+| `ASHLR_API_URL_DISABLE` | *(unset)* | Set to `1` to skip the ping entirely. |
+
+If `$ARGUMENTS` contains `--errors`, also run:
+
+```sh
+bun run "${CLAUDE_PLUGIN_ROOT}/scripts/errors-report.ts" $ARGUMENTS
+```
+
+(Strip `--errors` from the forwarded arguments if the script doesn't accept it.) Append its stdout verbatim under a `## Recent errors` section after the main diagnostics block. Display it inside a fenced code block.
+
+No preamble. No trailing summary beyond the follow-up question.

package/commands/ashlr-eco-mode.md

@@ -0,0 +1,92 @@
+---
+name: ashlr-eco-mode
+description: Toggle eco mode — aggressive token-saving behaviors that trade some response richness for lower session cost.
+argument-hint: "on | off | status"
+---
+
+Toggle eco mode for the current session.
+
+## Usage
+
+```
+/ashlr-eco-mode on      # enable eco mode
+/ashlr-eco-mode off     # disable eco mode
+/ashlr-eco-mode status  # show current eco mode state + active behaviors
+```
+
+## What eco mode does
+
+When `ASHLR_ECO=1` is set, the following behaviors activate automatically:
+
+| Behavior | Details |
+|----------|---------|
+| Auto-compact every 15 tool calls | Triggers `/ashlr-compact` automatically to prevent stale result accumulation |
+| Force genome grep | Errors if `.ashlrcode/genome/` is missing, with a link to `/ashlr-genome-init` |
+| Lower summarization threshold | Reduces LLM summarization threshold from 16384 → 12288 bytes (fires more often) |
+| Smart Task routing | Task tool calls without explicit `subagent_type` are routed to `ashlr:ashlr:explore` when the prompt is question-shaped (starts with what/where/how/find/explain/why/which/when/who) |
+| Suppress image attachments | Image data in tool results is stripped before processing |
+| Auto-activate `/ashlr-brief` | If `~/.ashlr/brief.json` is unset or `off`, eco-mode-on writes `level: standard` and eco-mode-off restores the prior level. See `/ashlr-brief` for details. |
+
+## Environment variable
+
+| Variable | Value | Effect |
+|----------|-------|--------|
+| `ASHLR_ECO` | `1` | Eco mode on |
+| `ASHLR_ECO` | unset / `0` | Eco mode off |
+
+The eco router hook (`hooks/pretooluse-eco-router.ts`) reads `ASHLR_ECO` and injects `subagent_type: "ashlr:ashlr:explore"` into question-shaped Task tool calls.
+
+The status line shows a `eco` badge when `ASHLR_ECO=1`.
+
+## Steps
+
+### `on`
+
+1. Set env var via Bash:
+   ```sh
+   export ASHLR_ECO=1
+   ```
+2. Print:
+   ```
+   Eco mode ON. Active behaviors:
+   - Auto-compact every 15 tool calls
+   - Force genome grep (error if .ashlrcode/genome/ missing)
+   - Summarization threshold: 12288 bytes (was 16384)
+   - Question-shaped Task calls routed to ashlr:ashlr:explore
+   - Image attachments suppressed in tool results
+
+   Run /ashlr-eco-mode off to disable.
+   ```
+
+### `off`
+
+1. Unset env var via Bash:
+   ```sh
+   unset ASHLR_ECO
+   ```
+2. Print: "Eco mode OFF. All behaviors restored to defaults."
+
+### `status`
+
+1. Check `ASHLR_ECO` in environment.
+2. If `ASHLR_ECO=1`:
+   ```
+   Eco mode: ON (ASHLR_ECO=1)
+
+   Active behaviors:
+   - Auto-compact every 15 tool calls              ✓
+   - Force genome grep                              ✓
+   - Summarization threshold: 12288 bytes           ✓ (default: 16384)
+   - Question Task routing → ashlr:ashlr:explore   ✓
+   - Image attachment suppression                   ✓
+   ```
+3. If off:
+   ```
+   Eco mode: OFF
+
+   Run /ashlr-eco-mode on to enable all token-saving behaviors.
+   ```
+
+### No argument
+
+Print the status (same as `status`).

package/commands/ashlr-genome-init.md

@@ -0,0 +1,24 @@
+---
+name: ashlr-genome-init
+description: Initialize a `.ashlrcode/genome/` in the current project so ashlr__grep can route through genome RAG for ~-84% token savings.
+---
+
+Initialize a genome for the user's current project.
+
+Run the following Bash command:
+
+```
+bun run ${CLAUDE_PLUGIN_ROOT}/scripts/genome-init.ts --dir "$(pwd)"
+```
+
+Pass `--force` only if the user explicitly asks to overwrite an existing genome.
+Pass `--minimal` only if the user asks to skip the auto-populated architecture/conventions sections.
+Pass `--summarize` if the user wants to use a local Ollama model to generate concise CLAUDE.md summaries instead of truncating. Requires Ollama running locally — falls back gracefully to truncation if unavailable.
+
+After the command runs:
+
+- Relay the script's stdout verbatim as the response.
+- If the script exits non-zero because a genome already exists, tell the user to re-run with `/ashlr-genome-init --force` only if they confirm they want to overwrite.
+- Do not read or modify any generated files unless the user asks.
+
+No preamble, no trailing summary beyond the script's output.

package/commands/ashlr-genome-keygen.md

@@ -0,0 +1,36 @@
+---
+name: ashlr-genome-keygen
+description: Generate an X25519 keypair for team-cloud genome v2 encryption and register the public half with Ashlr. Run this once per machine before running /ashlr-genome-team-init. Safe to re-run — a no-op when the machine's key is already registered.
+---
+
+Run the keygen script and show the user the outcome.
+
+Steps:
+
+1. Run via Bash:
+
+   ```
+   bun run ${CLAUDE_PLUGIN_ROOT}/scripts/genome-keygen.ts $ARGUMENTS
+   ```
+
+2. Print the script's stdout verbatim. Do not paraphrase — the user needs to see the exact pubkey path and value on first generation.
+
+3. If the script exits non-zero, surface its stderr:
+   - Exit 2: user hasn't signed in. Suggest `/ashlr-upgrade` first.
+   - Exit 3: network or server error. Suggest checking `$ASHLR_API_URL` and network.
+
+Flags (forwarded via `$ARGUMENTS`):
+
+| Flag | Purpose |
+|---|---|
+| `--force` | Regenerate even if a keypair already exists (key rotation). Previous envelopes will no longer decrypt — ask an admin to run `/ashlr-genome-rewrap`. |
+| `--dry-run` | Print what would happen, no network, no file writes |
+| `--endpoint <url>` | Override the default `https://api.ashlr.ai` |
+
+## What it does
+
+Generates a 32-byte X25519 keypair client-side. Saves both halves to `~/.ashlr/member-keys/<yourUserId>.json` with mode 0600. Uploads only the public half via `POST /user/genome-pubkey`. Your private key never leaves the machine.
+
+## Why
+
+Team-cloud genome v2 uses envelope encryption: admins wrap the team DEK for each member's public key; members unwrap with their private key on first pull. This replaces the v1 flow where you had to DM a 32-byte base64 string to a teammate via Signal / 1Password.

package/commands/ashlr-genome-loop.md

@@ -0,0 +1,118 @@
+---
+name: ashlr-genome-loop
+description: Inspect and control the automatic genome propose + consolidate loop (PostToolUse observer + SessionEnd consolidator).
+---
+
+The ashlr-plugin runs an automatic genome loop: a PostToolUse hook proposes
+architecture/decision-flavored observations to
+`.ashlrcode/genome/proposals.jsonl`, and a SessionEnd hook consolidates them
+back into section files when ≥ 3 are pending. This command exposes the
+loop's status and on/off state.
+
+Subcommands (arg to the slash command):
+
+- `status` — show pending proposal count, last consolidation timestamp, and
+  whether the loop is currently enabled.
+- `run` — force a consolidation pass on the current project's genome.
+- `on` — enable the loop (writes `~/.ashlr/config.json`).
+- `off` — disable the loop (writes `~/.ashlr/config.json`). The
+  `ASHLR_GENOME_AUTO=0` env var also disables it per-shell.
+
+Dispatch on `$1`:
+
+### If `$1` is empty or `status`
+
+Run the following Bash command and relay the output:
+
+```bash
+bash -c '
+set -e
+CFG="$HOME/.ashlr/config.json"
+LOG="$HOME/.ashlr/genome-consolidation.log"
+GENOME="$(pwd)/.ashlrcode/genome"
+PROPOSALS="$GENOME/proposals.jsonl"
+
+ENABLED="on"
+if [ "${ASHLR_GENOME_AUTO:-1}" = "0" ]; then ENABLED="off (env ASHLR_GENOME_AUTO=0)"; fi
+if [ -f "$CFG" ] && grep -q "\"genomeAuto\"[[:space:]]*:[[:space:]]*false" "$CFG" 2>/dev/null; then
+  ENABLED="off (~/.ashlr/config.json)"
+fi
+
+PENDING=0
+if [ -f "$PROPOSALS" ]; then
+  PENDING=$(grep -c . "$PROPOSALS" 2>/dev/null || echo 0)
+fi
+
+LAST="(never)"
+if [ -f "$LOG" ]; then
+  LAST=$(tail -n 1 "$LOG" 2>/dev/null | awk "{print \$1}")
+  [ -z "$LAST" ] && LAST="(never)"
+fi
+
+echo "ashlr genome loop — $ENABLED"
+echo "  pending proposals: $PENDING ($PROPOSALS)"
+echo "  last consolidation: $LAST"
+'
+```
+
+### If `$1` is `run`
+
+Run the following Bash command and relay its output verbatim:
+
+```bash
+bun run ${CLAUDE_PLUGIN_ROOT}/scripts/genome-auto-consolidate.ts --dir "$(pwd)"
+```
+
+If no output appears, say "No pending proposals to consolidate (need ≥ 3)."
+
+### If `$1` is `on`
+
+Run the following Bash command:
+
+```bash
+bash -c '
+mkdir -p "$HOME/.ashlr"
+CFG="$HOME/.ashlr/config.json"
+if [ -f "$CFG" ]; then
+  bun -e "
+    const fs = require(\"fs\");
+    const p = process.env.HOME + \"/.ashlr/config.json\";
+    let j = {};
+    try { j = JSON.parse(fs.readFileSync(p, \"utf-8\")); } catch {}
+    j.genomeAuto = true;
+    fs.writeFileSync(p, JSON.stringify(j, null, 2));
+    console.log(\"ashlr genome loop: enabled\");
+  "
+else
+  echo "{\"genomeAuto\": true}" > "$CFG"
+  echo "ashlr genome loop: enabled"
+fi
+'
+```
+
+### If `$1` is `off`
+
+Run the following Bash command:
+
+```bash
+bash -c '
+mkdir -p "$HOME/.ashlr"
+CFG="$HOME/.ashlr/config.json"
+if [ -f "$CFG" ]; then
+  bun -e "
+    const fs = require(\"fs\");
+    const p = process.env.HOME + \"/.ashlr/config.json\";
+    let j = {};
+    try { j = JSON.parse(fs.readFileSync(p, \"utf-8\")); } catch {}
+    j.genomeAuto = false;
+    fs.writeFileSync(p, JSON.stringify(j, null, 2));
+    console.log(\"ashlr genome loop: disabled\");
+  "
+else
+  echo "{\"genomeAuto\": false}" > "$CFG"
+  echo "ashlr genome loop: disabled"
+fi
+'
+```
+
+No preamble, no trailing summary beyond the command output.

package/commands/ashlr-genome-push.md

@@ -0,0 +1,36 @@
+---
+name: ashlr-genome-push
+description: Push the local .ashlrcode/genome/ to the team cloud. Safe to run any time; invoked automatically at SessionEnd after consolidation. No-op when the repo has no .cloud-id (i.e. team-genome not initialized) or when ASHLR_CLOUD_GENOME_DISABLE=1.
+---
+
+Run the push script and show the user the outcome.
+
+Steps:
+
+1. Run via Bash:
+
+   ```
+   bun run ${CLAUDE_PLUGIN_ROOT}/scripts/genome-cloud-push.ts $ARGUMENTS
+   ```
+
+2. Print the script's stdout verbatim. Don't paraphrase — exit-code-specific messages tell the user how to recover:
+   - Exit 0: success or no-op. Nothing to do.
+   - Exit 1: another push is in progress for this repo (lockfile held). Suggest retrying in a moment.
+   - Exit 2: auth / network / server error OR no local member keypair. Check the stderr for the specific cause. Common fixes: `/ashlr-genome-keygen`, `/ashlr-upgrade`, ask admin to re-wrap for you.
+
+Flags (forwarded via `$ARGUMENTS`):
+
+| Flag | Purpose |
+|---|---|
+| `--dry-run` | Enumerate + encrypt + show what would be POSTed, no network |
+| `--quiet` | Suppress stderr info messages — used by SessionEnd hook path |
+| `--endpoint <url>` | Override the default `https://api.ashlr.ai` |
+| `--cwd <dir>` | Use a different repo root (for testing) |
+
+## What it does
+
+1. Reads `.ashlrcode/genome/.cloud-id` to learn which team genome to push to.
+2. Acquires a cross-process lockfile at `.ashlrcode/genome/.push.lock` so concurrent pushes (e.g. two MCP processes or a hook + a manual CLI) serialize cleanly.
+3. Fetches your wrapped DEK via `GET /genome/:id/key-envelope` (T1) and unwraps with your local X25519 private key (T2).
+4. Enumerates `.ashlrcode/genome/{knowledge,vision,milestones,strategies}/*.md` + `manifest.json`, encrypts each with the DEK via AES-256-GCM, and POSTs with a bumped per-machine vclock component.
+5. Persists the new vclock only on a successful push so a mid-push crash doesn't leave a ghost-bumped clock.

package/commands/ashlr-genome-rewrap.md

@@ -0,0 +1,48 @@
+---
+name: ashlr-genome-rewrap
+description: Re-wrap the team-cloud genome DEK for every member with a current pubkey. Run this after a teammate rotates their keypair (/ashlr-genome-keygen --force) or joins the team and runs /ashlr-genome-keygen for the first time. Admin-only.
+argument-hint: "[--rotate-dek] [--endpoint <url>]"
+---
+
+Run the rewrap script and show the user its output verbatim.
+
+Steps:
+
+1. Run via Bash:
+
+   ```sh
+   bun run ${CLAUDE_PLUGIN_ROOT}/scripts/genome-rewrap.ts $ARGUMENTS
+   ```
+
+2. Print the script's stdout verbatim — the per-member wrap log is what
+   the admin needs to confirm success.
+
+3. If the script exits non-zero, surface its stderr:
+   - Exit 2: prereq missing — likely no Pro token, no local keypair, or
+     no `.cloud-id` in this repo. Suggest the relevant skill:
+     `/ashlr-upgrade`, `/ashlr-genome-keygen`, or `/ashlr-genome-team-init`.
+   - Exit 3: network / server error. Suggest checking `$ASHLR_API_URL`
+     and the team's tier (rewrap requires Team tier).
+
+Flags (forwarded via `$ARGUMENTS`):
+
+| Flag | Purpose |
+|---|---|
+| `--rotate-dek` | Generate a fresh team DEK before wrapping. Invalidates every existing envelope. Use after a suspected key compromise. |
+| `--endpoint <url>` | Override the default `https://api.ashlr.ai` |
+| `--cwd <dir>` | Repo to operate on (default cwd) |
+
+## When to use
+
+- A teammate ran `/ashlr-genome-keygen --force` (rotated their key); their
+  previous envelope no longer decrypts.
+- A new teammate joined the team and ran `/ashlr-genome-keygen`; they now
+  have a pubkey on file but no envelope yet.
+- Suspected key compromise — run with `--rotate-dek` to mint a fresh DEK
+  and invalidate every prior envelope at once.
+
+## What it does
+
+Re-wraps the existing team DEK for every member with a current pubkey on
+file. With `--rotate-dek`, generates a fresh DEK first so every old
+envelope is invalidated.

package/commands/ashlr-genome-team-init.md

@@ -0,0 +1,67 @@
+---
+name: ashlr-genome-team-init
+description: Initialize (or rewrap for new members of) a team-cloud genome for the current repo. One-time per repo by an admin; then teammates join via /ashlr-team-invite + /ashlr-genome-keygen + admin re-runs with --wrap-all.
+---
+
+Run the team-init script and show the user the outcome.
+
+Steps:
+
+1. Run via Bash:
+
+   ```
+   bun run ${CLAUDE_PLUGIN_ROOT}/scripts/genome-team-init.ts $ARGUMENTS
+   ```
+
+2. Print the script's stdout verbatim. Don't paraphrase — the user needs to see the `genomeId` and `.cloud-id` path to understand what to commit.
+
+3. If the script exits non-zero, surface its stderr:
+   - Exit 2: prereq missing. Most common: `/ashlr-upgrade` (no pro-token), `/ashlr-genome-keygen` (no local member keypair), team-tier not reached, no git remote.
+   - Exit 3: network / server error.
+
+Flags (forwarded via `$ARGUMENTS`):
+
+| Flag | Purpose |
+|---|---|
+| `--force` | Reinitialize even if `.cloud-id` already exists. **This rotates the DEK** — existing team envelopes stop working until re-wrapped. |
+| `--wrap-all` | Skip init; just mint envelopes for every team member with a pubkey on file. Use after adding a teammate (`/ashlr-team-invite` + they run `/ashlr-genome-keygen`). |
+| `--endpoint <url>` | Override the default `https://api.ashlr.ai` |
+| `--cwd <dir>` | Use a different repo root |
+
+## What it does (fresh init)
+
+1. Resolves the repo URL from `git remote get-url origin`.
+2. `POST /genome/init` — server allocates a new `genomeId` scoped to your team.
+3. Generates a fresh 32-byte DEK client-side.
+4. Wraps the DEK for your own X25519 pubkey (via T2's `wrapDek`).
+5. `POST /genome/:id/key-envelope` — uploads the self-wrapped envelope so your push path immediately works.
+6. Writes `.ashlrcode/genome/.cloud-id` so subsequent pushes (and SessionStart pulls, T5) find the genome.
+
+Commit `.ashlrcode/genome/.cloud-id` to the repo so teammates auto-discover the cloud genome on checkout.
+
+## What it does (--wrap-all)
+
+1. Reads `.cloud-id`, fetches your own envelope, unwraps to recover the team DEK.
+2. Lists all team members + their registered pubkeys (via `GET /genome/:id/members`).
+3. For each member with a pubkey, wraps the DEK and uploads the envelope.
+4. Reports who got wrapped and who was skipped (no pubkey yet — they need to run `/ashlr-genome-keygen`).
+
+## Typical team setup
+
+```
+# on admin's machine
+/ashlr-upgrade                            # get pro-token (team tier)
+/ashlr-genome-keygen                      # generate X25519 keypair
+/ashlr-genome-team-init                   # bootstrap genome, self-wrap
+git add .ashlrcode/genome/.cloud-id && git commit -m "chore: team genome" && git push
+
+# on each teammate's machine
+/ashlr-upgrade                            # same (or accept invite first)
+/ashlr-genome-keygen                      # generate their X25519 keypair
+# wait for admin...
+
+# back on admin's machine
+/ashlr-genome-team-init --wrap-all        # mint envelopes for the new pubkeys
+
+# teammate pulls, next /ashlr-genome-push works
+```

package/commands/ashlr-handoff.md

@@ -0,0 +1,23 @@
+---
+name: ashlr-handoff
+description: Generate a context-pack for the next session to resume cold.
+argument-hint: ""
+---
+
+Generate a plain-text handoff that can be pasted into a fresh Claude Code
+session. Renders branch/dirty state, last 5 commits, genome state, top
+session tools, and top lifetime projects — all in ASCII so it copies
+cleanly.
+
+Run via Bash:
+
+```sh
+bun run ${CLAUDE_PLUGIN_ROOT}/scripts/savings-dashboard.ts --handoff
+```
+
+Print the script's stdout verbatim — do not paraphrase. The output is
+designed to be copy-pasted, so any reformatting from this skill weakens
+the handoff.
+
+If the script fails, fall back to telling the user:
+`/ashlr-dashboard --handoff failed — run git log and check status line.`