@inbrace-tech/tokenline 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Inbrace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# tokenline
+
+> A cache-aware statusline for AI coding CLIs — your context, prompt-cache, and token economics at a glance.
+
+![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)
+![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20WSL2-blue)
+![Shell](https://img.shields.io/badge/shell-bash%204%2B-lightgrey)
+
+`tokenline` turns the one-line status bar of your AI coding CLI into a live cockpit:
+which model you're on, how much context you've burned, how long your prompt cache
+stays hot, how many tokens you're **saving** by reusing it, and how close you are to
+your 5h / 7d rate limits.
+
+It is **cross-CLI** (Claude Code, Antigravity) and **cross-provider** (Anthropic,
+Gemini) — detecting the active client and model provider at runtime and adjusting
+the cost equivalents accordingly.
+
+## Preview
+
+![Tokenline Preview](https://raw.githubusercontent.com/inbrace-tech/tokenline/main/assets/tokenline.png)
+
+- **Line 1** — model · context used (tokens + %) · cache TTL with a live HOT→COLD countdown.
+- **Line 2** — per-turn token economics: `read / write / new / output`, the equivalent
+  billed tokens (`eq`), and the **`saving %`** you get from prompt caching.
+- **Line 3** — 5h and 7d rate-limit bars with reset ETA and a **pace marker**
+  (`!!` = you're burning the window faster than it refills).
+
+> Lines 2 and 3 appear only when there's something to show (a turn happened, limits
+> exist), so the bar stays quiet when idle.
+
+## Why tokenline?
+
+Most statuslines show the model and the context bar. `tokenline` adds the two things
+that actually drive cost and flow on long agent sessions:
+
+- **Cache visibility.** Anthropic and Gemini bill cached input tokens at a fraction of
+  the price — but the cache expires. `tokenline` shows the TTL countdown (5m or 1h,
+  detected from the data) so you know whether your next turn lands warm or cold.
+- **Savings, quantified.** The `saving %` makes the value of prompt caching concrete
+  instead of invisible.
+- **Rate-limit pacing.** The `!!` marker warns you when you're on track to hit the 5h
+  or 7d ceiling before it resets.
+
+## Requirements
+
+v1 targets **Linux / WSL2**:
+
+- `bash` 4 or newer
+- [`jq`](https://jqlang.github.io/jq/)
+- GNU coreutils (`date -d`, `stat -c`)
+
+> macOS and Windows support are on the [roadmap](#roadmap). `install.sh` checks all of
+> the above and tells you exactly what's missing.
+
+## Install
+
+### With npm (recommended)
+
+If you have **Node 18+**, one command installs the script and wires it into your
+Claude Code settings:
+
+```bash
+npx @inbrace-tech/tokenline init
+```
+
+It copies `tokenline.sh` to `~/.claude/` and adds the `statusLine` block to
+`~/.claude/settings.json`. Use `--project` to configure the current project
+instead of your global settings, and `--dry-run` to preview without writing.
+Then restart Claude Code.
+
+> The statusline runs as `bash tokenline.sh` — Node is used only at install
+> time, never in the per-second hot path. `jq` is still required at runtime.
+
+### Without Node (clone + install.sh)
+
+No Node? Clone the repo and run the dependency checker, which prints a
+ready-to-paste snippet:
+
+```bash
+git clone https://github.com/inbrace-tech/tokenline.git
+cd tokenline
+./install.sh
+```
+
+Add the printed block to `~/.claude/settings.json` (global) or your project's
+`.claude/settings.json`, inside the top-level object:
+
+```json
+"statusLine": {
+  "type": "command",
+  "command": "bash /absolute/path/to/tokenline/tokenline.sh",
+  "refreshInterval": 1
+}
+```
+
+Then restart Claude Code.
+
+### What the installer does
+
+`npx @inbrace-tech/tokenline init` is deliberately transparent about touching
+your config:
+
+- **Writes** `tokenline.sh` to `~/.claude/` (or `./.claude/` with `--project`).
+- **Merges** only the `statusLine` key into `settings.json` — every other
+  setting is preserved.
+- **Backs up** `settings.json` to `settings.json.bak` before writing.
+- **Never clobbers** invalid JSON: if it can't parse your `settings.json`, it
+  stops and prints the block to paste manually.
+- Is **idempotent**, and won't replace a different existing `statusLine` unless
+  you pass `--force`.
+
+Other commands: `doctor` (check dependencies and config, change nothing) and
+`uninstall` (remove the block; `--purge` also deletes the script).
+
+### Antigravity CLI
+
+`tokenline` detects the Antigravity CLI from the transcript path and switches to its
+provider equivalents automatically. Point Antigravity's statusline command at the same
+`tokenline.sh` — no extra flags needed.
+
+## How it works
+
+On every refresh the host CLI pipes a JSON snapshot of the session to the script over
+stdin. `tokenline` parses it in a single `jq` pass (to keep the per-second refresh
+cheap), reads the last turn's timestamp from the transcript to drive the cache
+countdown, and renders up to three lines. Per-turn timestamps are cached in a
+per-user `0700` directory under `$XDG_RUNTIME_DIR` (tmpfs, cleared on logout).
+
+## Troubleshooting
+
+| Symptom | Cause / fix |
+| --- | --- |
+| Blank statusline, or `[tokenline] jq not found` | Install `jq` (`apt install jq` / `brew install jq`), then re-run `./install.sh`. |
+| Cache shows `COLD` immediately | Normal right after a long idle gap — the cache window has elapsed. It goes `HOT` again on your next turn. |
+| Colors look wrong / show escape codes | Your terminal must support 256-color ANSI. Most modern terminals do; check your `$TERM`. |
+| Nothing renders on macOS | Expected on v1 — macOS uses BSD `date`/`stat`. See the [roadmap](#roadmap). |
+
+## Roadmap
+
+- [ ] macOS support (BSD `date`/`stat`, bash 3.2 fallback)
+- [ ] Windows support (Git Bash / PowerShell)
+- [ ] Configurable colors and thresholds via `TOKENLINE_*` env vars
+
+(Issues for these are tracked in the repo — contributions welcome.)
+
+## Contributing
+
+Issues and PRs are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md). The CI runs
+[ShellCheck](https://www.shellcheck.net/) on every push, so please keep the script
+lint-clean.
+
+## About Inbrace
+
+`tokenline` is built and maintained by **Inbrace** — a software house based in
+Campinas, Brazil, building software with technical and human responsibility. We work
+where security is non-negotiable and architecture is treated as a strategic asset:
+intentional engineering, grounded decisions, and systems built to last.
+
+> Inbrace. The human side of software.
+
+Learn more at [inbrace.com.br](https://inbrace.com.br) ·
+[LinkedIn](https://www.linkedin.com/company/inbrace-tech/)
+
+## Credits
+
+Built by [@ropdias](https://github.com/ropdias) at [Inbrace](https://inbrace.com.br).
+
+## License
+
+[MIT](LICENSE) © 2026 Inbrace.

package/dist/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";var A=require("fs"),D=require("path");var N=require("os"),l=require("path"),J=(0,l.join)(__dirname,"..","tokenline.sh"),_=e=>e.project?(0,l.resolve)(".claude"):(0,l.join)((0,N.homedir)(),".claude"),$=e=>e.dir?(0,l.resolve)(e.dir,"tokenline.sh"):(0,l.join)(_(e),"tokenline.sh"),d=e=>(0,l.join)(_(e),"settings.json"),q=e=>e.includes(" ")?`bash "${e}"`:`bash ${e}`;var p=require("fs");function f(e){if(!(0,p.existsSync)(e))return{exists:!1,data:{}};let t=(0,p.readFileSync)(e,"utf8");if(t.trim()==="")return{exists:!0,data:{},raw:t};try{return{exists:!0,data:JSON.parse(t),raw:t}}catch{return{exists:!0,data:null,raw:t}}}function x(e){let t=`${e}.bak`;return(0,p.copyFileSync)(e,t),t}var S=e=>typeof e=="string"&&/tokenline\.sh/.test(e);var O=require("child_process"),I=require("os");var E=!!process.stdout.isTTY&&!process.env.NO_COLOR,h=(e,t)=>E?`\x1B[${e}m${t}\x1B[0m`:t,s=e=>h("1",e),W=e=>h("2",e),k=e=>h("32",e),G=e=>h("31",e),K=e=>h("33",e),m=e=>console.log(`${k("\u2713")} ${e}`),i=e=>console.log(`${K("!")} ${e}`),u=e=>console.error(`${G("\u2717")} ${e}`),r=e=>console.log(`${W("\u2192")} ${e}`);function w(){let e=(0,I.platform)();return e==="linux"?(m(`platform: ${e} (supported)`),!0):(i(`platform: ${e} \u2014 v1 targets Linux/WSL2; the bash statusline likely won't render yet (see roadmap). Use --force to install anyway.`),!1)}function v(){let e=(0,O.spawnSync)("jq",["--version"],{encoding:"utf8"});return e.status===0?(m(String(e.stdout).trim()),!0):(i("jq not found \u2014 required at runtime. Install it (apt install jq / brew install jq)."),!1)}function C(){let e=(0,O.spawnSync)("bash",["--version"],{encoding:"utf8"});if(e.status===0){let t=String(e.stdout).match(/version (\d+)\.(\d+)/);return t&&Number(t[1])>=4?(m(`bash ${t[1]}.${t[2]}`),!0):(i(`bash ${t?`${t[1]}.${t[2]}`:"?"} found \u2014 the script needs bash 4+.`),!1)}return i("bash not found \u2014 the statusline runs as a bash script."),!1}function P(){console.log(s(`
+tokenline \u2014 environment check
+`)),w(),C(),v();let e=[{label:"global",project:!1},{label:"project",project:!0}];for(let t of e){let o=d({project:t.project,dir:null}),n=f(o);n.exists&&n.data&&S(n.data.statusLine?.command)?m(`${t.label} settings: tokenline configured (${o})`):n.exists&&n.data===null?i(`${t.label} settings: invalid JSON (${o})`):r(`${t.label} settings: not configured (${o})`)}console.log()}var a=require("fs"),j=require("path");function U(e){if(console.log(s(`
+tokenline \u2014 installing the statusline
+`)),!w()&&!e.force){u("Unsupported platform. Re-run with --force to install anyway."),process.exitCode=1;return}C(),v();let o=$(e),n=d(e),b={type:"command",command:q(o),refreshInterval:1},c=f(n);if(c.exists&&c.data===null){u(`Could not parse ${n} (invalid JSON). Leaving it untouched.`),console.log(`
+Add this block manually, inside the top-level object:
+`),console.log(JSON.stringify({statusLine:b},null,2)+`
+`),process.exitCode=1;return}let y=c.data?c.data.statusLine:void 0,L=y!==void 0&&y.command===b.command,R=y!==void 0&&!L;if(R&&!e.force){u(`A different statusLine is already configured in ${n}:`),console.log(`    ${JSON.stringify(y)}`),i("Re-run with --force to replace it."),process.exitCode=1;return}if(e.dryRun){console.log(s(`
+[dry-run] would:`)),r(`write script  \u2192 ${o}`),r(`${c.exists?"patch":"create"} settings \u2192 ${n}`),c.exists&&r(`backup       \u2192 ${n}.bak`),console.log(`
+statusLine block:
+${JSON.stringify(b,null,2)}
+`);return}(0,a.mkdirSync)((0,j.dirname)(o),{recursive:!0}),(0,a.copyFileSync)(J,o),(0,a.chmodSync)(o,493),r(`wrote ${o}`);let T=c.data??{};c.exists?(x(n),r(`backed up ${n} \u2192 settings.json.bak`)):(0,a.mkdirSync)((0,j.dirname)(n),{recursive:!0}),T.statusLine=b,(0,a.writeFileSync)(n,JSON.stringify(T,null,2)+`
+`),r(`${L?"confirmed":R?"replaced":"added"} statusLine in ${n}`),console.log(`
+${k("Done.")} Restart Claude Code to see the statusline.
+`)}var g=require("fs");function B(e){console.log(s(`
+tokenline \u2014 uninstall
+`));let t=d(e),o=f(t);if(!o.exists||o.data===null?i(`No usable settings at ${t} \u2014 nothing to remove.`):S(o.data.statusLine?.command)?e.dryRun?r(`[dry-run] would remove statusLine from ${t}`):(x(t),delete o.data.statusLine,(0,g.writeFileSync)(t,JSON.stringify(o.data,null,2)+`
+`),r(`removed statusLine from ${t} (backup: settings.json.bak)`)):r(`No tokenline statusLine in ${t} \u2014 left untouched.`),e.purge){let n=$(e);(0,g.existsSync)(n)&&(e.dryRun?r(`[dry-run] would delete ${n}`):((0,g.unlinkSync)(n),r(`deleted ${n}`)))}console.log(`
+${k("Done.")} Restart Claude Code.
+`)}var Y=JSON.parse((0,A.readFileSync)((0,D.join)(__dirname,"..","package.json"),"utf8"));function z(e){let t={_:[],dir:null,project:!1,dryRun:!1,force:!1,purge:!1,help:!1,version:!1,unknown:null};for(let o=0;o<e.length;o++){let n=e[o];switch(n){case"--dir":t.dir=e[++o]??null;break;case"--project":case"--local":t.project=!0;break;case"--dry-run":t.dryRun=!0;break;case"--force":t.force=!0;break;case"--purge":t.purge=!0;break;case"-h":case"--help":t.help=!0;break;case"-v":case"--version":t.version=!0;break;default:n!==void 0&&n.startsWith("-")?t.unknown=n:n!==void 0&&t._.push(n)}}return t}function F(){console.log(`
+${s("tokenline")} \u2014 a cache-aware statusline for AI coding CLIs
+
+${s("Usage")}
+  npx @inbrace-tech/tokenline <command> [options]
+
+${s("Commands")}
+  init          Install tokenline.sh and wire it into your Claude Code settings
+  doctor        Check dependencies and current config \u2014 changes nothing
+  uninstall     Remove the tokenline statusLine block from settings
+
+${s("Options")}
+  --project     Target ./.claude (project) instead of ~/.claude (global)
+  --dir <path>  Write tokenline.sh to a custom directory
+  --dry-run     Show what would happen without writing anything
+  --force       Proceed on an unsupported platform / replace an existing statusLine
+  --purge       (uninstall) also delete the installed tokenline.sh
+  -h, --help    Show this help
+  -v, --version Show version
+
+${s("Notes")}
+  The statusline runs as 'bash tokenline.sh' \u2014 no Node in the per-second hot path.
+  jq is required at runtime; this installer checks for it but cannot install it.
+`)}function H(){let e=z(process.argv.slice(2));if(e.unknown&&i(`ignoring unknown option: ${e.unknown}`),e.version){console.log(Y.version);return}if(e.help||e._.length===0){F();return}try{switch(e._[0]){case"init":U(e);break;case"doctor":P();break;case"uninstall":case"remove":B(e);break;default:u(`Unknown command: ${e._[0]}`),F(),process.exitCode=1}}catch(t){u(t instanceof Error?t.message:String(t)),process.exitCode=1}}H();

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@inbrace-tech/tokenline",
+  "version": "1.0.0",
+  "description": "A cache-aware statusline for AI coding CLIs — installs tokenline.sh and wires it into your Claude Code settings.",
+  "bin": {
+    "tokenline": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "tokenline.sh"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "antigravity",
+    "statusline",
+    "tokens",
+    "prompt-cache",
+    "cli"
+  ],
+  "author": "Inbrace (https://inbrace.com.br)",
+  "contributors": [
+    "Rodrigo Pinheiro Dias (https://github.com/ropdias)"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/inbrace-tech/tokenline#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inbrace-tech/tokenline.git"
+  },
+  "bugs": {
+    "url": "https://github.com/inbrace-tech/tokenline/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "24.13.2",
+    "eslint": "10.5.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.6",
+    "eslint-plugin-simple-import-sort": "13.0.0",
+    "globals": "17.6.0",
+    "prettier": "3.8.4",
+    "tsup": "^8.5.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.61.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint . --cache --cache-location node_modules/.cache/.eslintcache --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\""
+  }
+}

package/tokenline.sh

@@ -0,0 +1,449 @@
+#!/usr/bin/env bash
+
+# ==============================================================================
+# tokenline — a cache-aware statusline for AI coding CLIs
+#
+# Cross-CLI (Claude Code, Antigravity) and cross-provider (Anthropic, Gemini).
+# Renders: model · context · cache TTL (HOT/COLD) · per-turn token economics
+# (read / write / new / output / eq / saving %) · 5h + 7d rate-limit pacing.
+#
+# Repo:     https://github.com/inbrace-tech/tokenline
+# License:  MIT
+# Requires: bash 4+, jq, GNU coreutils (date -d, stat -c). Linux/WSL2 for v1.
+# ==============================================================================
+
+# --- Colors & Formatting Constants ---
+COLOR_GRAY=$'\033[38;5;244m'
+COLOR_DARK_GRAY=$'\033[38;5;240m'
+COLOR_CYAN=$'\033[38;5;51m'
+COLOR_YELLOW=$'\033[38;5;226m'
+COLOR_MAGENTA=$'\033[38;5;201m'
+COLOR_ORANGE=$'\033[38;5;208m'
+COLOR_RED=$'\033[38;5;196m'
+COLOR_GREEN=$'\033[38;5;46m'
+COLOR_RESET=$'\033[00m'
+STYLE_BLINK=$'\033[1;5m'
+
+# --- Dependency guard ---
+# A statusline must never crash the host CLI's prompt. Without jq we cannot
+# parse the input JSON, so emit a minimal, explicit hint instead of a blank
+# line, and exit 0 (never signal an error code to the host).
+if ! command -v jq >/dev/null 2>&1; then
+  printf '%s[tokenline] jq not found — install jq to enable the statusline%s\n' \
+    "$COLOR_GRAY" "$COLOR_RESET"
+  exit 0
+fi
+
+# --- Runtime state directory ---
+# Per-turn timestamp / TTL are cached between the 1s refreshes. Prefer a
+# per-user dir (0700) under XDG_RUNTIME_DIR: it avoids predictable, world-
+# readable paths in shared /tmp (and the symlink/collision risks they carry),
+# and is tmpfs cleared on logout — so no orphan-file cleanup is needed. Falls
+# back to /tmp when XDG_RUNTIME_DIR is unset.
+_runtime_dir="${XDG_RUNTIME_DIR:-/tmp}/tokenline-${UID:-$(id -u)}"
+mkdir -p "$_runtime_dir" 2>/dev/null && chmod 700 "$_runtime_dir" 2>/dev/null
+[ -d "$_runtime_dir" ] || _runtime_dir="/tmp"
+
+# --- 1. Parse JSON Standard Input and Prepare State Variables ---
+parse_and_prepare_paths() {
+  # Read full stdin JSON representing active session state from the CLI client
+  local input
+  input=$(cat)
+
+  # Single jq execution to parse all required fields into an array at once (reduces forks)
+  mapfile -t _f < <(printf '%s' "$input" | jq -r '
+    (.model.display_name // ""),
+    (.context_window.used_percentage // ""),
+    (.context_window.context_window_size // ""),
+    (.transcript_path // ""),
+    (.session_id // ""),
+    (.rate_limits.five_hour.used_percentage // ""),
+    (.rate_limits.five_hour.resets_at // ""),
+    (.rate_limits.seven_day.used_percentage // ""),
+    (.rate_limits.seven_day.resets_at // ""),
+    (.context_window.current_usage.input_tokens // 0),
+    (.context_window.current_usage.output_tokens // 0),
+    (.context_window.current_usage.cache_creation_input_tokens // 0),
+    (.context_window.current_usage.cache_read_input_tokens // 0)' 2>/dev/null)
+
+  # Malformed or empty stdin: jq emits nothing, so the array is empty. Degrade to
+  # a silent no-op render rather than leaking parse errors or rendering garbage —
+  # the host CLI always sends valid JSON, so this path only guards against abuse.
+  [ "${#_f[@]}" -eq 0 ] && exit 0
+
+  model="${_f[0]}"
+  used_pct="${_f[1]}"
+  tokens_limit="${_f[2]}"
+  transcript_path="${_f[3]}"
+  session_id="${_f[4]}"
+  rl_5h_pct="${_f[5]}"
+  rl_5h_reset="${_f[6]}"
+  rl_7d_pct="${_f[7]}"
+  rl_7d_reset="${_f[8]}"
+  cur_input="${_f[9]}"
+  cur_output="${_f[10]}"
+  cur_cwrite="${_f[11]}"
+  cur_cread="${_f[12]}"
+
+  # Computed: total input-only tokens used in the current context window
+  tokens_used=$((cur_input + cur_cwrite + cur_cread))
+
+  # If Claude Code sends a subagent transcript, resolve it to the parent session instead
+  if [[ "$transcript_path" == */subagents/* ]]; then
+    transcript_path="$(dirname "$(dirname "$transcript_path")").jsonl"
+  fi
+
+  # Detect active CLI Client
+  cli_client="claude-code"
+  if [[ "$transcript_path" == *"/antigravity"* ]] || [[ "$transcript_path" == *"/antigravity-cli"* ]]; then
+    cli_client="antigravity"
+  fi
+
+  # Dynamic Path Correction: Translate /antigravity/ to /antigravity-cli/ if client is Antigravity CLI
+  if [ "$cli_client" = "antigravity" ] && [[ "$transcript_path" == *"/antigravity/"* ]]; then
+    transcript_path="${transcript_path/\/antigravity\//\/antigravity-cli\/}"
+  fi
+
+  # Detect if Gemini model is active
+  is_gemini=false
+  if [[ "$model" =~ [Gg]emini ]]; then
+    is_gemini=true
+  fi
+
+  # Get the current epoch timestamp once to be reused across all calculations
+  now=$(date +%s)
+}
+
+# --- 2. Formatting Helpers ---
+fmt_k() {
+  # Formats token counts nicely (e.g. 1500000 -> 1.5M, 25600 -> 25.6k).
+  # Value is passed via -v (defaulted to 0) so a missing or non-numeric arg
+  # can never break awk's program syntax.
+  awk -v v="${1:-0}" 'BEGIN {
+    if (v >= 1000000) printf "%.1fM", v/1000000
+    else if (v >= 1000) printf "%.1fk", v/1000
+    else printf "%d", v }'
+}
+
+fmt_eta() {
+  # Formats raw seconds remaining into a human readable string (e.g., 3600 -> 1h, 90 -> 1m30s)
+  local secs=$1
+  if [ "$secs" -le 0 ]; then
+    printf 'now'
+  elif [ "$secs" -lt 3600 ]; then
+    printf '%dm' $((secs / 60))
+  elif [ "$secs" -lt 86400 ]; then
+    local h=$((secs / 3600)) m=$(((secs % 3600) / 60))
+    if [ "$m" -gt 0 ]; then printf '%dh%dm' "$h" "$m"; else printf '%dh' "$h"; fi
+  else
+    local d=$((secs / 86400)) h=$(((secs % 86400) / 3600))
+    if [ "$h" -gt 0 ]; then printf '%dd%dh' "$d" "$h"; else printf '%dd' "$d"; fi
+  fi
+}
+
+# --- 3. Cache Timer Logic ---
+compute_cache_timer() {
+  cache_info=""
+  local ts_cache_file="$_runtime_dir/lastts-${session_id:-default}"
+  local ttl_cache_file="$_runtime_dir/ttl-${session_id:-default}"
+  local tokens_cache_file="$_runtime_dir/lasttokens-${session_id:-default}"
+
+  # Update the cached turn timestamp if token usage changed (signaling a new turn)
+  local last_tokens
+  last_tokens=$(cat "$tokens_cache_file" 2>/dev/null)
+  if [ "$tokens_used" -ne "${last_tokens:-0}" ] 2>/dev/null; then
+    printf '%s\n' "$now" > "$ts_cache_file" 2>/dev/null
+    printf '%s\n' "$tokens_used" > "$tokens_cache_file" 2>/dev/null
+  fi
+
+  local last_ts=""
+  local e5m=0
+  local e1h=0
+
+  # Read the last turn's timestamp directly from the transcript file (if readable)
+  if [ -n "$transcript_path" ] && [ -f "$transcript_path" ] && [ -r "$transcript_path" ]; then
+    # General Query: Matches .type=="assistant" (Claude Code) or .type=="PLANNER_RESPONSE" (Antigravity CLI)
+    # Extracts the dynamic timestamp using (.timestamp // .created_at) and caching flags
+    IFS=$'\t' read -r iso e5m e1h < <(
+      tail -n 200 "$transcript_path" 2>/dev/null \
+      | jq -r 'select(.type=="assistant" or .type=="PLANNER_RESPONSE")
+               | [
+                   (.timestamp // .created_at),
+                   (.message.usage.cache_creation.ephemeral_5m_input_tokens // 0),
+                   (.message.usage.cache_creation.ephemeral_1h_input_tokens // 0)
+                 ]
+               | @tsv' 2>/dev/null \
+      | tail -n 1
+    )
+    if [ -n "$iso" ]; then
+      last_ts=$(date -d "$iso" +%s 2>/dev/null)
+    fi
+    # Mtime fallback if parsing is unsuccessful
+    [ -z "$last_ts" ] && last_ts=$(stat -c %Y "$transcript_path" 2>/dev/null)
+  fi
+
+  # Fallback to local session caching file if transcript read is unavailable or cached timestamp is newer
+  local cached_ts
+  cached_ts=$(cat "$ts_cache_file" 2>/dev/null)
+  if [ -n "$cached_ts" ]; then
+    if [ -z "$last_ts" ] || [ "$cached_ts" -gt "$last_ts" ] 2>/dev/null; then
+      last_ts="$cached_ts"
+    fi
+  fi
+
+  # Ensure there is always a valid timestamp to fall back to
+  if [ -z "$last_ts" ]; then
+    last_ts="$now"
+    printf '%s\n' "$last_ts" > "$ts_cache_file" 2>/dev/null
+  fi
+
+  # Determine cache TTL window (Gemini has 5m default; Anthropic determines it via tokens fields)
+  local ttl
+  if [ "$is_gemini" = true ]; then
+    ttl=300
+    ttl_label="5m"
+  else
+    if [ "${e1h:-0}" -gt 0 ]; then
+      ttl=3600
+      ttl_label="1h"
+    elif [ "${e5m:-0}" -gt 0 ]; then
+      ttl=300
+      ttl_label="5m"
+    else
+      # Retrieve previously determined session TTL if latest turn did not populate these fields (e.g. hit only)
+      ttl=$(awk '{print $1}' "$ttl_cache_file" 2>/dev/null)
+      ttl_label=$(awk '{print $2}' "$ttl_cache_file" 2>/dev/null)
+      [ -z "$ttl" ] && { ttl=300; ttl_label="5m"; }
+    fi
+  fi
+  printf '%s %s\n' "$ttl" "$ttl_label" > "$ttl_cache_file" 2>/dev/null
+
+  # Calculate remaining time and format the cache information display
+  local elapsed
+  local remaining
+  elapsed=$((now - last_ts))
+  remaining=$((ttl - elapsed))
+  if [ "$remaining" -gt 0 ]; then
+    local mins=$((remaining / 60))
+    local secs=$((remaining % 60))
+    local pct10=$((remaining * 10 / ttl))
+    local fg=""
+    
+    # Custom HSL-based gradient colors for remaining time
+    if   [ "$pct10" -ge 8 ]; then fg="$COLOR_GREEN"
+    elif [ "$pct10" -ge 6 ]; then fg=$'\033[38;5;154m'
+    elif [ "$pct10" -ge 4 ]; then fg="$COLOR_YELLOW"
+    elif [ "$pct10" -ge 2 ]; then fg="$COLOR_ORANGE"
+    elif [ "$pct10" -ge 1 ]; then fg="$COLOR_RED"
+    else                          fg="${COLOR_RED}${STYLE_BLINK}" # Blinking red if < 10%
+    fi
+
+    local suffix="HOT"
+    [ "$pct10" -lt 1 ] && suffix="HOT !"
+    cache_info=$(printf '%s[%s] cache: %s%d:%02d %s%s' "$COLOR_GRAY" "$ttl_label" "$fg" "$mins" "$secs" "$suffix" "$COLOR_RESET")
+  else
+    cache_info=$(printf '%s[%s] cache: \033[1;5m%sCOLD%s' "$COLOR_GRAY" "$ttl_label" "$COLOR_RED" "$COLOR_RESET")
+  fi
+}
+
+# --- 4. Context Window Computation ---
+compute_context_info() {
+  ctx_info=""
+  if [ -n "$used_pct" ]; then
+    local pct
+    local ctx_color
+    pct=$(printf '%.0f' "$used_pct")
+    if   [ "$pct" -ge 80 ]; then ctx_color=$'\033[01;31m' # Bold Red
+    elif [ "$pct" -ge 50 ]; then ctx_color=$'\033[01;33m' # Bold Yellow
+    else                         ctx_color=$'\033[01;32m' # Bold Green
+    fi
+
+    if [ "${tokens_used:-0}" -gt 0 ] && [ "${tokens_limit:-0}" -gt 0 ]; then
+      ctx_info=$(printf '%sctx: %s%s%s/%s (%s%%)%s' \
+        "$COLOR_GRAY" "$COLOR_RESET" "$ctx_color" "$(fmt_k "$tokens_used")" "$(fmt_k "$tokens_limit")" "$pct" "$COLOR_RESET")
+    else
+      ctx_info=$(printf '%sctx: %s%s%s%%%s' "$COLOR_GRAY" "$COLOR_RESET" "$ctx_color" "$pct" "$COLOR_RESET")
+    fi
+  fi
+}
+
+# --- 5. Rate Limit Windows Heuristics and Bars ---
+rl_color_for_pct() {
+  local pct=$1
+  if   [ "$pct" -ge 90 ]; then echo "${COLOR_RED}${STYLE_BLINK}" # Blinking red
+  elif [ "$pct" -ge 75 ]; then echo "$COLOR_RED"
+  elif [ "$pct" -ge 50 ]; then echo "$COLOR_ORANGE"
+  elif [ "$pct" -ge 25 ]; then echo "$COLOR_YELLOW"
+  else                         echo "$COLOR_GREEN"
+  fi
+}
+
+rl_bar() {
+  local pct=$1
+  local color=$2
+  local width=10
+  local filled=$((pct * width / 100))
+  [ "$filled" -lt 0 ] && filled=0
+  [ "$filled" -gt "$width" ] && filled=$width
+  
+  local empty=$((width - filled))
+  local bar="$color"
+  local i
+  for ((i=0; i<filled; i++)); do bar+="█"; done
+  bar+="$COLOR_DARK_GRAY"
+  for ((i=0; i<empty; i++)); do bar+="░"; done
+  bar+="$COLOR_RESET"
+  printf '%s' "$bar"
+}
+
+rl_segment() {
+  local label=$1
+  local pct=$2
+  local reset_at=$3
+  local window_secs=$4
+  local now_ts=$5
+  [ -z "$pct" ] && return
+  local pct_int; pct_int=$(printf '%.0f' "$pct")
+
+  local eta_secs=0
+  if [ -n "$reset_at" ] && [ "$reset_at" != "null" ]; then
+    eta_secs=$((reset_at - now_ts))
+    [ "$eta_secs" -lt 0 ] && eta_secs=0
+  fi
+
+  # Pace heuristic: check if we are burning the API limits faster than scheduling
+  local pace_marker=""
+  if [ "$pct_int" -ge 20 ] && [ "$eta_secs" -gt 0 ] && [ "$window_secs" -gt 0 ]; then
+    local elapsed_secs=$((window_secs - eta_secs))
+    [ "$elapsed_secs" -lt 0 ] && elapsed_secs=0
+    local min_elapsed=$((window_secs / 10))
+    if [ "$elapsed_secs" -ge "$min_elapsed" ]; then
+      local fast
+      fast=$(awk "BEGIN{
+        pace = ($pct_int * $window_secs) / ($elapsed_secs * 100)
+        if (pace >= 1.5) print 2
+        else if (pace >= 1.25) print 1
+        else print 0
+      }")
+      if   [ "$fast" = "2" ]; then pace_marker=$(printf '%s!!%s' "${COLOR_RED}${STYLE_BLINK}" "$COLOR_RESET")
+      elif [ "$fast" = "1" ]; then pace_marker=$(printf '%s!%s' "$COLOR_ORANGE" "$COLOR_RESET")
+      fi
+    fi
+  fi
+
+  local color; color=$(rl_color_for_pct "$pct_int")
+  local bar; bar=$(rl_bar "$pct_int" "$color")
+  local reset_str=""
+  [ "$eta_secs" -gt 0 ] && reset_str=$(printf ' (%s to reset)' "$(fmt_eta "$eta_secs")")
+
+  printf '%s%s: %s%s %s%d%%%s%s%s' \
+    "$COLOR_GRAY" "$label" "$COLOR_RESET" \
+    "$bar" \
+    "$color" "$pct_int" "$COLOR_RESET" \
+    "$reset_str" \
+    "${pace_marker:+ $pace_marker}"
+}
+
+compute_rate_limits() {
+  rl_5h_info=""
+  rl_7d_info=""
+  # Gemini models do not have five_hour / seven_day rate limits; only compute for non-Gemini (Anthropic)
+  if [ "$is_gemini" = false ]; then
+    [ -n "$rl_5h_pct" ] && rl_5h_info=$(rl_segment "5h" "$rl_5h_pct" "$rl_5h_reset" 18000  "$now")
+    [ -n "$rl_7d_pct" ] && rl_7d_info=$(rl_segment "7d" "$rl_7d_pct" "$rl_7d_reset" 604800 "$now")
+  fi
+}
+
+# --- 6. Last-Turn Token Economics Breakdown & Equivalents ---
+compute_turn_breakdown() {
+  last_info=""
+  if [ "$cur_cread" -gt 0 ] || [ "$cur_cwrite" -gt 0 ] || [ "$cur_input" -gt 0 ] || [ "$cur_output" -gt 0 ]; then
+    local read_mult
+    local write_mult
+    local input_mult
+    local output_mult
+    
+    # Multipliers based on active provider (Gemini equivalents vs Anthropic Claude)
+    if [ "$is_gemini" = true ]; then
+      read_mult="0.25"
+      write_mult="1.0"
+      input_mult="1"
+      output_mult="4"
+    else
+      read_mult="0.1"
+      write_mult="1.25"
+      [ "${ttl_label:-5m}" = "1h" ] && write_mult="2"
+      input_mult="1"
+      output_mult="5"
+    fi
+
+    # Equivalent tokens formula
+    local eq_tokens
+    local uncached_eq
+    eq_tokens=$(awk "BEGIN { printf \"%d\", ($cur_cread * $read_mult) + ($cur_cwrite * $write_mult) + ($cur_input * $input_mult) + ($cur_output * $output_mult) }")
+    uncached_eq=$(awk "BEGIN { printf \"%d\", ($cur_cread + $cur_cwrite + $cur_input) * $input_mult + ($cur_output * $output_mult) }")
+    
+    local saving_pct=0
+    [ "$uncached_eq" -gt 0 ] && saving_pct=$(awk "BEGIN { printf \"%d\", 100 * ($uncached_eq - $eq_tokens) / $uncached_eq }")
+    
+    local read_lbl="${read_mult}x"
+    local write_lbl="${write_mult}x"
+    local input_lbl="${input_mult}x"
+    local output_lbl="${output_mult}x"
+
+    local save_color
+    if   [ "$saving_pct" -ge 90 ]; then save_color="$COLOR_GREEN"
+    elif [ "$saving_pct" -ge 70 ]; then save_color="$COLOR_YELLOW"
+    elif [ "$saving_pct" -ge 50 ]; then save_color="$COLOR_ORANGE"
+    else                                save_color="$COLOR_RED"
+    fi
+
+    # Format the complete per-turn breakdown line
+    last_info=$(printf '%sread(%s): %s%s%s %swrite(%s): %s%s%s %snew(%s): %s%s%s %soutput(%s): %s%s%s %seq: %s%s%s %ssaving: %s%d%%%s' \
+      "$COLOR_GRAY" "$read_lbl" "$COLOR_CYAN" "$(fmt_k "$cur_cread")" "$COLOR_RESET" \
+      "$COLOR_GRAY" "$write_lbl" "$COLOR_YELLOW" "$(fmt_k "$cur_cwrite")" "$COLOR_RESET" \
+      "$COLOR_GRAY" "$input_lbl" "$COLOR_MAGENTA" "$(fmt_k "$cur_input")" "$COLOR_RESET" \
+      "$COLOR_GRAY" "$output_lbl" "$COLOR_GREEN" "$(fmt_k "$cur_output")" "$COLOR_RESET" \
+      "$COLOR_GRAY" "$COLOR_ORANGE" "$(fmt_k "$eq_tokens")" "$COLOR_RESET" \
+      "$COLOR_GRAY" "$save_color" "$saving_pct" "$COLOR_RESET")
+  fi
+}
+
+# --- 7. Compose and Render Output ---
+render_statusline() {
+  # Line 1: client/model | ctx | cache TTL
+  local display_header=""
+  if [ "$cli_client" = "antigravity" ]; then
+    # Custom styled brand display for Antigravity CLI users
+    display_header="${COLOR_CYAN}🌌 Antigravity${COLOR_RESET} (${model})"
+  else
+    # Default display for Claude Code
+    display_header="${model}"
+  fi
+
+  local line1="$display_header"
+  [ -n "$ctx_info" ]   && line1="$line1 | $ctx_info"
+  [ -n "$cache_info" ] && line1="$line1 | $cache_info"
+  printf "%s\n" "$line1"
+
+  # Line 2: breakdown of cache / raw / saving (only shown when activity happens)
+  [ -n "$last_info" ] && printf "%s\n" "$last_info"
+
+  # Line 3: API rate limits and progress bars (Only shown for Claude models where limits exist)
+  if [ "$is_gemini" = false ] && { [ -n "$rl_5h_info" ] || [ -n "$rl_7d_info" ]; }; then
+    local sep_line="${COLOR_DARK_GRAY}──────────────────────────────${COLOR_RESET}"
+    printf "%s\n" "$sep_line"
+    local line_rl=""
+    [ -n "$rl_5h_info" ] && line_rl="$rl_5h_info"
+    [ -n "$rl_7d_info" ] && line_rl="${line_rl:+$line_rl  }$rl_7d_info"
+    printf "%s\n" "$line_rl"
+  fi
+}
+
+# --- Orchestrated Execution Flow ---
+parse_and_prepare_paths
+compute_cache_timer
+compute_context_info
+compute_rate_limits
+compute_turn_breakdown
+render_statusline