@kurokeita/add-skill 1.17.2 → 1.19.0

package/dist/skills/gh-fix-ci/SKILL.md

@@ -21,7 +21,11 @@ Prereq: authenticate with the standard GitHub CLI once (for example, run `gh aut
 
 ## Quick start
 
-- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "<number-or-url>"`
+- Detect the interpreter first:
+  `PYTHON_BIN=$(command -v python || command -v python3 || true)`
+- If `PYTHON_BIN` is empty, skip the bundled script and use the manual `gh` fallback workflow.
+- Otherwise run:
+  `"$PYTHON_BIN" "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "<number-or-url>"`
 - Add `--json` if you want machine-friendly output for summarization.
 
 ## Workflow
@@ -34,7 +38,11 @@ Prereq: authenticate with the standard GitHub CLI once (for example, run `gh aut
    - If the user provides a PR number or URL, use that directly.
 3. Inspect failing checks (GitHub Actions only).
    - Preferred: run the bundled script (handles gh field drift and job-log fallbacks):
-     - `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "<number-or-url>"`
+     - Resolve the interpreter first:
+       `PYTHON_BIN=$(command -v python || command -v python3 || true)`
+     - If `PYTHON_BIN` is set, run:
+       `"$PYTHON_BIN" "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "<number-or-url>"`
+     - If neither `python` nor `python3` is available, skip the bundled script and use the manual fallback below.
      - Add `--json` for machine-friendly output.
    - Manual fallback:
      - `gh pr checks <pr> --json name,state,bucket,link,startedAt,completedAt,workflow`
@@ -65,6 +73,6 @@ Fetch failing PR checks, pull GitHub Actions logs, and extract a failure snippet
 
 Usage examples:
 
-- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "123"`
-- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "https://github.com/org/repo/pull/123" --json`
-- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --max-lines 200 --context 40`
+- `PYTHON_BIN=$(command -v python || command -v python3 || true); test -n "$PYTHON_BIN" && "$PYTHON_BIN" "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "123"`
+- `PYTHON_BIN=$(command -v python || command -v python3 || true); test -n "$PYTHON_BIN" && "$PYTHON_BIN" "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "https://github.com/org/repo/pull/123" --json`
+- `PYTHON_BIN=$(command -v python || command -v python3 || true); test -n "$PYTHON_BIN" && "$PYTHON_BIN" "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --max-lines 200 --context 40`

package/dist/skills/grill-me/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: grill-me
+description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
+---
+
+# Grill me
+
+Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
+If a question can be answered by exploring the codebase, explore the codebase instead.

package/dist/skills/prd-to-tasks/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: prd-to-tasks
+description: >
+  Break a local PRD into independently grabbable implementation tasks using vertical slices, then save them under
+  .prd/{prd-name}/tasks/ in the current workspace. Use when the user wants to convert a PRD to tasks, break a spec
+  into actionable work, slice a PRD, or create implementation tasks from a local planning document. Do NOT trigger
+  for: writing PRDs, reviewing PRDs without task creation, or remote work item management systems.
+argument-hint: "[prd-name]"
+---
+
+# PRD to Tasks
+
+Break a local PRD into independently grabbable implementation tasks using vertical slices.
+
+Input location:
+
+- PRD directory: `.prd/{prd-name}/`
+- Source PRD: `.prd/{prd-name}/prd.md`
+
+Output location:
+
+- Tasks directory: `.prd/{prd-name}/tasks/`
+- Optional index: `.prd/{prd-name}/tasks/README.md`
+
+`{prd-name}` should be a filesystem-safe kebab-case slug. If the user provides a title instead, normalize it to a slug
+and state the slug you used.
+
+## Step 1: Locate the PRD
+
+If the user provided `$ARGUMENTS`, treat that as the PRD name and normalize it.
+
+If not, ask which PRD directory to use.
+
+Then:
+
+1. Confirm `.prd/{prd-name}/prd.md` exists
+2. Read it fully
+3. Check whether `.prd/{prd-name}/tasks/` already exists
+4. If task files already exist, summarize them and ask whether to overwrite, append, or regenerate selectively
+
+If the PRD does not exist, stop and tell the user exactly which path is missing.
+
+## Step 2: Explore the codebase
+
+If you have not already explored the relevant code in this conversation, do so now:
+
+1. Read top-level architecture guidance if present
+2. Search for code related to the PRD concepts
+3. Read nearby guidance files for affected subsystems
+4. Look for similar features and test patterns
+
+The PRD tells you *what* to build. The codebase tells you enough about *where* and *how* to create useful tasks.
+
+## Step 3: Draft vertical slices
+
+Break the PRD into **tracer bullet** tasks.
+
+### What is a tracer bullet?
+
+A tracer bullet is a thin vertical slice through the whole feature path. It proves that the relevant layers connect
+correctly end to end. It is not a horizontal "build all backend first, then all UI" slice.
+
+Prefer slices that are:
+
+- Independently verifiable
+- Demoable on their own
+- Thin and end to end
+- Ordered by dependency
+
+### HITL vs AFK
+
+Each slice should be marked:
+
+- `HITL`: needs human input, review, testing on real devices, design signoff, or external coordination
+- `AFK`: can be implemented and validated without waiting on a person
+
+### Vertical slice rules
+
+- Each slice should deliver a complete behavior, not one technical layer
+- Prefer many thin slices over a few broad ones
+- Use the PRD's module design to inform slicing, but do not create one task per module
+- Order slices so blockers come first
+
+## Step 4: Quiz the user
+
+Present the proposed slices as a numbered list. For each slice, include:
+
+- Title
+- Type: `HITL` or `AFK`
+- Blocked by
+- User stories covered
+
+Ask the user whether:
+
+- The granularity is right
+- The dependencies are correct
+- Any slices should be merged or split
+- The `HITL` versus `AFK` labels are accurate
+
+Iterate until approved.
+
+## Step 5: Write task files
+
+Only write files after the user approves the breakdown.
+
+Create `.prd/{prd-name}/tasks/` if needed.
+
+Create one Markdown file per task using zero-padded numeric prefixes:
+
+- `.prd/{prd-name}/tasks/01-{task-slug}.md`
+- `.prd/{prd-name}/tasks/02-{task-slug}.md`
+
+`{task-slug}` should be kebab-case and derived from the task title.
+
+Each task file should use this structure:
+
+```md
+# {Task title}
+
+- Type: AFK | HITL
+- Status: Proposed
+- Blocked by: None | 01-other-task
+- Source PRD: ../prd.md
+
+## What to Build
+
+Concise description of the vertical slice. Describe end-to-end behavior, not a layer-by-layer checklist.
+
+## Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## User Stories Addressed
+
+- User story 3
+- User story 7
+
+## Notes
+
+- Optional implementation hints grounded in the current codebase
+- Reference relevant modules or concepts, but avoid binding the task to fragile file-level details unless necessary
+```
+
+Also create or update `.prd/{prd-name}/tasks/README.md` with:
+
+- The PRD title
+- The approved slice list in dependency order
+- A short summary of each task
+
+## Important constraints
+
+- Do not modify `prd.md` unless the user asks
+- Do not delete existing task files unless the user explicitly approves replacement
+- If existing tasks overlap the proposed slices, call that out before writing duplicates
+
+## After writing
+
+Summarize:
+
+- The PRD slug used
+- The task files created or updated
+- Any existing task files that were preserved

package/dist/skills/statusline-setup/SKILL.md

@@ -0,0 +1,479 @@
+---
+name: statusline-setup
+description: 'Set up the Claude Code statusline with cwd, git branch, model, context %, session token totals, and 5h/7d quota usage with ETA. Use when asked to "set up my statusline", "install statusline", "configure Claude Code statusline", or to add a colored status line showing rate limits and token usage. Detects OS and installs the appropriate variant (bash + jq on Linux/macOS, PowerShell on Windows).'
+---
+
+# Statusline Setup
+
+Install a Claude Code statusline that renders, left to right, pipe-separated:
+
+1. **cwd** — 24-bit ANSI `#5EFFFF` (`38;2;94;255;255`), with `$HOME` / `%USERPROFILE%` shortened to `~`.
+2. **git branch** in parentheses — 24-bit ANSI `#C24870` (`38;2;194;72;112`), only when inside a repo.
+3. **model display name + effort** in parens — 24-bit ANSI `#E89440` (`38;2;232;148;64`), effort only when present.
+4. **`ctx N%`** — 24-bit ANSI `#009AFB` (`38;2;0;154;251`), the `context_window.used_percentage`.
+5. **tokens** as `↑<in> ↓<out>` — 24-bit ANSI `#937bda` (`38;2;147;123;218`), its own pipe-separated segment immediately after `ctx`.
+6. **`5h:N%(eta)`** and **`7d:N%(eta)`** — colored independently by remaining quota (see below).
+
+Segments are joined with ANSI `0;37` pipes (` | `).
+
+## When to Use This Skill
+
+- "Set up my Claude Code statusline"
+- "Install the statusline"
+- "Configure my statusline with token counts and quota"
+- Any request to add a colored status line showing context %, rate limits, or session tokens.
+
+## OS Detection
+
+Detect the platform first and install only the matching variant:
+
+- **Linux / macOS** → write `~/.claude/statusline-command.sh` (pure bash + `jq`), wire into `~/.claude/settings.json`.
+- **Windows** → write `%USERPROFILE%\.claude\statusline-command.ps1`, wire into `%USERPROFILE%\.claude\settings.json`.
+
+## Token Formatting
+
+- `< 1000` → raw integer (e.g. `↑850 ↓120`)
+- `>= 1_000` → one decimal + `k` (e.g. `↑1.2k ↓34.5k`)
+- `>= 1_000_000` → one decimal + `M` (e.g. `↑1.2M ↓3.4M`)
+- Missing/unparseable transcript → omit the segment entirely (no stray separator, never render `↑0 ↓0`).
+
+## Token Source
+
+Claude Code does **not** include token totals in the statusline JSON. Read `transcript_path` (JSONL, one message per line) and sum across **assistant** messages:
+
+- `input` = `message.usage.input_tokens` + `message.usage.cache_creation_input_tokens` + `message.usage.cache_read_input_tokens`
+- `output` = `message.usage.output_tokens`
+
+Skip lines that fail JSON parsing or lack `message.usage`. If `transcript_path` is missing or the file does not exist, omit the tokens segment.
+
+## Quota Colors (by REMAINING quota = 100 - used%)
+
+| Remaining | Color | 24-bit ANSI |
+|-----------|-------|-------------|
+| `> 60%` | bright green `#4eba65` | `38;2;78;186;101` |
+| `31–60%` | amber `#de8e3e` | `38;2;222;142;62` |
+| `11–30%` | orange `#ea580c` | `38;2;234;88;12` |
+| `<= 10%` | deep red-orange `#b74426` | `38;2;183;68;38` |
+
+The 5h and 7d windows must be colored **independently**.
+
+## ETA Format (from epoch seconds in `resets_at`)
+
+- `> 1 day` → `Xd Yh`
+- `> 1 hour` → `Xh Ym`
+- else → `Xm`
+- past → `now`
+
+## Input Schema (stdin JSON)
+
+Any field may be missing:
+
+```
+cwd
+transcript_path
+model.display_name
+effort.level
+context_window.used_percentage
+rate_limits.five_hour.used_percentage
+rate_limits.five_hour.resets_at
+rate_limits.seven_day.used_percentage
+rate_limits.seven_day.resets_at
+```
+
+## Linux / macOS Implementation
+
+Write `~/.claude/statusline-command.sh` (chmod +x). Pure bash + `jq` — no Python. `jq` must be installed (`apt install jq`, `brew install jq`, etc.); if missing, the script prints a one-line hint and exits 0 so the statusline area stays clean.
+
+JSON parsing rules:
+
+- Read the full stdin payload **once** with `cat`, parse all fields with a single `jq` call.
+- For the JSONL transcript, invoke `jq` **once over the whole file** (do not call `jq` per line) — use a streaming filter that reduces over `inputs`.
+
+`~/.claude/statusline-command.sh`:
+
+```bash
+#!/usr/bin/env bash
+# Claude Code statusline — pure bash + jq.
+
+set -u
+
+if ! command -v jq >/dev/null 2>&1; then
+  printf '%s' "statusline: jq not installed"
+  exit 0
+fi
+
+C_CWD=$'\033[38;2;94;255;255m'
+C_BRANCH=$'\033[38;2;194;72;112m'
+C_PIPE=$'\033[0;37m'
+C_MODEL=$'\033[38;2;232;148;64m'
+C_CTX=$'\033[38;2;0;154;251m'
+C_TOK=$'\033[38;2;147;123;218m'
+RESET=$'\033[0m'
+
+GREEN=$'\033[38;2;78;186;101m'
+AMBER=$'\033[38;2;222;142;62m'
+ORANGE=$'\033[38;2;234;88;12m'
+REDORG=$'\033[38;2;183;68;38m'
+
+quota_color() {
+  local used="$1"
+  local rem=$(( 100 - used ))
+  if   (( rem > 60 )); then printf '%s' "$GREEN"
+  elif (( rem > 30 )); then printf '%s' "$AMBER"
+  elif (( rem > 10 )); then printf '%s' "$ORANGE"
+  else                       printf '%s' "$REDORG"
+  fi
+}
+
+fmt_eta() {
+  local resets="$1"
+  [[ -z "$resets" || "$resets" == "null" ]] && { printf ''; return; }
+  local now delta days hours mins
+  now=$(date +%s)
+  delta=$(( resets - now ))
+  if   (( delta <= 0 )); then printf 'now'
+  elif (( delta >= 86400 )); then
+    days=$(( delta / 86400 )); hours=$(( (delta % 86400) / 3600 ))
+    printf '%dd %dh' "$days" "$hours"
+  elif (( delta >= 3600 )); then
+    hours=$(( delta / 3600 )); mins=$(( (delta % 3600) / 60 ))
+    printf '%dh %dm' "$hours" "$mins"
+  else
+    mins=$(( delta / 60 ))
+    printf '%dm' "$mins"
+  fi
+}
+
+fmt_tokens() {
+  local n="$1"
+  if   (( n < 1000 )); then printf '%d' "$n"
+  elif (( n < 1000000 )); then awk -v n="$n" 'BEGIN{printf "%.1fk", n/1000}'
+  else                       awk -v n="$n" 'BEGIN{printf "%.1fM", n/1000000}'
+  fi
+}
+
+shorten_home() {
+  local p="$1"
+  [[ -z "$p" ]] && return
+  if [[ "$p" == "$HOME" ]]; then printf '~'
+  elif [[ "$p" == "$HOME"/* ]]; then printf '~%s' "${p#$HOME}"
+  else printf '%s' "$p"
+  fi
+}
+
+# --- read & parse stdin payload in a single jq call ---
+payload=$(cat)
+if [[ -z "${payload// }" ]]; then payload='{}'; fi
+
+read_fields() {
+  jq -r '
+    [
+      .cwd // "",
+      .transcript_path // "",
+      .model.display_name // "",
+      .effort.level // "",
+      (.context_window.used_percentage // "" | tostring),
+      (.rate_limits.five_hour.used_percentage // "" | tostring),
+      (.rate_limits.five_hour.resets_at // "" | tostring),
+      (.rate_limits.seven_day.used_percentage // "" | tostring),
+      (.rate_limits.seven_day.resets_at // "" | tostring)
+    ] | join("\u001f")
+  ' 2>/dev/null <<<"$payload"
+}
+
+IFS=$'\x1f' read -r cwd transcript model effort ctx five_used five_reset seven_used seven_reset < <(read_fields)
+
+segments=()
+
+if [[ -n "$cwd" ]]; then
+  segments+=("${C_CWD}$(shorten_home "$cwd")${RESET}")
+fi
+
+# Branch: must use git -C "$cwd", never PWD.
+branch=""
+if [[ -n "$cwd" ]]; then
+  branch=$(git -C "$cwd" rev-parse --abbrev-ref HEAD 2>/dev/null) || branch=""
+fi
+if [[ -n "$branch" ]]; then
+  segments+=("${C_BRANCH}(${branch})${RESET}")
+fi
+
+if [[ -n "$model" ]]; then
+  if [[ -n "$effort" ]]; then
+    segments+=("${C_MODEL}${model} (${effort})${RESET}")
+  else
+    segments+=("${C_MODEL}${model}${RESET}")
+  fi
+fi
+
+if [[ -n "$ctx" ]]; then
+  ctx_int=$(awk -v n="$ctx" 'BEGIN{printf "%d", (n+0.5)}')
+  segments+=("${C_CTX}ctx ${ctx_int}%${RESET}")
+fi
+
+# --- tokens: one jq pass over the whole JSONL transcript ---
+if [[ -n "$transcript" && -f "$transcript" ]]; then
+  tok=$(jq -rs '
+    reduce .[] as $m ({i:0,o:0};
+      ($m.message.usage // null) as $u
+      | if $u == null then .
+        else
+          .i += (($u.input_tokens // 0) + ($u.cache_creation_input_tokens // 0) + ($u.cache_read_input_tokens // 0))
+          | .o += ($u.output_tokens // 0)
+        end
+    )
+    | "\(.i)\t\(.o)"
+  ' "$transcript" 2>/dev/null) || tok=""
+  if [[ -n "$tok" ]]; then
+    IFS=$'\t' read -r ti to <<<"$tok"
+    if (( ti > 0 || to > 0 )); then
+      segments+=("${C_TOK}↑$(fmt_tokens "$ti") ↓$(fmt_tokens "$to")${RESET}")
+    fi
+  fi
+fi
+
+if [[ -n "$five_used" ]]; then
+  fu=$(awk -v n="$five_used" 'BEGIN{printf "%d", (n+0.5)}')
+  eta=$(fmt_eta "$five_reset")
+  segments+=("$(quota_color "$fu")5h:${fu}%(${eta})${RESET}")
+fi
+if [[ -n "$seven_used" ]]; then
+  su=$(awk -v n="$seven_used" 'BEGIN{printf "%d", (n+0.5)}')
+  eta=$(fmt_eta "$seven_reset")
+  segments+=("$(quota_color "$su")7d:${su}%(${eta})${RESET}")
+fi
+
+sep=" ${C_PIPE}|${RESET} "
+out=""
+for i in "${!segments[@]}"; do
+  if (( i == 0 )); then out="${segments[$i]}"
+  else out="${out}${sep}${segments[$i]}"
+  fi
+done
+printf '%s' "$out"
+```
+
+Wire into `~/.claude/settings.json` (merge into existing JSON, don't clobber other keys):
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "bash ~/.claude/statusline-command.sh"
+  }
+}
+```
+
+## Windows Implementation
+
+Write `%USERPROFILE%\.claude\statusline-command.ps1`. Use `ConvertFrom-Json` (no Python dep). Read the JSONL transcript with `Get-Content -ReadCount 0` and `ConvertFrom-Json` per line inside try/catch. Use `[char]27` for ANSI escapes (works on PS 5.1 and 7+). Read stdin with `[Console]::In.ReadToEnd()`.
+
+`%USERPROFILE%\.claude\statusline-command.ps1`:
+
+```powershell
+$ErrorActionPreference = 'SilentlyContinue'
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+$OutputEncoding = [System.Text.Encoding]::UTF8
+$ESC = [char]27
+
+$C_CWD    = "$ESC[38;2;94;255;255m"
+$C_BRANCH = "$ESC[38;2;194;72;112m"
+$C_PIPE   = "$ESC[0;37m"
+$C_MODEL  = "$ESC[38;2;232;148;64m"
+$C_CTX    = "$ESC[38;2;0;154;251m"
+$C_TOK    = "$ESC[38;2;147;123;218m"
+$RESET    = "$ESC[0m"
+
+$GREEN  = "$ESC[38;2;78;186;101m"
+$AMBER  = "$ESC[38;2;222;142;62m"
+$ORANGE = "$ESC[38;2;234;88;12m"
+$REDORG = "$ESC[38;2;183;68;38m"
+
+function QuotaColor([double]$used) {
+  $remaining = 100 - $used
+  if ($remaining -gt 60) { return $GREEN }
+  if ($remaining -gt 30) { return $AMBER }
+  if ($remaining -gt 10) { return $ORANGE }
+  return $REDORG
+}
+
+function FmtEta($resetsAt) {
+  if ($null -eq $resetsAt) { return "" }
+  $delta = [int64]$resetsAt - [int64](Get-Date -UFormat %s)
+  if ($delta -le 0) { return "now" }
+  $days = [math]::Floor($delta / 86400); $delta = $delta % 86400
+  $hours = [math]::Floor($delta / 3600); $delta = $delta % 3600
+  $mins = [math]::Floor($delta / 60)
+  if ($days -gt 0)  { return "${days}d ${hours}h" }
+  if ($hours -gt 0) { return "${hours}h ${mins}m" }
+  return "${mins}m"
+}
+
+function FmtTokens([int64]$n) {
+  if ($n -lt 1000) { return "$n" }
+  if ($n -lt 1000000) { return ("{0:N1}k" -f ($n / 1000.0)) }
+  return ("{0:N1}M" -f ($n / 1000000.0))
+}
+
+function ShortenHome($p) {
+  if (-not $p) { return "" }
+  $home = $env:USERPROFILE
+  if ($p -eq $home) { return "~" }
+  if ($p.StartsWith("$home\")) { return "~" + $p.Substring($home.Length) }
+  return $p
+}
+
+function GetBranch($cwd) {
+  if (-not $cwd) { return $null }
+  try {
+    $b = & git -C "$cwd" rev-parse --abbrev-ref HEAD 2>$null
+    if ($LASTEXITCODE -eq 0 -and $b) { return $b.Trim() }
+  } catch {}
+  return $null
+}
+
+function SumTokens($path) {
+  if (-not $path) { return $null }
+  if (-not (Test-Path -LiteralPath $path)) { return $null }
+  $sumIn = 0; $sumOut = 0; $found = $false
+  $lines = Get-Content -LiteralPath $path -ReadCount 0 -ErrorAction SilentlyContinue
+  if ($null -eq $lines) { return $null }
+  foreach ($line in $lines) {
+    if (-not $line) { continue }
+    try { $obj = $line | ConvertFrom-Json -ErrorAction Stop } catch { continue }
+    $msg = $obj.message
+    if (-not $msg) { continue }
+    $usage = $msg.usage
+    if (-not $usage) { continue }
+    $found = $true
+    if ($usage.input_tokens)              { $sumIn  += [int64]$usage.input_tokens }
+    if ($usage.cache_creation_input_tokens) { $sumIn  += [int64]$usage.cache_creation_input_tokens }
+    if ($usage.cache_read_input_tokens)    { $sumIn  += [int64]$usage.cache_read_input_tokens }
+    if ($usage.output_tokens)             { $sumOut += [int64]$usage.output_tokens }
+  }
+  if (-not $found) { return $null }
+  return ,@($sumIn, $sumOut)
+}
+
+$raw = [Console]::In.ReadToEnd()
+try { $data = if ($raw.Trim()) { $raw | ConvertFrom-Json } else { @{} } } catch { $data = @{} }
+
+$segments = @()
+
+$cwd = $data.cwd
+if ($cwd) { $segments += "$C_CWD$(ShortenHome $cwd)$RESET" }
+
+$branch = GetBranch $cwd
+if ($branch) { $segments += "$C_BRANCH($branch)$RESET" }
+
+$model = $data.model.display_name
+$effort = $data.effort.level
+if ($model) {
+  if ($effort) { $segments += "$C_MODEL$model ($effort)$RESET" }
+  else         { $segments += "$C_MODEL$model$RESET" }
+}
+
+$ctx = $data.context_window.used_percentage
+if ($null -ne $ctx) { $segments += "$C_CTX" + "ctx " + [int][math]::Round([double]$ctx) + "%$RESET" }
+
+$tokens = SumTokens $data.transcript_path
+if ($null -ne $tokens) {
+  $segments += "$C_TOK↑$(FmtTokens $tokens[0]) ↓$(FmtTokens $tokens[1])$RESET"
+}
+
+$five = $data.rate_limits.five_hour
+$seven = $data.rate_limits.seven_day
+if ($null -ne $five.used_percentage) {
+  $u = [double]$five.used_percentage
+  $segments += "$(QuotaColor $u)5h:$([int][math]::Round($u))%($(FmtEta $five.resets_at))$RESET"
+}
+if ($null -ne $seven.used_percentage) {
+  $u = [double]$seven.used_percentage
+  $segments += "$(QuotaColor $u)7d:$([int][math]::Round($u))%($(FmtEta $seven.resets_at))$RESET"
+}
+
+$sep = " $C_PIPE|$RESET "
+[Console]::Out.Write([string]::Join($sep, $segments))
+```
+
+Wire into `%USERPROFILE%\.claude\settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "powershell.exe -NoProfile -ExecutionPolicy Bypass -File \"%USERPROFILE%\\.claude\\statusline-command.ps1\""
+  }
+}
+```
+
+## Smoke Test
+
+After installing, generate a fake JSON payload with 5h at 80% used, 7d at 50% used, both with future `resets_at`, plus a `transcript_path` pointing at a small fixture JSONL containing two assistant messages with `usage` blocks. Pipe it into the script and confirm:
+
+- 5h renders **orange**, 7d renders **amber**.
+- cwd, model, and context % are present.
+- Tokens segment renders `↑<sum> ↓<sum>` matching the fixture, in `#937bda`, as its own pipe-separated segment immediately after `ctx`.
+- Omitting `transcript_path` hides the tokens segment cleanly (no stray separator).
+
+### Linux/macOS smoke test
+
+```bash
+mkdir -p /tmp/statusline-smoke
+cat >/tmp/statusline-smoke/transcript.jsonl <<'EOF'
+{"type":"assistant","message":{"role":"assistant","usage":{"input_tokens":100,"cache_creation_input_tokens":200,"cache_read_input_tokens":300,"output_tokens":50}}}
+{"type":"assistant","message":{"role":"assistant","usage":{"input_tokens":10,"cache_creation_input_tokens":20,"cache_read_input_tokens":30,"output_tokens":5}}}
+EOF
+FUTURE=$(($(date +%s) + 7200))
+FUTURE7=$(($(date +%s) + 3*86400))
+printf '{"cwd":"%s","transcript_path":"/tmp/statusline-smoke/transcript.jsonl","model":{"display_name":"Opus 4.7"},"effort":{"level":"medium"},"context_window":{"used_percentage":42},"rate_limits":{"five_hour":{"used_percentage":80,"resets_at":%d},"seven_day":{"used_percentage":50,"resets_at":%d}}}' "$HOME" "$FUTURE" "$FUTURE7" | bash ~/.claude/statusline-command.sh; echo
+```
+
+### Windows smoke test (PowerShell)
+
+```powershell
+$tmp = "$env:TEMP\statusline-smoke"
+New-Item -ItemType Directory -Force -Path $tmp | Out-Null
+@'
+{"type":"assistant","message":{"role":"assistant","usage":{"input_tokens":100,"cache_creation_input_tokens":200,"cache_read_input_tokens":300,"output_tokens":50}}}
+{"type":"assistant","message":{"role":"assistant","usage":{"input_tokens":10,"cache_creation_input_tokens":20,"cache_read_input_tokens":30,"output_tokens":5}}}
+'@ | Set-Content -LiteralPath "$tmp\transcript.jsonl" -Encoding UTF8
+$future = [int64](Get-Date -UFormat %s) + 7200
+$future7 = [int64](Get-Date -UFormat %s) + 3*86400
+$payload = @{
+  cwd = $env:USERPROFILE
+  transcript_path = "$tmp\transcript.jsonl"
+  model = @{ display_name = "Opus 4.7" }
+  effort = @{ level = "medium" }
+  context_window = @{ used_percentage = 42 }
+  rate_limits = @{
+    five_hour = @{ used_percentage = 80; resets_at = $future }
+    seven_day = @{ used_percentage = 50; resets_at = $future7 }
+  }
+} | ConvertTo-Json -Depth 5 -Compress
+$payload | powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$env:USERPROFILE\.claude\statusline-command.ps1"
+```
+
+## Color Preview One-Liner
+
+After install, output a one-liner the user can paste to preview all four quota tiers, with both 5h and 7d on each line, separated by ` | `, one tier per line.
+
+### Bash form
+
+```bash
+printf '\033[38;2;78;186;101m5h:20%%(2h30m)\033[0m \033[0;37m|\033[0m \033[38;2;78;186;101m7d:25%%(3d12h)\033[0m\n\033[38;2;222;142;62m5h:55%%(2h30m)\033[0m \033[0;37m|\033[0m \033[38;2;222;142;62m7d:45%%(3d12h)\033[0m\n\033[38;2;234;88;12m5h:80%%(1h15m)\033[0m \033[0;37m|\033[0m \033[38;2;234;88;12m7d:75%%(2d3h)\033[0m\n\033[38;2;183;68;38m5h:95%%(0h30m)\033[0m \033[0;37m|\033[0m \033[38;2;183;68;38m7d:92%%(1d2h)\033[0m\n'
+```
+
+### PowerShell form
+
+```powershell
+$e=[char]27; Write-Host "$e[38;2;78;186;101m5h:20%(2h30m)$e[0m $e[0;37m|$e[0m $e[38;2;78;186;101m7d:25%(3d12h)$e[0m`n$e[38;2;222;142;62m5h:55%(2h30m)$e[0m $e[0;37m|$e[0m $e[38;2;222;142;62m7d:45%(3d12h)$e[0m`n$e[38;2;234;88;12m5h:80%(1h15m)$e[0m $e[0;37m|$e[0m $e[38;2;234;88;12m7d:75%(2d3h)$e[0m`n$e[38;2;183;68;38m5h:95%(0h30m)$e[0m $e[0;37m|$e[0m $e[38;2;183;68;38m7d:92%(1d2h)$e[0m"
+```
+
+## Other Rules
+
+- Do not add features beyond this spec.
+- Do not auto-commit any changes.
+- Do not add Co-Authored-By trailers.
+- Read git branch with `git -C "$cwd" rev-parse --abbrev-ref HEAD`, never from `PWD`.
+- When merging into existing `settings.json`, preserve all other keys; only set/replace `statusLine`.