Customize GitHub Copilot CLI Status Line

Over the past few months, I have switched most of my development workflows to GitHub Copilot CLI. Whether I’m exploring a codebase, writing code, debugging, or even building a new application, I find myself in GitHub Copilot CLI most of the time. It’s fast, it keeps me in the flow, and the agentic capabilities make it incredibly productive.

Many users have asked me how to track context usage in the CLI ?

First of all, you can always use the /context and /usage commands to get a snapshot of your current context window usage.

Nevertheless, you can also have a live status line that shows your token consumption and context usage percentage in real time, without needing to type any command, you just need to use the experimental statusLine.command feature to run a custom script to generate the status line content.

This post walks you through setting it up from scratch. I also document the full JSON payload that Copilot sends to your script — I captured it directly from a live session to build the reference table below.

I’ve also published two demonstrations on my YouTube channel:

• 🇬🇧 Customize GitHub Copilot CLI “Status Line” : Boost your terminal sessions!
• 🇫🇷 Personnaliser la “Status Line” de GitHub Copilot CLI : Boostez votre terminal !

Prerequisites

Windows users — see the Windows section at the end. (I am not a Windows user, so I welcome contributions to that section!)

1 — Enable the Experimental Feature

statusLine is behind an experimental gate. Pick one of the following approaches, then restart Copilot CLI:

# Option A: turn on all experimental features
copilot --experimental
# (or type /experimental on inside a running session)

# Option B: enable only STATUS_LINE in config
# Edit ~/.copilot/settings.json and add:
#   "feature_flags": { "enabled": ["STATUS_LINE"] }

After restarting, the CLI will look for statusLine in your config.

:::tip If you toggle experimental mode, restart Copilot CLI before testing. The feature flags are read at startup, simply call the /restart command. :::

2 — Create the Script

Save the following as ~/.copilot/statusline.sh (or any path you like):

#!/usr/bin/env bash

set -eu

payload=$(cat)

current_context_tokens=$(echo "$payload"  | jq -r '.context_window.current_context_tokens  // empty')
displayed_context_limit=$(echo "$payload"  | jq -r '.context_window.displayed_context_limit  // empty')
used_percentage=$(echo "$payload"  | jq -r '.context_window.used_percentage  // empty')

total_duration_ms=$(echo "$payload" | jq -r '.cost.total_duration_ms // 0')


current_context_tokens_formatted="$current_context_tokens"
if [ -n "$current_context_tokens" ] && [ "$current_context_tokens" -ge 1000 ]; then
    current_context_tokens_formatted="$(printf '%.1fk' "$(echo "scale=1; $current_context_tokens / 1000" | bc)")"
fi

displayed_context_limit_formatted="$displayed_context_limit"
if [ -n "$displayed_context_limit" ] && [ "$displayed_context_limit" -ge 1000 ]; then
    displayed_context_limit_formatted="$((displayed_context_limit / 1000))k"
fi      


# ── Format total duration as HH:MM:SS if available ──────────────────────────────
total_duration="00:00:00"
if [ "$total_duration_ms" -gt 0 ]; then
    # Convert ms to seconds, then format as HH:MM:SS locally no functions for this in bash
    total_seconds=$((total_duration_ms / 1000))
    hours=$((total_seconds / 3600))
    minutes=$(((total_seconds % 3600) / 60))
    seconds=$((total_seconds % 60))
    total_duration=$(printf "%02d:%02d:%02d" "$hours" "$minutes" "$seconds")
fi

# ── Build the gauge ──────────────────────────────────────────────
# 10-cell bar: each cell = 10 %. Filled = █, empty = ░
gauge=""
if [ -n "$used_percentage" ]; then
    # Round to nearest integer (jq gives a float like 42.7)
    pct_int=$(printf '%.0f' "$used_percentage")

    filled=$(( pct_int / 10 ))
    empty=$(( 10 - filled ))

    i=0; while [ $i -lt $filled ]; do gauge="${gauge}█"; i=$((i+1)); done
    i=0; while [ $i -lt $empty  ]; do gauge="${gauge}░"; i=$((i+1)); done

    gauge="${gauge} ${pct_int}%"
fi


# ── Format the final status line content ──────────────────────────────
printf "🧠 Context %s/%s - %s - " "$current_context_tokens" "$displayed_context_limit_formatted" "$gauge"
printf "\t⏱️ %s" "$total_duration"

Make it executable:

chmod +x ~/.copilot/statusline.sh

Use Any Language

The statusLine.command is not limited to Bash — you can use any language that supports a shebang (#!). As long as your script reads JSON from stdin and prints the status line to stdout, it will work.

Here are equivalent examples in Shell (sh), Python, and JavaScript (Node.js):

#!/usr/bin/env bash

input=$(cat)
model=$(echo "$input" | jq -r '.model.display_name')
displayed_context_limit=$(echo "$input" | jq -r '.context_window.displayed_context_limit')
printf "%s - Context Limit %s (sh)" "$model" "$displayed_context_limit"

#!/usr/bin/env python3

import sys
import json

input_data = sys.stdin.read()
data = json.loads(input_data)
model = data['model']['display_name']
displayed_context_limit = data['context_window']['displayed_context_limit']
print(f"{model} - Context Limit {displayed_context_limit} (Python)")

#!/usr/bin/env node

let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;
    const displayedContextLimit = data.context_window.displayed_context_limit;
    console.log(`${model} - Context Limit ${displayedContextLimit} (JS)`);
});

3 — Wire It Up in Config

Open ~/.copilot/settings.json and add the statusLine key:

{
  "statusLine": {
    "type": "command",
    "command": "~/.copilot/statusline.sh",
    "padding": 1
  }
}

Tip: The command value supports ~ expansion and environment variables, so $HOME/.copilot/statusline.sh works too.
If you use COPILOT_HOME or --config-dir, your config lives in that directory instead of ~/.copilot/.

Restart Copilot CLI. After the first model call you should see something like:

 🧠 Context 0/168k - █░░░░░░░░░ 19% - 	⏱️ 00:17:34

Statusline Command JSON Payload

All fields returned by the statusline.command API payload.

Windows: Git Bash & PowerShell

Option A — Git Bash

If you have Git for Windows installed, you already have Bash and can install jq via scoop or by dropping the jq.exe binary on your PATH.

Set the command in config to point at the Git Bash executable:

{
  "statusLine": {
    "type": "command",
    "command": "bash C:/Users/you/.copilot/statusline.sh"
  }
}

Use forward slashes or escaped backslashes in the path.
~ expansion may not work on Windows; use the absolute path instead.

Option B — PowerShell (no jq needed)

If you prefer a native Windows approach, save a .ps1 script:

# statusline.ps1
$json = $input | Out-String | ConvertFrom-Json
$t = $json.context_window.total_tokens
$p = [math]::Round($json.context_window.used_percentage)
$filled = [int]($p / 10)
$bar = ('█' * $filled) + ('░' * (10 - $filled))
Write-Host -NoNewline "tokens: $t  $bar ${p}%"

Config:

{
  "statusLine": {
    "type": "command",
    "command": "powershell -NoProfile -File C:\\Users\\you\\.copilot\\statusline.ps1"
  }
}

Caveat: PowerShell startup adds latency. If the 10-second timeout is tight on your machine, prefer the Git Bash route.

Recap

1. Enable the experimental STATUS_LINE feature and restart.
2. Create ~/.copilot/statusline.sh with the gauge script.
3. Configure statusLine.command in ~/.copilot/settings.json.

And remember: you can always type /context and /usage inside a Copilot CLI session to get a one-off snapshot of your context window usage. The status line just makes it always visible without interrupting your flow.

Happy coding!