Status line

The footer under the prompt box can carry one line of your own. You point Syntic Code at a script, it hands the script a JSON snapshot of the session, and whatever the script prints shows up in the footer. Use it for the git branch, the active model, how full the context is, how much of your plan window is left, a clock, or anything else a shell command can work out.

Two ways to set it up

Let the agent write it

/statusline

With no instructions, /statusline reads your shell start-up files (~/.zshrc, ~/.bashrc, ~/.bash_profile, ~/.profile, in that order), finds your prompt, and turns it into a status line command. You can also describe what you want:

/statusline show the branch, the model and how much context is used

A small built-in helper agent does the work. It may only read files and edit your settings, and it saves the result to ~/.syntic/settings.json, merging with what is already there. /statusline only works in an interactive session.

Write it yourself

Add a statusLine object to a settings file:

{
  "statusLine": {
    "command": "~/.syntic/statusline.sh",
    "refreshInterval": 30
  }
}

A "type": "command" field, which /statusline writes, is accepted and has no further effect.

Changes to the file are picked up while you work, so you can edit the script and the setting and watch the footer update.

Build one step by step

#!/usr/bin/env bash
# ~/.syntic/statusline.sh
input=$(cat)
model=$(printf '%s' "$input" | jq -r '.model')
echo "$model"

chmod +x ~/.syntic/statusline.sh

echo '{"model":"Syntic Code","cwd":"/tmp","total_cost_usd":0.12,"context_used_pct":0.4}' \
  | ~/.syntic/statusline.sh

{ "statusLine": { "command": "~/.syntic/statusline.sh" } }

How it runs

To remove the status line, delete the statusLine key or set command to an empty string.

The JSON your command receives

One JSON object arrives on standard input each run. Fields with no value yet are left out.

Plan usage fields

rate_limits always has five_hour and seven_day, each a fraction from 0 to 1 (0 until usage is known). Once Syntic Code has fetched your plan’s usage, it also carries:

five_hour follows the session window and seven_day follows the weekly window.

Plan usage is fetched in the background every five minutes, and only while a status line is set, you are signed in, and your privacy level allows optional traffic. Headless runs never fetch it.

A full example:

{
  "model": "Syntic Code",
  "cwd": "/home/dev/shop",
  "session_id": "5f1c…",
  "session_name": "Fix checkout rounding",
  "version": "0.4.2",
  "permission_mode": "acceptEdits",
  "effort": "medium",
  "fast_mode": false,
  "thinking_shown": false,
  "vim_mode": false,
  "total_cost_usd": 0.84,
  "context_used_pct": 0.31,
  "context_window": { "used_tokens": 81000, "window_tokens": 262144, "used_percentage": 30.9 },
  "rate_limits": {
    "five_hour": 0.42,
    "seven_day": 0.18,
    "windows": {
      "session": { "used_percentage": 42.0, "resets_at": "2026-10-13T17:00:00Z" },
      "weekly": { "used_percentage": 18.0, "resets_at": "2026-10-19T00:00:00Z" }
    },
    "unlimited": false,
    "credits_enabled": false
  }
}

Examples

Context use with a color warning

#!/usr/bin/env bash
input=$(cat)
pct=$(printf '%s' "$input" | jq -r '.context_window.used_percentage // 0')
model=$(printf '%s' "$input" | jq -r '.model')
if [ "${pct%.*}" -ge 80 ]; then color='\033[31m'; else color='\033[32m'; fi
printf "%s · ${color}%s%% context\033[0m\n" "$model" "$pct"

Branch and changed files

#!/usr/bin/env bash
input=$(cat)
dir=$(printf '%s' "$input" | jq -r '.cwd')
cd "$dir" 2>/dev/null || exit 0
branch=$(git branch --show-current 2>/dev/null) || exit 0
dirty=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
echo "⎇ ${branch:-detached} · ${dirty} changed"

Git can be slow in very large repositories. Remember the one-second limit; if your command is often cut off, cache the result in a file and refresh it less often.

Plan usage in Python

#!/usr/bin/env python3
import json, sys
 
data = json.load(sys.stdin)
limits = data.get("rate_limits", {})
session = limits.get("windows", {}).get("session")
cost = data.get("total_cost_usd", 0)
if limits.get("unlimited"):
    usage = "no limit"
elif session:
    usage = f"{session['used_percentage']:.0f}% of session window"
else:
    usage = "usage pending"
print(f"{data.get('model', '?')} · ${cost:.2f} · {usage}")

Shorter on narrow windows

#!/usr/bin/env bash
input=$(cat)
model=$(printf '%s' "$input" | jq -r '.model')
cwd=$(printf '%s' "$input" | jq -r '.cwd')
if [ "${COLUMNS:-80}" -lt 100 ]; then echo "$model"; else echo "$model · $cwd"; fi

A clock

{ "statusLine": { "command": "date +%H:%M", "refreshInterval": 30 } }

Subagent rows

While subagents run, each one has a row of its own. subagentStatusLine lets a script replace the task text on each row:

{ "subagentStatusLine": { "command": "~/.syntic/agent-line.sh" } }

The command runs once per running subagent, with the same timing rules as the main status line, and only after the folder is trusted. Its first line of output replaces that row’s task text. It is read from your own user settings file.

Each run receives:

#!/usr/bin/env bash
input=$(cat)
printf '%s' "$input" | jq -r '"\(.agent_type): \(.activity // "thinking") · \(.elapsed_secs)s"'

More about subagents is on Subagents.

When it goes wrong