@kurokeita/add-skill 2.0.0 → 2.1.0

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.1.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.