@zalom/plastic 1.12.0 → 1.13.0

package/hooks/statusline

@@ -1,57 +1,258 @@
 #!/bin/bash
-# plastic-hook-version: 3.0.0
+# plastic-hook-version: 4.0.0
 # StatusLine hook - Plastic owns the full statusline (no chaining).
-# Renders: {model} - Plastic {version}[ -> {next}] - {path} - [{project}: {id} {title}]
-# Pure bash (macOS 3.2 compatible). No ruby, no jq. Reads stdin once; small file reads only.
+# Renders: {model} - ctx {pct}% ({used}/{size}) - 5h {p}% - 7d {p}% - ${cost}
+#          - claudish {n} rw / {tok} - Plastic {version}[ -> {next}] - {path}
+# Every segment but claudish and the Plastic version comes from the stdin payload.
+# Pure bash (macOS 3.2 compatible). No ruby, no jq. Reads stdin once; small file reads
+# only. The stdin JSON is walked in a single awk pass (below); nothing else in this
+# script forks a second process per field, which is what keeps a render cheap.
 
-INPUT=$(cat)
+IFS= read -r -d '' INPUT
 
 # --- Colors (ANSI-C quoting; bash 3.2 supports $'\033') ---
-C_MODEL=$'\033[38;2;90;140;220m'   # navy blue - model (lightened for legibility)
-C_VER=$'\033[37m'                  # white     - "Plastic {version}" and update arrow
-C_NEXT=$'\033[33m'                 # yellow    - next version
-C_PATH=$'\033[38;2;128;134;144m'   # gray      - path (matches dim UI text)
-C_BRACK=$'\033[33m'                # yellow    - work-unit brackets
-C_PROJ=$'\033[38;2;249;140;30m'    # orange    - project name
-C_ID=$'\033[38;2;45;212;191m'      # teal      - intent id (accent between orange + yellow)
-C_INTENT=$'\033[33m'               # yellow    - intent title
-C_SEP=$'\033[38;2;128;134;144m'    # gray      - separators
+C_MODEL=$'\033[38;2;90;140;220m'    # navy blue - model
+C_CTX=$'\033[38;2;45;212;191m'      # teal      - context window
+C_OK=''                             # default   - meter below 70%
+C_WARN=$'\033[33m'                  # yellow    - meter at 70% and above
+C_CRIT=$'\033[38;2;231;76;60m'      # red       - meter at 90% and above
+C_COST=$'\033[37m'                  # white     - session cost
+C_CLAUDISH=$'\033[38;2;249;140;30m' # orange    - claudish rewrites
+C_VER=$'\033[37m'                   # white     - "Plastic {version}" and update arrow
+C_NEXT=$'\033[33m'                  # yellow    - next version
+C_PATH=$'\033[38;2;128;134;144m'    # gray      - path (matches dim UI text)
+C_SEP=$'\033[38;2;128;134;144m'     # gray      - separators
 RST=$'\033[0m'
 SEP="${C_SEP} "$'\302\267'" ${RST}"   # " . " middot, dim
 
-# --- Extract a flat JSON string field from stdin: json_str <key> ---
-json_str() {
-  printf '%s' "$INPUT" \
-    | grep -o "\"$1\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" \
-    | head -1 \
-    | sed "s/.*\"$1\"[[:space:]]*:[[:space:]]*\"//;s/\"$//"
+# --- Truncate a JSON number to an integer ("42.5" -> "42"); empty stays empty ---
+to_int() {
+  case "$1" in
+    ''|*[!0-9.]*) return ;;
+  esac
+  _i=${1%%.*}
+  [ -z "$_i" ] && _i=0
+  printf '%s' "$_i"
 }
 
-# --- Model (model.display_name) ---
-MODEL=$(json_str "display_name")
+# --- Format a non-negative integer token count with k/M, rounded to the nearest
+# unit; "M" once the count reaches 1,000,000, "k" below it. Empty stays empty. ---
+fmt_tok() {
+  case "$1" in
+    ''|*[!0-9]*) return ;;
+  esac
+  if [ "$1" -ge 1000000 ]; then
+    printf '%dM' "$(( ($1 + 500000) / 1000000 ))"
+  else
+    printf '%dk' "$(( ($1 + 500) / 1000 ))"
+  fi
+}
+
+# --- Round a JSON decimal string to two places ("1.2345" -> "1.23"); empty or
+# non-numeric (including anything with a stray sign or exponent letter) stays
+# empty, matching to_int's guard. Pure bash arithmetic, no awk/printf fork. ---
+fmt_money() {
+  case "$1" in
+    ''|*[!0-9.]*) return ;;
+  esac
+  _whole=${1%%.*}
+  case "$1" in
+    *.*) _frac=${1#*.} ;;
+    *) _frac="" ;;
+  esac
+  [ -z "$_whole" ] && _whole=0
+  _frac3="${_frac}000"
+  _frac3=${_frac3:0:3}
+  _cents=${_frac3:0:2}
+  _third=${_frac3:2:1}
+  [ -z "$_cents" ] && _cents=00
+  _cents=$((10#$_cents))
+  if [ "$_third" -ge 5 ]; then
+    _cents=$((_cents + 1))
+    if [ "$_cents" -ge 100 ]; then
+      _cents=0
+      _whole=$((_whole + 1))
+    fi
+  fi
+  printf '%d.%02d' "$_whole" "$_cents"
+}
+
+# --- Walk the stdin JSON exactly once and emit "path<TAB>value" for every field
+# this script reads. A recursive-descent walker (not a regex or a brace-balanced
+# line range) so nesting, pretty-printing, and single-line payloads all parse the
+# same way, and a value inside an array can never be mistaken for one of the
+# named top-level fields (an array suppresses emission for everything under it).
+# A number token containing "e"/"E" is treated as unsupported and dropped, so
+# scientific-notation input renders as absent rather than a wrong magnitude.
+FIELDS=$(printf '%s' "$INPUT" | awk '
+  function skip_ws() {
+    while (i <= n) {
+      c = substr(buf, i, 1)
+      if (c == " " || c == "\t" || c == "\n" || c == "\r") { i++ } else { break }
+    }
+  }
+  function parse_string(   c, esc, start, s) {
+    i++
+    start = i
+    esc = 0
+    while (i <= n) {
+      c = substr(buf, i, 1)
+      if (esc) { esc = 0; i++; continue }
+      if (c == "\\") { esc = 1; i++; continue }
+      if (c == "\"") { break }
+      i++
+    }
+    s = substr(buf, start, i - start)
+    i++
+    return s
+  }
+  function parse_number(   start, c) {
+    start = i
+    if (substr(buf, i, 1) == "-") { i++ }
+    while (i <= n) {
+      c = substr(buf, i, 1)
+      if (c ~ /[0-9]/) { i++; continue }
+      if (c == "." || c == "e" || c == "E" || c == "+" || c == "-") { i++; continue }
+      break
+    }
+    return substr(buf, start, i - start)
+  }
+  function parse_value(key, prefix, emit,   c, qp, val) {
+    skip_ws()
+    c = substr(buf, i, 1)
+    if (key != "") { qp = (prefix == "" ? key : prefix "." key) } else { qp = "" }
+    if (c == "{") {
+      parse_object(qp, emit)
+    } else if (c == "[") {
+      parse_array()
+    } else if (c == "\"") {
+      val = parse_string()
+      if (emit && qp != "" && (qp in wanted)) { print qp "\t" val }
+    } else if (c == "-" || (c >= "0" && c <= "9")) {
+      val = parse_number()
+      if (emit && qp != "" && (qp in wanted) && val !~ /[eE]/) { print qp "\t" val }
+    } else if (substr(buf, i, 4) == "true") {
+      i += 4
+    } else if (substr(buf, i, 5) == "false") {
+      i += 5
+    } else if (substr(buf, i, 4) == "null") {
+      i += 4
+    } else {
+      i++
+    }
+  }
+  function parse_object(prefix, emit,   c, key) {
+    i++
+    skip_ws()
+    if (substr(buf, i, 1) == "}") { i++; return }
+    while (i <= n) {
+      skip_ws()
+      if (substr(buf, i, 1) != "\"") {
+        if (substr(buf, i, 1) == "}") { i++; return }
+        i++
+        continue
+      }
+      key = parse_string()
+      skip_ws()
+      if (substr(buf, i, 1) == ":") { i++ }
+      parse_value(key, prefix, emit)
+      skip_ws()
+      c = substr(buf, i, 1)
+      if (c == ",") { i++; continue }
+      if (c == "}") { i++; return }
+      return
+    }
+  }
+  function parse_array(   c) {
+    i++
+    skip_ws()
+    if (substr(buf, i, 1) == "]") { i++; return }
+    while (i <= n) {
+      parse_value("", "", 0)
+      skip_ws()
+      c = substr(buf, i, 1)
+      if (c == ",") { i++; continue }
+      if (c == "]") { i++; return }
+      return
+    }
+  }
+  BEGIN {
+    wanted["model.display_name"] = 1
+    wanted["workspace.current_dir"] = 1
+    wanted["cwd"] = 1
+    wanted["session_id"] = 1
+    wanted["context_window.used_percentage"] = 1
+    wanted["context_window.context_window_size"] = 1
+    wanted["context_window.current_usage.input_tokens"] = 1
+    wanted["context_window.current_usage.cache_creation_input_tokens"] = 1
+    wanted["context_window.current_usage.cache_read_input_tokens"] = 1
+    wanted["cost.total_cost_usd"] = 1
+    wanted["rate_limits.five_hour.used_percentage"] = 1
+    wanted["rate_limits.seven_day.used_percentage"] = 1
+  }
+  { buf = buf $0 " " }
+  END {
+    n = length(buf)
+    i = 1
+    skip_ws()
+    if (substr(buf, i, 1) == "{") { parse_value("", "", 1) }
+  }
+')
+
+MODEL=""
+REAL_CWD=""
+CWD_TOP=""
+SID=""
+CW_PCT=""
+CW_SIZE=""
+CU_IN=""
+CU_CC=""
+CU_CR=""
+COST_RAW=""
+M5_PCT=""
+M7_PCT=""
+
+while IFS=$'\t' read -r k v; do
+  case "$k" in
+    model.display_name) MODEL="$v" ;;
+    workspace.current_dir) REAL_CWD="$v" ;;
+    cwd) CWD_TOP="$v" ;;
+    session_id) SID="$v" ;;
+    context_window.used_percentage) CW_PCT="$v" ;;
+    context_window.context_window_size) CW_SIZE="$v" ;;
+    context_window.current_usage.input_tokens) CU_IN="$v" ;;
+    context_window.current_usage.cache_creation_input_tokens) CU_CC="$v" ;;
+    context_window.current_usage.cache_read_input_tokens) CU_CR="$v" ;;
+    cost.total_cost_usd) COST_RAW="$v" ;;
+    rate_limits.five_hour.used_percentage) M5_PCT="$v" ;;
+    rate_limits.seven_day.used_percentage) M7_PCT="$v" ;;
+  esac
+done <<FIELDS_EOF
+$FIELDS
+FIELDS_EOF
 
 # --- Path (workspace.current_dir, fallback top-level cwd) ---
-REAL_CWD=$(json_str "current_dir")
-[ -z "$REAL_CWD" ] && REAL_CWD=$(json_str "cwd")
-# Abbreviate $HOME -> ~
+[ -z "$REAL_CWD" ] && REAL_CWD="$CWD_TOP"
 CWD="$REAL_CWD"
 case "$CWD" in
   "$HOME") CWD="~" ;;
   "$HOME"/*) CWD="~${CWD#"$HOME"}" ;;
 esac
 
-# --- Plastic version ---
+# --- Plastic version (read builtin, no tr fork) ---
 VERSION=""
-[ -f "$HOME/.plastic/VERSION" ] && VERSION=$(tr -d ' \t\n' < "$HOME/.plastic/VERSION")
+if [ -f "$HOME/.plastic/VERSION" ]; then
+  IFS= read -r VERSION < "$HOME/.plastic/VERSION"
+fi
 
-# --- Update (next version when one is available) ---
+# --- Update (next version when one is available); pure-bash regex, no fork ---
 NEXT=""
 CACHE_FILE="$HOME/.plastic/.cache/update-check.json"
 if [ -f "$CACHE_FILE" ]; then
-  if grep -q '"updateAvailable"[[:space:]]*:[[:space:]]*true' "$CACHE_FILE" 2>/dev/null; then
-    LATEST=$(grep -o '"latest"[[:space:]]*:[[:space:]]*"[^"]*"' "$CACHE_FILE" 2>/dev/null \
-      | head -1 | sed 's/.*"latest"[[:space:]]*:[[:space:]]*"//;s/"$//')
-    if [ -n "$LATEST" ]; then
+  IFS= read -r -d '' CACHE_JSON < "$CACHE_FILE" || true
+  if [[ "$CACHE_JSON" =~ \"updateAvailable\"[[:space:]]*:[[:space:]]*true ]]; then
+    if [[ "$CACHE_JSON" =~ \"latest\"[[:space:]]*:[[:space:]]*\"([^\"]*)\" ]]; then
+      LATEST="${BASH_REMATCH[1]}"
       case "$LATEST" in
         *-*) NEXT="${LATEST##*-}" ;;   # 1.0.0-beta.3 -> beta.3
         *)   NEXT="$LATEST" ;;
@@ -60,144 +261,88 @@ if [ -f "$CACHE_FILE" ]; then
   fi
 fi
 
-# --- Scope resolution: cwd -> registered project store, else global ---
-# Match the longest registered project path that prefixes the real cwd.
-PROJECTS_YML="$HOME/.plastic/projects.yml"
-SLUG=""
-if [ -n "$REAL_CWD" ] && [ -f "$PROJECTS_YML" ]; then
-  SLUG=$(awk -v cwd="$REAL_CWD" '
-    /^  [A-Za-z0-9_.-]+:[[:space:]]*$/ { s=$1; sub(/:$/,"",s); next }
-    /^    path:/ {
-      p=$0; sub(/^[[:space:]]*path:[[:space:]]*/,"",p); gsub(/"/,"",p);
-      if (length(p)>0 && (cwd==p || index(cwd, p"/")==1) && length(p)>best) { best=length(p); win=s }
-    }
-    END { if (win!="") print win }
-  ' "$PROJECTS_YML")
+# --- Context window (stdin context_window) ---
+# used_percentage is the documented input-side figure (input + cache creation +
+# cache read), so it wins for the percentage. The token count in parentheses comes
+# from current_usage when it is present. Each derives the other when only one is
+# available; when both are null there is no ctx segment.
+CTX_SEG=""
+CW_SIZE=$(to_int "$CW_SIZE")
+CW_PCT=$(to_int "$CW_PCT")
+CW_USED=""
+U_IN=$(to_int "$CU_IN")
+U_CC=$(to_int "$CU_CC")
+U_CR=$(to_int "$CU_CR")
+if [ -n "$U_IN$U_CC$U_CR" ]; then
+  CW_USED=$(( ${U_IN:-0} + ${U_CC:-0} + ${U_CR:-0} ))
 fi
-
-if [ -n "$SLUG" ]; then
-  INDEX="$HOME/.plastic/projects/$SLUG/INDEX.md"
-  PROJ_LABEL="$SLUG"
-else
-  INDEX="$HOME/.plastic/INDEX.md"
-  PROJ_LABEL="global"
+if [ -z "$CW_USED" ] && [ -n "$CW_PCT" ] && [ -n "$CW_SIZE" ] && [ "$CW_SIZE" -gt 0 ]; then
+  CW_USED=$(( CW_SIZE * CW_PCT / 100 ))
 fi
-INDEX_DIR=$(dirname "$INDEX")
-
-# --- Current-session work-unit: the live bridge wins over savepoint recency ---
-# The statusline receives the real session_id on stdin. A session can now own
-# SEVERAL per-intent bridges at once (intent 131, plastic-{session_id}--{id}.json),
-# one per concurrent delivery, so the statusline must pick which of them to show:
-# prefer a candidate whose worktree.code (or intent dir) prefixes REAL_CWD, else
-# the newest by mtime (ls -t is 3.2-safe); tolerate a legacy single-key
-# plastic-{session_id}.json when no per-intent file exists. This beats the shared,
-# savepoint-recency heuristic so parallel sessions on one store no longer
-# overwrite each other's line. grep/sed/ls only - no jq, no ruby.
-WORK=""
-SID=$(json_str "session_id")
-
-if [ -n "$SID" ]; then
-  BR_TMP="${PLASTIC_TMP:-/tmp}"
-  BRIDGE=""
-  CANDIDATES=$(ls -1t "${BR_TMP}"/plastic-"${SID}"--*.json 2>/dev/null)
-  if [ -n "$CANDIDATES" ]; then
-    while IFS= read -r cand; do
-      [ -z "$cand" ] && continue
-      WT_BLOCK=$(sed -n '/"worktree"[[:space:]]*:[[:space:]]*{/,/}/p' "$cand" 2>/dev/null)
-      WC=$(printf '%s\n' "$WT_BLOCK" | grep -o '"code"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
-        | sed 's/.*"code"[[:space:]]*:[[:space:]]*"//;s/"$//')
-      IN_BLOCK=$(sed -n '/"intent"[[:space:]]*:[[:space:]]*{/,/}/p' "$cand" 2>/dev/null)
-      ISTORE=$(printf '%s\n' "$IN_BLOCK" | grep -o '"store"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
-        | sed 's/.*"store"[[:space:]]*:[[:space:]]*"//;s/"$//')
-      IDIR=$(printf '%s\n' "$IN_BLOCK" | grep -o '"dir"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
-        | sed 's/.*"dir"[[:space:]]*:[[:space:]]*"//;s/"$//')
-      MATCH=""
-      if [ -n "$WC" ] && [ -n "$REAL_CWD" ]; then
-        case "$REAL_CWD" in "$WC"|"$WC"/*) MATCH=1 ;; esac
-      fi
-      if [ -z "$MATCH" ] && [ -n "$ISTORE" ] && [ -n "$IDIR" ] && [ -n "$REAL_CWD" ]; then
-        IPATH="$ISTORE/$IDIR"
-        case "$REAL_CWD" in "$IPATH"|"$IPATH"/*) MATCH=1 ;; esac
-      fi
-      if [ -n "$MATCH" ]; then
-        BRIDGE="$cand"
-        break
-      fi
-    done <<BRIDGE_CAND_EOF
-$CANDIDATES
-BRIDGE_CAND_EOF
-    # No cwd/worktree signal on any candidate: fail open to the newest (ls -t
-    # already sorted CANDIDATES newest-first).
-    [ -z "$BRIDGE" ] && BRIDGE=$(printf '%s\n' "$CANDIDATES" | head -1)
-  else
-    # Legacy tolerance: no per-intent bridge for this session, but an old
-    # single-key file may still exist.
-    LEGACY="${BR_TMP}/plastic-${SID}.json"
-    [ -f "$LEGACY" ] && BRIDGE="$LEGACY"
-  fi
-
-  if [ -n "$BRIDGE" ] && [ -f "$BRIDGE" ]; then
-    # Bridge JSON is pretty-printed (one field per line). Scope extraction to the
-    # "intent" object so a sibling top-level "id"/"name" can never win (the intent
-    # object holds only string fields, so the first "}" closes it). grep/sed only.
-    INTENT_BLOCK=$(sed -n '/"intent"[[:space:]]*:[[:space:]]*{/,/}/p' "$BRIDGE" 2>/dev/null)
-    B_ID=$(printf '%s\n' "$INTENT_BLOCK" | grep -o '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
-      | sed 's/.*"id"[[:space:]]*:[[:space:]]*"//;s/"$//')
-    B_NAME=$(printf '%s\n' "$INTENT_BLOCK" | grep -o '"name"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
-      | sed 's/.*"name"[[:space:]]*:[[:space:]]*"//;s/"$//')
-    if [ -n "$B_ID" ] && [ -n "$B_NAME" ]; then
-      EMDASH=$'\342\200\224'
-      WORK="${B_ID} ${EMDASH} ${B_NAME}"
-    fi
+if [ -z "$CW_PCT" ] && [ -n "$CW_USED" ] && [ -n "$CW_SIZE" ] && [ "$CW_SIZE" -gt 0 ]; then
+  CW_PCT=$(( CW_USED * 100 / CW_SIZE ))
+fi
+if [ -n "$CW_PCT" ]; then
+  CTX_SEG="${C_CTX}ctx ${CW_PCT}%"
+  if [ -n "$CW_USED" ] && [ -n "$CW_SIZE" ] && [ "$CW_SIZE" -gt 0 ]; then
+    CTX_SEG="${CTX_SEG} ($(fmt_tok "$CW_USED")/$(fmt_tok "$CW_SIZE"))"
   fi
+  CTX_SEG="${CTX_SEG}${RST}"
 fi
 
-# --- Most-recently-accessed active intent (mirror dashboard: last savepoint ts) ---
-# Fallback only: runs when no session bridge resolved a work-unit above.
-if [ -z "$WORK" ] && [ -f "$INDEX" ]; then
-  BEST_TS=""
-  while IFS= read -r line; do
-    [ -z "$line" ] && continue
-    inside=${line#*[}; inside=${inside%%]*}             # "{id} - {title}"
-    dir=${line#*](store/}; dir=${dir%%/*}              # intent directory name
-    [ -z "$dir" ] && continue
-    sp="$INDEX_DIR/store/$dir/savepoint.md"
-    ts=""
-    if [ -f "$sp" ]; then
-      ts=$(grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z' "$sp" 2>/dev/null | tail -1)
-    fi
-    # ISO8601 sorts lexicographically; keep the newest. Empty ts sorts lowest.
-    if [ -z "$BEST_TS" ] || { [ -n "$ts" ] && [ "$ts" \> "$BEST_TS" ]; }; then
-      BEST_TS="$ts"
-      WORK="$inside"
-    fi
-  done <<EOF
-$(sed -n '/^## Active$/,/^## /{/^- \[/p;}' "$INDEX")
-EOF
+# --- Subscription meters (stdin rate_limits; absent for API-key sessions) ---
+meter_seg() {   # $1 = label, $2 = raw percentage
+  _p=$(to_int "$2")
+  [ -z "$_p" ] && return
+  _c="$C_OK"
+  [ "$_p" -ge 70 ] && _c="$C_WARN"
+  [ "$_p" -ge 90 ] && _c="$C_CRIT"
+  printf '%s' "${_c}$1 ${_p}%${RST}"
+}
+M5=$(meter_seg "5h" "$M5_PCT")
+M7=$(meter_seg "7d" "$M7_PCT")
+
+# --- Session cost (stdin cost.total_cost_usd); hidden when it renders as $0.00 ---
+COST_SEG=""
+if [ -n "$COST_RAW" ]; then
+  COST_FMT=$(fmt_money "$COST_RAW")
+  [ -n "$COST_FMT" ] && [ "$COST_FMT" != "0.00" ] && COST_SEG="${C_COST}\$${COST_FMT}${RST}"
 fi
 
-# --- Build the work-unit "[{project}: {id} {title}]" with title truncation ---
-WORK_SEG=""
-if [ -n "$WORK" ]; then
-  # Split "{id} - {title}" on the em-dash (U+2014).
-  EMDASH=$'\342\200\224'
-  id=${WORK%% $EMDASH *}
-  title=${WORK#* $EMDASH }
-  # Fallback if the em-dash form is absent: split on first space.
-  if [ "$id" = "$WORK" ]; then id=${WORK%% *}; title=${WORK#* }; fi
-  # Truncate long titles (~40 chars).
-  if [ ${#title} -gt 40 ]; then title="$(printf '%.40s' "$title")..."; fi
-  WORK_SEG="${C_BRACK}[${RST}${C_PROJ}${PROJ_LABEL}${RST}${C_INTENT}: ${RST}${C_ID}${id}${RST}${C_INTENT} ${title}${RST}${C_BRACK}]${RST}"
+# --- claudish rewrites for THIS session (fork ledger, optional) ---
+# Tab separated, one call per line; column 11 is the session id. Rows written
+# before that column existed have 9 or 10 fields and never match, so an old
+# ledger renders no segment instead of a wrong one.
+CL_SEG=""
+CL_LOG="${CLAUDISH_LOCAL_DIR:-$HOME/.claude/claudish-local}/usage.log"
+if [ -n "$SID" ] && [ -f "$CL_LOG" ]; then
+  CL=$(awk -F'\t' -v sid="$SID" '
+    NF >= 11 && $11 == sid { n++; t += $5 + $6 }
+    END {
+      if (n > 0) {
+        if (t >= 1000) {
+          s = sprintf("%.1f", t / 1000); sub(/\.0$/, "", s); printf "%d %sk", n, s
+        } else {
+          printf "%d %d", n, t
+        }
+      }
+    }' "$CL_LOG" 2>/dev/null)
+  [ -n "$CL" ] && CL_SEG="${C_CLAUDISH}claudish ${CL%% *} rw / ${CL#* }${RST}"
 fi
 
 # --- Assemble segments in order, joined by " . " ---
 PARTS=""
 add() { [ -z "$1" ] && return; if [ -z "$PARTS" ]; then PARTS="$1"; else PARTS="$PARTS$SEP$1"; fi; }
 
-# Order: stable values first (model, work-unit), then the volatile-length
-# values last (version, path) so the line does not visually jump as they change.
+# Order: identity first (model), then this session's spend (context, meters, cost,
+# rewrites), then the volatile-length values last (version, path) so the line does
+# not visually jump as they change.
 [ -n "$MODEL" ] && add "${C_MODEL}${MODEL}${RST}"
-[ -n "$WORK_SEG" ] && add "$WORK_SEG"
+add "$CTX_SEG"
+add "$M5"
+add "$M7"
+add "$COST_SEG"
+add "$CL_SEG"
 if [ -n "$VERSION" ]; then
   vseg="${C_VER}Plastic ${VERSION}${RST}"
   [ -n "$NEXT" ] && vseg="${vseg}${C_VER} "$'\342\206\222'" ${RST}${C_NEXT}${NEXT}${RST}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/lib/bridge.rb

@@ -37,8 +37,9 @@ module Bridge
   # `## Active` block); such bridges are purged. An Active intent's bridge is kept
   # unconditionally, because while the intent is live the bridge is still load-
   # bearing: it is the continuation signal (a parked or interrupted run resumes
-  # from it) and the anti-collision lock (it keys the per-session statusline so
-  # parallel sessions do not overwrite each other). An age window was the wrong
+  # from it) and the anti-collision lock for parallel deliveries on one store,
+  # keeping each session's gate checks and locks from overwriting another's. An
+  # age window was the wrong
   # axis: it left dead bridges resident for ~2 days AND could reap bridges of
   # interrupted-but-still-active intents, which are exactly the ones to preserve.
 
@@ -121,7 +122,7 @@ module Bridge
   # The CLAUDE_CODE_SESSION_ID fallback (intent 79) carries the bg/headless real
   # session id (Claude Code passes session_id on stdin, not via an env var; the
   # headless id lives in CLAUDE_CODE_SESSION_ID). Keying by the real id (instead of
-  # a derived hash) lets the statusline, which receives that same id on stdin, find
+  # a derived hash) lets the gate hooks, which receive that same id on stdin, find
   # the bridge by direct filename lookup.
   def self.resolve_session(explicit, intent_id:, store:)
     return explicit.to_s.strip unless blank?(explicit)

package/scripts/lib/doctor_core.rb

@@ -107,6 +107,19 @@ class Doctor
     path.sub(Dir.home, "~")
   end
 
+  # Every hook command string registered under one settings.json event, flattened
+  # across that event's matcher groups. Shape-tolerant on purpose: settings.json is
+  # hand-editable and may carry anything at all under an event key.
+  def event_commands(groups)
+    return [] unless groups.is_a?(Array)
+
+    groups.flat_map do |group|
+      next [] unless group.is_a?(Hash) && group["hooks"].is_a?(Array)
+
+      group["hooks"].map { |h| h.is_a?(Hash) ? h["command"].to_s : "" }
+    end
+  end
+
   def check(category:, name:, status:, message:, details: [], fixable: false, fix_hint: nil)
     result = {
       category: category,
@@ -270,14 +283,30 @@ class Doctor
       )
     else
       hooks = settings["hooks"] || {}
+
+      # A live registration is a launcher Plastic ships TODAY (intent 277).
+      # claude_purge_command?, which this replaced, answers "was this ever ours":
+      # right for the installer's purge, wrong here, because a SessionStart
+      # carrying only the retired plastic-lock-gate satisfied the event while
+      # nothing shipped to run it.
       missing_events = CLAUDE_HOOK_EVENTS.reject do |event|
-        groups = hooks[event]
-        next false unless groups.is_a?(Array)
+        event_commands(hooks[event]).any? { |cmd| HookRegistry.claude_current_command?(cmd) }
+      end
 
-        groups.any? do |group|
-          group.is_a?(Hash) && group["hooks"].is_a?(Array) &&
-            group["hooks"].any? { |h| HookRegistry.claude_purge_command?(h["command"]) }
-        end
+      # Name the launcher when a missing event still carries a Plastic-owned
+      # command. Inside a missing event every such command is by construction not
+      # a current one, and a bare "SessionStart" reads as "nothing registered" to
+      # someone looking at a settings.json that plainly holds a plastic- entry.
+      # Events with no Plastic entry keep the bare name: two tests compare details
+      # by element equality and by count.
+      missing_details = missing_events.map do |event|
+        stale = event_commands(hooks[event])
+                .flat_map { |cmd| HookRegistry.command_basenames(cmd) }
+                .select { |name| HookRegistry.claude_purgeable_launcher_names.include?(name) }
+                .uniq
+        next event if stale.empty?
+
+        "#{event} (registered command is not a current Plastic hook: #{stale.join(', ')})"
       end
 
       if missing_events.empty?
@@ -289,7 +318,7 @@ class Doctor
         checks << check(
           category: "agent_registration", name: "hooks_registered", status: "fail",
           message: "#{missing_events.size} hook event(s) not registered in settings.json",
-          details: missing_events,
+          details: missing_details,
           fixable: true, fix_hint: "Re-run the Plastic installer: npx @zalom/plastic@latest --claude"
         )
       end

package/scripts/lib/hook_registry.rb

@@ -244,6 +244,26 @@ module HookRegistry
     command_basenames(cmd).any? { |name| known.include?(name) }
   end
 
+  # Is this settings.json hook command one Plastic registers TODAY? (intent 277)
+  #
+  # The narrower twin of claude_purge_command?. The purge asks "was this ever
+  # ours", because it has to recognise an old entry in order to remove it. A
+  # liveness check asks "is there something here that still runs", and the two
+  # sets differ by exactly the entries that make the answers disagree: a
+  # SessionStart carrying only plastic-lock-gate satisfied doctor's
+  # hooks_registered while no such launcher ships anymore.
+  #
+  # Sourced from claude_launcher_names alone, so RETIRED_CLAUDE_LAUNCHERS is out
+  # (that is the bug) and CLAUDE_NON_HOOK_LAUNCHERS is out too: plastic-statusline
+  # is settings["statusLine"], not a hook of any event, so a group whose only
+  # Plastic entry is the statusline command has no hook registered in it.
+  # Tokenised through command_basenames like the purge predicate, so a quoted
+  # path or the legacy `ruby <path>/plastic-<name>.rb` form still resolves.
+  def claude_current_command?(cmd)
+    known = claude_launcher_names
+    command_basenames(cmd).any? { |name| known.include?(name) }
+  end
+
   # Is this ~/.codex/hooks.json command one of ours? Every Plastic Codex entry
   # invokes our dispatcher by path (`"<plastic_home>/scripts/codex-hook" <name>`),
   # so the dispatcher's filename identifies it. Basename EQUALITY, so a user's

package/scripts/scaffold-intent

@@ -31,8 +31,8 @@
 #
 # outcome is an end-of-Exec step. Run it once the diff and the test summary exist, right
 # before plastic-intent-ending writes the narrative. Writing outcome.md makes the intent
-# read as Done to the statusline and to any stage-derived display (Bridge.derive_stage
-# keys on outcome.md's presence). This does NOT purge a bridge:
+# read as Done to any stage-derived display (Bridge.derive_stage keys on outcome.md's
+# presence). This does NOT purge a bridge:
 # Bridge.purge_done_bridges keys on INDEX Active status plus lock presence, never on the
 # derived stage.