@kurokeita/add-skill 2.0.0 → 2.2.0

package/dist/skills/iso-response/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: iso-response
+description: Apply ISO 24495-1:2023 plain language principles to every response written for the user. Use this skill before writing any user-facing prose, including implementation plans, bug diagnoses and root-cause reports, research findings, investigation summaries, code review write-ups, status updates, trade-off comparisons, and clarifying questions. Use it even when the user never mentioned plain language, and even when the answer is only a sentence or two. It governs how a response is ordered, worded, and structured. It does not govern code, commit messages, or file contents.
+---
+
+# ISO Response
+
+## What this skill is for
+
+ISO 24495-1:2023 (*Plain language, Part 1: Governing principles and guidelines*) defines plain language as communication whose wording, structure, and design let the intended readers easily find what they need, understand what they find, and use it (clause 3.1).
+
+Your responses are documents under that standard's own definition (clause 3.3, which lists email and error message as examples). The user is the reader (clause 3.2). You are the author (clause 3.4). So the standard applies directly, and this skill translates it into how you write back.
+
+The point is not politeness or polish. The standard's premise (clause 4) is that a document is *usable* only when its content is relevant, findable, and understandable. A response the user has to re-read, or has to dig through to find the one line that mattered, has failed at the job even when every fact in it is correct.
+
+## Precedence
+
+Plain language wins over terse or stylized output modes for prose the user reads. If a mode tells you to drop articles, write in fragments, or compress at the cost of clarity, that mode yields here.
+
+This is not a license to pad. The standard itself demands concision: write concise sentences (5.3.4), write clear and concise paragraphs (5.3.5), and leave out content readers do not need (5.1.6 d). Plain language and brevity point the same direction almost always. Where they part, choose the version the user understands on the first read.
+
+Unaffected: source code, commit messages, PR bodies, config files, and anything whose format is fixed by a tool or convention. Those follow their own rules.
+
+## The four principles
+
+The standard sets out four interdependent governing principles (clause 4):
+
+1. **Relevant**: readers get what they need.
+2. **Findable**: readers can easily find what they need.
+3. **Understandable**: readers can easily understand what they find.
+4. **Usable**: readers can easily use the information.
+
+The first three are what you do while writing. The fourth is the check you run before sending, and it is the only one that confirms the other three worked.
+
+## Principle 1: Relevant (clause 5.1)
+
+This principle covers decisions made *before* drafting. Work out who is reading, why, and in what state, then choose what goes in.
+
+- **Identify the reader (5.1.2).** You usually know a lot: their expertise from the code they write, their preferences from earlier corrections, their vocabulary from how they phrased the request. Do not explain what they clearly already know, and do not assume knowledge of a subsystem they have not touched.
+- **Identify their purpose (5.1.3).** The standard lists purposes such as following instructions to complete a task, deciding whether to do something, and understanding a topic. These need different responses. Someone deciding needs the trade-off and a recommendation. Someone executing needs ordered steps. Someone diagnosing needs the cause and the evidence.
+- **Identify the context (5.1.4).** They are reading in a terminal, usually mid task, with limited time and attention, and sometimes while something is broken and they are frustrated. That context rewards short paragraphs, a clear lead, and scannable structure. It punishes walls of text.
+- **Select the response type (5.1.5).** Prose, a table, a numbered plan, a diff, or a single sentence. Pick what fits the purpose rather than defaulting to headed sections. A one-line question deserves a one-line answer.
+- **Select content the reader needs (5.1.6).** Answer the question actually asked. Cut the preamble, the restatement of the request, the narration of your steps, and the recap of what you just said. Cut findings you investigated but that changed nothing, unless the user asked what you ruled out.
+- **Select content ethically (5.1.6 f).** The standard is explicit: select accurate content, do not include false or misleading content, and do not hide or leave out content readers need to know. In practice: if tests failed, say so and show the output. If you skipped a step, say which. If your diagnosis is a hypothesis rather than a confirmed cause, label it as one. Never let confident phrasing stand in for verification.
+
+## Principle 2: Findable (clause 5.2)
+
+The reader should be able to tell within seconds what the response is about and whether it answers them.
+
+### Order (5.2.2)
+
+The standard gives five ordering rules. They map onto responses almost one to one.
+
+- **Most important message first, commonly at the beginning (a).** Lead with the answer, the result, or the root cause. Not with how you got there. Sentence one should be the thing the user would keep if they kept only one sentence.
+- **Build new information on what the reader already knows (b).** Anchor in their terms and their file names before introducing yours.
+- **Chronological order for instructions and processes (c).** Plans and repro steps run in execution order, numbered.
+- **What most readers need before what only some need (d).** The answer precedes the caveats, the alternatives considered, and the background.
+- **Warnings before instructions when failure can cause damage or harm (e).** This one is load bearing. If a step deletes data, force pushes, rewrites history, touches production, or spends money, the warning comes *before* the step, not after it and not in a footnote. Same for a confirmation you need: ask before acting, not while acting.
+
+### Design (5.2.3)
+
+The standard names four inclusive information design techniques. In a terminal that renders markdown, they become:
+
+- **Prominence**: bold the decision, the number, or the file path that carries the weight. One or two per response, or the emphasis stops meaning anything.
+- **Proximity**: keep each finding next to its evidence. Do not list five findings and then five explanations.
+- **Similarity**: give things with the same function the same shape. Every step in a plan looks like every other step. Every finding is formatted like every other finding.
+- **Structure made visual**: use a table when comparing options across the same dimensions, a numbered list for ordered steps, a bulleted list for unordered items, and a fenced code block for anything the user might copy or that must be quoted exactly.
+
+### Headings and supplementary information (5.2.4, 5.2.5)
+
+> Clause titles below are from the standard's contents. The sample used to build this skill stops partway through 5.2.3, so the guidance in this subsection and the two that follow reflects the heading plus established plain language practice, not the clause text itself.
+
+- Headings help readers predict what comes next, and the standard notes they earn their place in documents longer than a few paragraphs. Under that threshold, skip them. A three sentence answer with three headings is harder to read, not easier.
+- A heading has to name its content specifically. "Root cause" and "What I changed" work. "Details", "Notes", and "Information" do not.
+- Keep supplementary information separate from the main line. Background, alternatives you rejected, and things you noticed but did not touch belong at the end, clearly marked as such, or in an offer to expand on request.
+
+## Principle 3: Understandable (clause 5.3)
+
+- **Choose familiar words (5.3.2).** Use the reader's vocabulary and the codebase's own names. Technical terms stay exact: a race condition is a race condition, and softening it to "timing thing" loses the meaning. Jargon that is not load bearing goes. Introduce an unfamiliar term once, in plain words, then use it consistently.
+- **Write clear sentences (5.3.3).** Prefer active voice and name the actor. "The migration drops the column" beats "the column is dropped". Keep the subject close to its verb. Say what happened rather than what was done.
+- **Write concise sentences (5.3.4).** One idea per sentence. Cut hedges that carry no information ("it seems that", "arguably", "in order to"). Keep a caveat only when it changes what the user does next.
+- **Write clear and concise paragraphs (5.3.5).** One topic per paragraph, its point in the first sentence. Three or four sentences is usually the ceiling in a terminal.
+- **Consider images and multimedia (5.3.6).** The standard's definition of image (3.6) includes charts, diagrams, flowcharts, and tables. Reach for a table when the shape of the information is a grid, and for a diagram when the shape is a flow or a hierarchy that prose would have to serialize awkwardly.
+- **Project a respectful tone (5.3.7).** Address the reader directly. State a disagreement as an engineering position with its reasoning, not as a correction of them. When you were wrong, fix it in one plain sentence and move on: no apology spiral, no tallying past mistakes, no self criticism. When they were wrong, describe the mechanism, not the mistake.
+- **Ensure the response is cohesive (5.3.8).** Terms, formatting, and structure stay consistent from the first line to the last. Every part connects to the question that was asked. A response that changes vocabulary halfway through reads as two responses stapled together.
+
+## Principle 4: Usable (clause 5.4)
+
+Principles 1 to 3 make usability *likely*. Only evaluation confirms it. Evaluate continually while drafting (5.4.2), then check the finished response before sending:
+
+1. **Lead test.** Does sentence one carry the answer? If the answer is in paragraph three, move it.
+2. **Skim test.** Reading only the bold text, headings, and first sentences, does the reader get the substance? That is how a response in a terminal is actually read.
+3. **Act test.** Can they do the next thing without asking you a follow up question? If not, name what is missing or ask for it.
+4. **Cut test.** Which sentences would the reader not miss? Delete them. Preamble, narration, and recap go first.
+5. **Warning test.** Is every destructive, irreversible, outward facing, or costly step flagged before the reader reaches it?
+6. **Honesty test.** Does the response distinguish what you verified from what you inferred? Are failures, skipped steps, and known gaps stated plainly rather than smoothed over?
+
+Then keep evaluating in the conversation (5.4.3, 5.4.4). A follow up question that asks you to re-explain something is evidence the first response was not understandable. A request to "just tell me" is evidence it was not findable. Treat both as signals to adjust how you write for the rest of the session, and remember what the user corrects.
+
+## Applying it to common response types
+
+**Implementation plan.** Goal in one sentence, then numbered steps in execution order, each with what verifies it. Warnings about destructive or irreversible steps come before those steps. Open questions go last, so they do not block reading the plan. Ordering rules 5.2.2 a, c, and e all apply.
+
+**Bug investigation.** Root cause first, named at the level of the mechanism. Then the evidence, quoted from the actual error, log, or file. Then evidence against, if any. Then the proposed fix and what it does not fix. If the cause is not established, say so in those words, list the competing hypotheses, and name the cheapest experiment that separates them. Ordering rule 5.2.2 a plus ethical content selection 5.1.6 f.
+
+**Question to the user.** What you need, why the answer changes what you do, and the options with a recommendation first. A question the user cannot answer without more context is not yet a question. Clause 5.1.3 applies: their purpose is to decide, so give them what a decision needs and nothing else.
+
+**Research or comparison.** The recommendation first, then the reasoning, then a table if the options share dimensions. Say what you did not check. Clause 5.1.6 f forbids hiding gaps the reader needs to know about.
+
+**Status or completion report.** What is done and verified, stated plainly. What failed, with the output. What you left out and why. No hedging on finished work, and no claiming a step you skipped.
+
+## Source
+
+ISO 24495-1:2023, *Plain language, Part 1: Governing principles and guidelines*, ISO/TC 37. Clause numbers above refer to that standard. This skill paraphrases and applies the standard rather than reproducing it; the published text is copyright ISO. Clauses 5.2.4 through 5.4.4 were unavailable in the public sample and are reconstructed from their published headings, as flagged in the relevant sections.

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

@@ -1,20 +1,67 @@
 ---
 name: statusline-setup
-description: 'Set up the Claude Code or Gemini/Antigravity CLI 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 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).'
+description: 'Set up the Claude Code or Gemini/Antigravity CLI statusline as two side-by-side bordered boxes — a repo box (cwd, git branch, working-tree state, last commit) and a session box (model, context % + token totals, 5h/7d quota with ETA). Use when asked to "set up my statusline", "install statusline", "configure statusline", or to add a colored multi-line 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 or Gemini/Antigravity statusline that renders, left to right, pipe-separated:
+Install a Claude Code or Gemini/Antigravity statusline that renders two side-by-side bordered boxes:
 
-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).
+```text
+╭─ repo ──────────────────────────────────────────────────────╮ ╭─ session ─────────────╮
+│ ~/dev/ai_agents                                             │ │ Opus 5 (high)         │
+│ feat/statusline-boxed-layout                                │ │ ctx 42%  ↑1.2M ↓18.4k │
+│ +2 ~5 ?1 ↑3                                                 │ │ 5h 38%  resets 2h 14m │
+│ ffd30ce feat(skills): add iso-response plain language skill │ │ 7d 61%  resets 3d 4h  │
+╰─────────────────────────────────────────────────────────────╯ ╰───────────────────────╯
+```
+
+## Box Contents
+
+### repo box
+
+1. **cwd** — 24-bit ANSI `#5EFFFF` (`38;2;94;255;255`), shown at **full length**; only `$HOME` / `%USERPROFILE%` is replaced with `~`. No component abbreviation.
+2. **git branch** — 24-bit ANSI `#C24870` (`38;2;194;72;112`), bare name with no parentheses. Detached HEAD renders `detached@<short-sha>`.
+3. **working-tree state** — `+<staged> ~<modified> -<deleted> ?<untracked>` in bright green `#4eba65`, followed by `↑<ahead> ↓<behind>` in dim `#787e8a`. A clean tree renders a dim `clean`. Each counter is omitted when zero.
+4. **last commit** — `%h %s` in dim `#787e8a`, truncated to 80 characters with a trailing `…`.
+
+Rows 2-4 appear only inside a git repo.
+
+### session box
+
+1. **model display name + effort** in parens — 24-bit ANSI `#E89440` (`38;2;232;148;64`), effort only when present.
+2. **`ctx N%`** — 24-bit ANSI `#009AFB` (`38;2;0;154;251`) — followed on the same row, after two spaces, by **tokens** `↑<in> ↓<out>` in `#937bda` (`38;2;147;123;218`). When no token data exists the row is just `ctx N%`.
+3. **`5h N%  resets <eta>`** — colored by remaining quota (see below).
+4. **`7d N%  resets <eta>`** — colored independently of the 5h row.
+
+## Box Rendering Rules
+
+- Border glyphs `╭ ╮ ╰ ╯ ─ │` in `#5a5f69` (`38;2;90;95;105`); the box title in `#8c929e` (`38;2;140;146;158`).
+- Each box's inner width is the longest of its content rows, or its title + 2, whichever is larger.
+- Both boxes are padded to the **same row count** with blank rows, so the two frames start and end on the same terminal lines.
+- The two boxes are joined by a single space on every line.
+- Rows are emitted newline-separated; the statusline host renders them as multiple lines.
+- When both boxes have zero content rows the script prints nothing and exits 0.
+
+### Measuring width with ANSI escapes present
+
+Build **two parallel arrays** per box: one holding the plain text, one holding the same text wrapped in color escapes. Measure padding from the plain array only — measuring the colored string counts the escape bytes and destroys alignment.
+
+### UTF-8 locale guard (bash only)
 
-Segments are joined with ANSI `0;37` pipes (` | `).
+`${#str}` counts **bytes**, not characters, unless the shell is in a UTF-8 locale. The rows contain `↑`, `↓` and `…`, so under `LC_ALL=C` every such row is padded 2 characters short. Guard at the top of the script with a subprocess-free probe:
+
+```bash
+probe='↑'
+if (( ${#probe} != 1 )); then
+  for loc in C.UTF-8 en_US.UTF-8 en_US.utf8; do
+    export LC_ALL="$loc"
+    (( ${#probe} == 1 )) && break
+  done
+fi
+```
+
+Assigning `LC_ALL` makes bash call `setlocale` immediately, so `${#probe}` re-evaluates inside the loop; a locale the system lacks leaves the previous value and the loop moves on.
 
 ## When to Use This Skill
 
@@ -37,12 +84,20 @@ Detect the operating system and targeted platform first, then write and wire the
 - **Linux / macOS** → write `~/.gemini/antigravity-cli/statusline-command.sh` (pure bash + `jq`), wire into `~/.gemini/antigravity-cli/settings.json`.
 - **Windows** → write `%USERPROFILE%\.gemini\antigravity-cli\statusline-command.ps1`, wire into `%USERPROFILE%\.gemini\antigravity-cli\settings.json`.
 
+Multi-line rendering is verified on Claude Code. Antigravity's handling of multi-line statusline output is untested.
+
+## Shell Compatibility
+
+macOS ships bash 3.2, so the bash variant must avoid: `local -n` namerefs, `mapfile`/`readarray`, associative arrays, and negative array indices. Pass arrays into helpers as positional parameters instead.
+
+The PowerShell variant targets Windows PowerShell 5.1, so avoid PowerShell 7 syntax: null-coalescing `??`, ternary `? :`, and chain operators `&&`/`||`.
+
 ## 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`).
+- Missing/unparseable transcript → omit the tokens from the `ctx` row entirely, never render `↑0 ↓0`.
 
 ## Token Source
 
@@ -55,6 +110,17 @@ Tokens are calculated dynamically:
    - `input` = `context_window.total_input_tokens`
    - `output` = `context_window.total_output_tokens`
 
+## Git State
+
+Read **all** git state from a single `git -C "$cwd" status -b --porcelain` call, never from `PWD`. That one call yields branch name, upstream ahead/behind, and the staged/modified/untracked counts:
+
+- The `##` header line carries `branch...upstream [ahead N, behind M]`, or the literal `HEAD (no branch)` when detached — fall back to `git -C "$cwd" rev-parse --short HEAD` for that case.
+- `??` entries are untracked.
+- For every other entry, column 1 is the index and column 2 the working tree. A `D` in either column counts as deleted; any other non-space counts as staged (column 1) or modified (column 2). One file can count in several buckets.
+- Deletions get their own `-N` counter so a staged removal does not read as `+N`, which looks like an addition.
+
+The last-commit row needs one further call: `git -C "$cwd" log -1 --format='%h %s'`.
+
 ## Quota Colors (by REMAINING quota = 100 - used%)
 
 | Remaining | Color | 24-bit ANSI |
@@ -134,12 +200,25 @@ if ! command -v jq >/dev/null 2>&1; then
   exit 0
 fi
 
+# ${#str} counts bytes outside a UTF-8 locale, which mis-pads every row holding
+# an arrow or ellipsis. Assigning LC_ALL re-runs setlocale, so the probe below
+# re-evaluates; an unavailable locale leaves the previous value untouched.
+probe='↑'
+if (( ${#probe} != 1 )); then
+  for loc in C.UTF-8 en_US.UTF-8 en_US.utf8; do
+    export LC_ALL="$loc"
+    (( ${#probe} == 1 )) && break
+  done
+fi
+
 C_CWD=$'\033[38;2;94;255;255m'
 C_BRANCH=$'\033[38;2;194;72;112m'
-C_PIPE=$'\033[0;37m'
+C_BOX=$'\033[38;2;90;95;105m'
+C_TITLE=$'\033[38;2;140;146;158m'
 C_MODEL=$'\033[38;2;232;148;64m'
 C_CTX=$'\033[38;2;0;154;251m'
 C_TOK=$'\033[38;2;147;123;218m'
+C_DIM=$'\033[38;2;120;126;138m'
 RESET=$'\033[0m'
 
 GREEN=$'\033[38;2;78;186;101m'
@@ -159,8 +238,9 @@ quota_color() {
 
 fmt_eta() {
   local resets="$1"
-  [[ -z "$resets" || "$resets" == "null" || "$resets" == "" ]] && { printf ''; return; }
+  [[ -z "$resets" || "$resets" == "null" ]] && { printf ''; return; }
   local now delta days hours mins
+  # Claude Code sends an absolute epoch; Antigravity sends a duration.
   if (( resets < 10000000 )); then
     delta=$resets
   else
@@ -188,13 +268,26 @@ fmt_tokens() {
   fi
 }
 
+truncate_to() {
+  local s="$1" max="$2"
+  if (( ${#s} > max )); then printf '%s…' "${s:0:$(( max - 1 ))}"
+  else printf '%s' "$s"
+  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"
+  if [[ "$p" == "$HOME" ]]; then p='~'
+  elif [[ "$p" == "$HOME"/* ]]; then p="~${p#$HOME}"
   fi
+  printf '%s' "$p"
+}
+
+repeat_char() {
+  local ch="$1" n="$2" out=""
+  while (( n-- > 0 )); do out+="$ch"; done
+  printf '%s' "$out"
 }
 
 # --- read & parse stdin payload in a single jq call ---
@@ -210,67 +303,113 @@ read_fields() {
       .effort.level // "",
       (.context_window.used_percentage // "" | tostring),
       (
-        .rate_limits.five_hour.used_percentage // 
-        (if .quota."gemini-5h" != null then ((1.0 - .quota."gemini-5h".remaining_fraction) * 100) 
-         elif .quota."3p-5h" != null then ((1.0 - .quota."3p-5h".remaining_fraction) * 100) 
+        .rate_limits.five_hour.used_percentage //
+        (if .quota."gemini-5h" != null then ((1.0 - .quota."gemini-5h".remaining_fraction) * 100)
+         elif .quota."3p-5h" != null then ((1.0 - .quota."3p-5h".remaining_fraction) * 100)
          else "" end)
         | tostring
       ),
       (
-        .rate_limits.five_hour.resets_at // 
-        .quota."gemini-5h".reset_in_seconds // 
-        .quota."3p-5h".reset_in_seconds // 
+        .rate_limits.five_hour.resets_at //
+        .quota."gemini-5h".reset_in_seconds //
+        .quota."3p-5h".reset_in_seconds //
         ""
         | tostring
       ),
       (
-        .rate_limits.seven_day.used_percentage // 
-        (if .quota."gemini-weekly" != null then ((1.0 - .quota."gemini-weekly".remaining_fraction) * 100) 
-         elif .quota."3p-weekly" != null then ((1.0 - .quota."3p-weekly".remaining_fraction) * 100) 
+        .rate_limits.seven_day.used_percentage //
+        (if .quota."gemini-weekly" != null then ((1.0 - .quota."gemini-weekly".remaining_fraction) * 100)
+         elif .quota."3p-weekly" != null then ((1.0 - .quota."3p-weekly".remaining_fraction) * 100)
          else "" end)
         | tostring
       ),
       (
-        .rate_limits.seven_day.resets_at // 
-        .quota."gemini-weekly".reset_in_seconds // 
-        .quota."3p-weekly".reset_in_seconds // 
+        .rate_limits.seven_day.resets_at //
+        .quota."gemini-weekly".reset_in_seconds //
+        .quota."3p-weekly".reset_in_seconds //
         ""
         | tostring
       ),
       (.context_window.total_input_tokens // "" | tostring),
       (.context_window.total_output_tokens // "" | tostring)
-    ] | join("\u001f")
+    ] | join("")
   ' 2>/dev/null <<<"$payload"
 }
 
 IFS=$'\x1f' read -r cwd transcript model effort ctx five_used five_reset seven_used seven_reset payload_in payload_out < <(read_fields)
 
-segments=()
+repo_plain=(); repo_color=()
 
 if [[ -n "$cwd" ]]; then
-  segments+=("${C_CWD}$(shorten_home "$cwd")${RESET}")
+  p=$(shorten_home "$cwd")
+  repo_plain+=("$p"); repo_color+=("${C_CWD}${p}${RESET}")
 fi
 
-# Branch: must use git -C "$cwd", never PWD.
-branch=""
+# One `status -b --porcelain` call yields branch, dirty counts and ahead/behind.
+# Must use git -C "$cwd", never PWD.
+branch=""; staged=0; modified=0; deleted=0; untracked=0; ahead=0; behind=0
 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}")
+  while IFS= read -r line; do
+    if [[ "$line" == '## '* ]]; then
+      head=${line#'## '}
+      if [[ "$head" == 'HEAD (no branch)' ]]; then
+        branch=$(git -C "$cwd" rev-parse --short HEAD 2>/dev/null)
+        [[ -n "$branch" ]] && branch="detached@${branch}"
+      else
+        branch=${head%%...*}
+        if [[ "$head" == *'[ahead '* ]]; then t=${head#*'[ahead '}; ahead=${t%%[,\]]*}; fi
+        if [[ "$head" == *'behind '* ]]; then t=${head#*'behind '}; behind=${t%%[,\]]*}; fi
+      fi
+    elif [[ "$line" == '??'* ]]; then
+      (( ++untracked ))
+    else
+      case "${line:0:1}" in
+        ' ') ;;
+        'D') (( ++deleted )) ;;
+        *)   (( ++staged )) ;;
+      esac
+      case "${line:1:1}" in
+        ' ') ;;
+        'D') (( ++deleted )) ;;
+        *)   (( ++modified )) ;;
+      esac
+    fi
+  done < <(git -C "$cwd" status -b --porcelain 2>/dev/null)
 fi
 
-if [[ -n "$model" ]]; then
-  if [[ -n "$effort" ]]; then
-    segments+=("${C_MODEL}${model} (${effort})${RESET}")
+if [[ -n "$branch" ]]; then
+  repo_plain+=("$branch"); repo_color+=("${C_BRANCH}${branch}${RESET}")
+
+  if (( staged || modified || deleted || untracked )); then
+    dirty=""
+    (( staged ))    && dirty+="+${staged} "
+    (( modified ))  && dirty+="~${modified} "
+    (( deleted ))   && dirty+="-${deleted} "
+    (( untracked )) && dirty+="?${untracked} "
+    dirty=${dirty% }
+    dirty_c="${GREEN}${dirty}${RESET}"
   else
-    segments+=("${C_MODEL}${model}${RESET}")
+    dirty="clean"; dirty_c="${C_DIM}clean${RESET}"
+  fi
+  sync=""
+  (( ahead ))  && sync+=" ↑${ahead}"
+  (( behind )) && sync+=" ↓${behind}"
+  repo_plain+=("${dirty}${sync}")
+  repo_color+=("${dirty_c}${C_DIM}${sync}${RESET}")
+
+  last=$(git -C "$cwd" log -1 --format='%h %s' 2>/dev/null)
+  if [[ -n "$last" ]]; then
+    last=$(truncate_to "$last" 80)
+    repo_plain+=("$last"); repo_color+=("${C_DIM}${last}${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}")
+sess_plain=(); sess_color=()
+
+if [[ -n "$model" ]]; then
+  m="$model"
+  [[ -n "$effort" ]] && m="${model} (${effort})"
+  sess_plain+=("$m"); sess_color+=("${C_MODEL}${m}${RESET}")
 fi
 
 ti=0
@@ -288,7 +427,7 @@ if [[ -n "$transcript" ]]; then
 fi
 
 if [[ -n "$transcript" && -f "$transcript" ]]; then
-  tok=$(jq -Rn '
+  tok=$(jq -Rrn '
     reduce (inputs | fromjson?) as $m ({i:0,o:0};
       ($m.message.usage // null) as $u
       | if $u == null then .
@@ -312,34 +451,82 @@ if (( ti == 0 && to == 0 )); then
   fi
 fi
 
+tokens=""
 if (( ti > 0 || to > 0 )); then
-  segments+=("${C_TOK}↑$(fmt_tokens "$ti") ↓$(fmt_tokens "$to")${RESET}")
+  tokens="↑$(fmt_tokens "$ti") ↓$(fmt_tokens "$to")"
+fi
+
+if [[ -n "$ctx" ]]; then
+  ctx_int=$(awk -v n="$ctx" 'BEGIN{printf "%d", (n+0.5)}')
+  c="ctx ${ctx_int}%"
+  c_col="${C_CTX}${c}${RESET}"
+  if [[ -n "$tokens" ]]; then
+    c+="  ${tokens}"; c_col+="  ${C_TOK}${tokens}${RESET}"
+  fi
+  sess_plain+=("$c"); sess_color+=("$c_col")
+elif [[ -n "$tokens" ]]; then
+  sess_plain+=("$tokens"); sess_color+=("${C_TOK}${tokens}${RESET}")
 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}")
+  s="5h ${fu}%"; [[ -n "$eta" ]] && s+="  resets ${eta}"
+  sess_plain+=("$s"); sess_color+=("$(quota_color "$fu")${s}${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}")
+  s="7d ${su}%"; [[ -n "$eta" ]] && s+="  resets ${eta}"
+  sess_plain+=("$s"); sess_color+=("$(quota_color "$su")${s}${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
+rows=${#repo_plain[@]}
+(( ${#sess_plain[@]} > rows )) && rows=${#sess_plain[@]}
+if (( rows == 0 )); then printf ''; exit 0; fi
+for (( i = ${#repo_plain[@]}; i < rows; i++ )); do repo_plain+=(""); repo_color+=(""); done
+for (( i = ${#sess_plain[@]}; i < rows; i++ )); do sess_plain+=(""); sess_color+=(""); done
+
+# Width comes from the plain rows; the parallel colored rows carry ANSI escapes
+# that would otherwise be counted as visible characters. Arrays are passed
+# positionally because bash 3.2 (macOS) has no `local -n` nameref.
+box_width() {
+  local title="$1"; shift
+  local w=$(( ${#title} + 2 )) s
+  for s in "$@"; do (( ${#s} > w )) && w=${#s}; done
+  printf '%d' "$w"
+}
+rw=$(box_width "repo" "${repo_plain[@]}")
+sw=$(box_width "session" "${sess_plain[@]}")
+
+box_top() {
+  local title="$1" w="$2"
+  printf '%s╭─ %s%s%s %s╮%s' "$C_BOX" "$C_TITLE" "$title" "$C_BOX" \
+    "$(repeat_char '─' $(( w - ${#title} - 1 )))" "$RESET"
+}
+box_bottom() {
+  printf '%s╰%s╯%s' "$C_BOX" "$(repeat_char '─' $(( $1 + 2 )))" "$RESET"
+}
+box_row() {
+  local colored="$1" w="$2" plain="$3"
+  printf '%s│%s %s%s %s│%s' "$C_BOX" "$RESET" "$colored" \
+    "$(repeat_char ' ' $(( w - ${#plain} )))" "$C_BOX" "$RESET"
+}
+
+out="$(box_top repo "$rw") $(box_top session "$sw")"
+for (( i = 0; i < rows; i++ )); do
+  out+=$'\n'
+  out+="$(box_row "${repo_color[$i]}" "$rw" "${repo_plain[$i]}")"
+  out+=" $(box_row "${sess_color[$i]}" "$sw" "${sess_plain[$i]}")"
 done
+out+=$'\n'"$(box_bottom "$rw") $(box_bottom "$sw")"
+
 printf '%s' "$out"
 ```
 
 ## Windows Implementation
 
-Write `statusline-command.ps1` to the targeted platform directory. 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.
+Write `statusline-command.ps1` to the targeted platform directory. 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, and set UTF-8 output encoding so the box-drawing glyphs survive.
 
 `statusline-command.ps1`:
 
@@ -351,10 +538,12 @@ $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_BOX    = "$ESC[38;2;90;95;105m"
+$C_TITLE  = "$ESC[38;2;140;146;158m"
 $C_MODEL  = "$ESC[38;2;232;148;64m"
 $C_CTX    = "$ESC[38;2;0;154;251m"
 $C_TOK    = "$ESC[38;2;147;123;218m"
+$C_DIM    = "$ESC[38;2;120;126;138m"
 $RESET    = "$ESC[0m"
 
 $GREEN  = "$ESC[38;2;78;186;101m"
@@ -362,6 +551,10 @@ $AMBER  = "$ESC[38;2;222;142;62m"
 $ORANGE = "$ESC[38;2;234;88;12m"
 $REDORG = "$ESC[38;2;183;68;38m"
 
+$TL = [char]0x256D; $TR = [char]0x256E; $BL = [char]0x2570; $BR = [char]0x256F
+$HZ = [char]0x2500; $VT = [char]0x2502
+$UP = [char]0x2191; $DN = [char]0x2193; $ELLIPSIS = [char]0x2026
+
 function QuotaColor([double]$used) {
   $remaining = 100 - $used
   if ($remaining -gt 60) { return $GREEN }
@@ -373,6 +566,7 @@ function QuotaColor([double]$used) {
 function FmtEta($resetsAt) {
   if ($null -eq $resetsAt -or $resetsAt -eq "") { return "" }
   $val = [int64]$resetsAt
+  # Claude Code sends an absolute epoch; Antigravity sends a duration.
   if ($val -lt 10000000) {
     $delta = $val
   } else {
@@ -393,23 +587,19 @@ function FmtTokens([int64]$n) {
   return ("{0:N1}M" -f ($n / 1000000.0))
 }
 
+function TruncateTo($s, [int]$max) {
+  if ($s.Length -gt $max) { return $s.Substring(0, $max - 1) + $ELLIPSIS }
+  return $s
+}
+
 function ShortenHome($p) {
   if (-not $p) { return "" }
-  $home = $env:USERPROFILE
-  if ($p -eq $home) { return "~" }
-  if ($p.StartsWith("$home\")) { return "~" + $p.Substring($home.Length) }
+  $userHome = $env:USERPROFILE
+  if ($p -eq $userHome) { return "~" }
+  if ($p.StartsWith("$userHome\")) { return "~" + $p.Substring($userHome.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 }
   # Resolve path mismatch (if it has .gemini/antigravity/ but it actually is at .gemini/antigravity-cli/)
@@ -443,30 +633,84 @@ function SumTokens($path) {
 $raw = [Console]::In.ReadToEnd()
 try { $data = if ($raw.Trim()) { $raw | ConvertFrom-Json } else { @{} } } catch { $data = @{} }
 
-$segments = @()
+$repoPlain = @(); $repoColor = @()
+$sessPlain = @(); $sessColor = @()
 
 $cwd = $data.cwd
-if ($cwd) { $segments += "$C_CWD$(ShortenHome $cwd)$RESET" }
+if ($cwd) {
+  $p = ShortenHome $cwd
+  $repoPlain += $p; $repoColor += "$C_CWD$p$RESET"
+}
 
-$branch = GetBranch $cwd
-if ($branch) { $segments += "$C_BRANCH($branch)$RESET" }
+# One `status -b --porcelain` call yields branch, dirty counts and ahead/behind.
+# Must use git -C "$cwd", never PWD.
+$branch = ""; $staged = 0; $modified = 0; $deleted = 0; $untracked = 0; $ahead = 0; $behind = 0
+if ($cwd) {
+  $statusLines = & git -C "$cwd" status -b --porcelain 2>$null
+  if ($LASTEXITCODE -eq 0 -and $statusLines) {
+    foreach ($line in @($statusLines)) {
+      if ($line.StartsWith("## ")) {
+        $head = $line.Substring(3)
+        if ($head -eq "HEAD (no branch)") {
+          $sha = & git -C "$cwd" rev-parse --short HEAD 2>$null
+          if ($sha) { $branch = "detached@" + $sha.Trim() }
+        } else {
+          $branch = ($head -split '\.\.\.')[0]
+          if ($head -match '\[ahead (\d+)') { $ahead  = [int]$Matches[1] }
+          if ($head -match 'behind (\d+)')  { $behind = [int]$Matches[1] }
+        }
+      } elseif ($line.StartsWith("??")) {
+        $untracked++
+      } else {
+        $idx = $line.Substring(0, 1)
+        if ($idx -eq "D") { $deleted++ } elseif ($idx -ne " ") { $staged++ }
+        $wt = $line.Substring(1, 1)
+        if ($wt -eq "D") { $deleted++ } elseif ($wt -ne " ") { $modified++ }
+      }
+    }
+  }
+}
+
+if ($branch) {
+  $repoPlain += $branch; $repoColor += "$C_BRANCH$branch$RESET"
+
+  if ($staged -gt 0 -or $modified -gt 0 -or $deleted -gt 0 -or $untracked -gt 0) {
+    $parts = @()
+    if ($staged -gt 0)    { $parts += "+$staged" }
+    if ($modified -gt 0)  { $parts += "~$modified" }
+    if ($deleted -gt 0)   { $parts += "-$deleted" }
+    if ($untracked -gt 0) { $parts += "?$untracked" }
+    $dirty = [string]::Join(" ", $parts)
+    $dirtyColored = "$GREEN$dirty$RESET"
+  } else {
+    $dirty = "clean"; $dirtyColored = "$C_DIM" + "clean$RESET"
+  }
+  $sync = ""
+  if ($ahead -gt 0)  { $sync += " $UP$ahead" }
+  if ($behind -gt 0) { $sync += " $DN$behind" }
+  $repoPlain += "$dirty$sync"
+  $repoColor += "$dirtyColored$C_DIM$sync$RESET"
+
+  $last = & git -C "$cwd" log -1 --format='%h %s' 2>$null
+  if ($last) {
+    $last = TruncateTo $last.Trim() 80
+    $repoPlain += $last; $repoColor += "$C_DIM$last$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" }
+  if ($effort) { $m = "$model ($effort)" } else { $m = "$model" }
+  $sessPlain += $m; $sessColor += "$C_MODEL$m$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
+$tokenSums = SumTokens $data.transcript_path
 $ti = 0
 $to = 0
-if ($null -ne $tokens) {
-  $ti = $tokens[0]
-  $to = $tokens[1]
+if ($null -ne $tokenSums) {
+  $ti = $tokenSums[0]
+  $to = $tokenSums[1]
 }
 
 # Fallback to payload context_window tokens if transcript sum is 0
@@ -477,8 +721,22 @@ if ($ti -eq 0 -and $to -eq 0) {
   }
 }
 
+$tokens = ""
 if ($ti -gt 0 -or $to -gt 0) {
-  $segments += "$C_TOK↑$(FmtTokens $ti) ↓$(FmtTokens $to)$RESET"
+  $tokens = "$UP" + (FmtTokens $ti) + " $DN" + (FmtTokens $to)
+}
+
+$ctx = $data.context_window.used_percentage
+if ($null -ne $ctx) {
+  $c = "ctx " + [int][math]::Round([double]$ctx) + "%"
+  $cColored = "$C_CTX$c$RESET"
+  if ($tokens) {
+    $c += "  $tokens"
+    $cColored += "  $C_TOK$tokens$RESET"
+  }
+  $sessPlain += $c; $sessColor += $cColored
+} elseif ($tokens) {
+  $sessPlain += $tokens; $sessColor += "$C_TOK$tokens$RESET"
 }
 
 $five_used = $null
@@ -509,14 +767,53 @@ if ($null -ne $data.rate_limits.seven_day.used_percentage) {
 }
 
 if ($null -ne $five_used) {
-  $segments += "$(QuotaColor $five_used)5h:$([int][math]::Round($five_used))%($(FmtEta $five_reset))$RESET"
+  $s = "5h " + [int][math]::Round($five_used) + "%"
+  $eta = FmtEta $five_reset
+  if ($eta) { $s += "  resets $eta" }
+  $sessPlain += $s; $sessColor += "$(QuotaColor $five_used)$s$RESET"
 }
 if ($null -ne $seven_used) {
-  $segments += "$(QuotaColor $seven_used)7d:$([int][math]::Round($seven_used))%($(FmtEta $seven_reset))$RESET"
+  $s = "7d " + [int][math]::Round($seven_used) + "%"
+  $eta = FmtEta $seven_reset
+  if ($eta) { $s += "  resets $eta" }
+  $sessPlain += $s; $sessColor += "$(QuotaColor $seven_used)$s$RESET"
+}
+
+$rows = [math]::Max($repoPlain.Count, $sessPlain.Count)
+if ($rows -eq 0) { exit 0 }
+while ($repoPlain.Count -lt $rows) { $repoPlain += ""; $repoColor += "" }
+while ($sessPlain.Count -lt $rows) { $sessPlain += ""; $sessColor += "" }
+
+# Width comes from the plain rows; the parallel colored rows carry ANSI escapes
+# that would otherwise be counted as visible characters.
+function BoxWidth($title, $plainRows) {
+  $w = $title.Length + 2
+  foreach ($s in $plainRows) { if ($s.Length -gt $w) { $w = $s.Length } }
+  return $w
+}
+$rw = BoxWidth "repo" $repoPlain
+$sw = BoxWidth "session" $sessPlain
+
+function BoxTop($title, [int]$w) {
+  $dashes = [string]$HZ * ($w - $title.Length - 1)
+  return "$C_BOX$TL$HZ $C_TITLE$title$C_BOX $dashes$TR$RESET"
+}
+function BoxBottom([int]$w) {
+  return "$C_BOX$BL" + ([string]$HZ * ($w + 2)) + "$BR$RESET"
 }
+function BoxRow($colored, [int]$w, $plain) {
+  $pad = " " * ($w - $plain.Length)
+  return "$C_BOX$VT$RESET $colored$pad $C_BOX$VT$RESET"
+}
+
+$lines = @()
+$lines += (BoxTop "repo" $rw) + " " + (BoxTop "session" $sw)
+for ($i = 0; $i -lt $rows; $i++) {
+  $lines += (BoxRow $repoColor[$i] $rw $repoPlain[$i]) + " " + (BoxRow $sessColor[$i] $sw $sessPlain[$i])
+}
+$lines += (BoxBottom $rw) + " " + (BoxBottom $sw)
 
-$sep = " $C_PIPE|$RESET "
-[Console]::Out.Write([string]::Join($sep, $segments))
+[Console]::Out.Write([string]::Join("`n", $lines))
 ```
 
 ## Settings Wiring
@@ -554,12 +851,16 @@ Wire into `~/.gemini/antigravity-cli/settings.json` (or `%USERPROFILE%\.gemini\a
 
 ## Smoke Test
 
-After installing, generate a fake JSON payload with 5h at 80% used, 7d at 50% used, both with future `resets_at`/`reset_in_seconds`, plus a `transcript_path` pointing at a small fixture JSONL containing two assistant messages with `usage` blocks. Pipe it into the script and confirm:
+After installing, pipe a fake payload 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).
+- **Every rendered line has the same character count** — this is the alignment check, and it fails first when width is measured off a colored string or the locale is not UTF-8.
+- Both boxes show the same number of rows, framed top and bottom on the same lines.
+- Inside a repo the repo box shows 4 rows: full cwd, branch, working-tree state, last commit.
+- Staging a deletion (`git rm`) renders `-N`, not `+N`.
+- 5h renders **orange** at 80% used, 7d renders **amber** at 50% used.
+- The tokens sum matches the fixture and sits on the `ctx` row.
+- Omitting `transcript_path` leaves the `ctx` row as a bare `ctx N%` — no `↑0 ↓0`, no stray spacing.
+- Outside a repo the repo box collapses to the cwd row alone and the session box pads with blank rows.
 
 ### Linux/macOS smoke test
 
@@ -567,13 +868,31 @@ After installing, generate a fake JSON payload with 5h at 80% used, 7d at 50% us
 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}}}
+not json at all - must be skipped, not fatal
 {"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
+
+# Claude Code payload
+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}}}' "$PWD" "$FUTURE" "$FUTURE7" | bash ~/.claude/statusline-command.sh; echo
+
+# Antigravity payload - exercises the quota/reset_in_seconds and token fallbacks
+printf '{"cwd":"%s","model":{"display_name":"Gemini 3.5 Flash"},"context_window":{"used_percentage":6.7,"total_input_tokens":70419,"total_output_tokens":16667},"quota":{"gemini-5h":{"remaining_fraction":0.87,"reset_in_seconds":2515},"gemini-weekly":{"remaining_fraction":0.97,"reset_in_seconds":589315}}}' "$PWD" | bash ~/.claude/statusline-command.sh; echo
 ```
 
+Assert equal line widths mechanically:
+
+```bash
+printf '{"cwd":"%s","transcript_path":"/tmp/statusline-smoke/transcript.jsonl","model":{"display_name":"Opus 4.7"},"context_window":{"used_percentage":42}}' "$PWD" \
+  | bash ~/.claude/statusline-command.sh \
+  | perl -CSD -pe 's/\e\[[0-9;]*m//g' \
+  | perl -CSD -ne 'chomp; print length($_), "\n"' \
+  | sort -u
+```
+
+That must print exactly one number. Re-run the same pipeline wrapped in `env -i PATH="$PATH" HOME="$HOME" bash -c '...'` to confirm the locale guard holds with no `LANG` set.
+
 ### Windows smoke test (PowerShell)
 
 ```powershell
@@ -586,7 +905,7 @@ New-Item -ItemType Directory -Force -Path $tmp | Out-Null
 $future = [int64](Get-Date -UFormat %s) + 7200
 $future7 = [int64](Get-Date -UFormat %s) + 3*86400
 $payload = @{
-  cwd = $env:USERPROFILE
+  cwd = $PWD.Path
   transcript_path = "$tmp\transcript.jsonl"
   model = @{ display_name = "Opus 4.7" }
   effort = @{ level = "medium" }
@@ -596,23 +915,27 @@ $payload = @{
     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"
+$out = $payload | powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$env:USERPROFILE\.claude\statusline-command.ps1"
+$out
+($out -split "`n" | ForEach-Object { ($_ -replace "$([char]27)\[[0-9;]*m", "").Length } | Sort-Object -Unique)
 ```
 
+The last line must print exactly one number.
+
 ## 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.
+After install, output a one-liner the user can paste to preview all four quota tiers, one tier per line, in the row format the session box uses.
 
 ### 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'
+printf '\033[38;2;78;186;101m5h 20%%  resets 2h 30m\033[0m\n\033[38;2;222;142;62m5h 55%%  resets 2h 30m\033[0m\n\033[38;2;234;88;12m5h 80%%  resets 1h 15m\033[0m\n\033[38;2;183;68;38m5h 95%%  resets 30m\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"
+$e=[char]27; Write-Host "$e[38;2;78;186;101m5h 20%  resets 2h 30m$e[0m`n$e[38;2;222;142;62m5h 55%  resets 2h 30m$e[0m`n$e[38;2;234;88;12m5h 80%  resets 1h 15m$e[0m`n$e[38;2;183;68;38m5h 95%  resets 30m$e[0m"
 ```
 
 ## Other Rules
@@ -620,5 +943,6 @@ $e=[char]27; Write-Host "$e[38;2;78;186;101m5h:20%(2h30m)$e[0m $e[0;37m|$e[0m $e
 - 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`.
+- Read git state with `git -C "$cwd" status -b --porcelain`, never from `PWD`.
+- Never measure padding from a string containing ANSI escapes.
 - When merging into existing `settings.json`, preserve all other keys; only set/replace `statusLine`.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kurokeita/add-skill",
-	"version": "2.0.0",
+	"version": "2.2.0",
 	"description": "CLI to install AI agent skills to various platforms",
 	"type": "module",
 	"bin": {

package/dist/skills/serena-file-processing/SKILL.md

@@ -1,47 +0,0 @@
----
-name: serena-file-processing
-description: Master instructions for using Serena MCP tools for code navigation, search, navigation, and editing. Includes rules for terminal usage and memory management.
----
-
-# Serena File Processing Skill
-
-This skill defines the **authoritative rules** for using Serena tools (`view_file`, `replace_file_content`, `grep_search`, etc.) and interactions with other tools in Antigravity.
-
-## Core Rules
-
-### 1. Terminal Execution
-
-- ❌ NEVER use `mcp_serena_execute_shell_command`.
-- ✅ ALWAYS use `run_command` for terminal operations in Antigravity.
-
-## Workflow Best Practices
-
-### 2. Code Navigation
-
-- **Symbolic First**: Use `view_file_outline` to understand file structure before reading content.
-- **Search Smart**: Use `grep_search` to find usages. Constraint searches to relevant paths.
-- **Jumping**: Use `view_code_item` to inspect specific functions/classes without reading the whole file.
-
-### 3. Code Editing
-
-- **Pattern Matching**: When using `replace_file_content` or `multi_replace_file_content`, ensure `TargetContent` is unique.
-- **Context**: Use `view_file` around the target area first to ensure you have the exact string for replacement.
-
-### 4. Memory Management
-
-- **Limit Output**: When reading large files, read in chunks or use `view_child_nodes`.
-- **Close Context**: You don't need to explicitly "close" files, but don't re-read files unnecessarily.
-
-## Integration with Other Skills
-
-- **Layering**: Use this skill as the foundational layer for file operations.
-- **Specifics**: Higher-level skills (like `bliksund-pr-reviewer`) define *what* to look for; this skill defines *how* to look for it reliably.
-
-## Troubleshooting
-
-### 5. Connection Issues
-
-If you encounter errors connecting to the Serena MCP server or tools are unavailable:
-
-1. **Check Process Status**: Ask the user to verify if the Serena process has started.
-2. **Check Workspace Config**: Ask the user to confirm if the Serena configuration has been initiated for the current workspace.