crewforth 3.1.1 → 3.2.0-rc.2

package/kit/eval/lib/star.sh

@@ -1,10 +1,13 @@
 #!/usr/bin/env bash
 # The one "leave a star" line. Single source of its URL, its text in both languages, and when it stays quiet.
 #
-#   star.sh --once <project>   ONCE PER KIT VERSION per clone. The installers (first install, and every update)
-#                              and doctor.sh on a healthy verdict all call it this way and share one marker, so a
-#                              version shows the line once — whichever of them reaches it first — and never again
-#                              until the Crewforth version changes. The marker holds the version it was shown for.
+#   star.sh --once <project> [doctor]
+#                              ONCE PER KIT VERSION per clone and per caller. The installers (first install, and
+#                              every update) share one marker; doctor (doctor.sh on a healthy verdict, and the
+#                              plugin's /crew-doctor) keeps its own, `doctor`. So a version shows the line at most
+#                              twice, once where it was installed and once where it was checked, and never again
+#                              until the Crewforth version changes. A marker holds the version it was shown for.
+#                              /crew-update runs its doctor with CREW_NO_STAR=1, so one command never shows it twice.
 #   star.sh                    unconditional (tests, and anyone who wants to see it).
 #
 # Nothing else prints it: not a hook, not a session start. Cost: one line (~30 tokens) per version, and only when
@@ -31,11 +34,21 @@ if [ "${1:-}" = --once ]; then
   # Builtin reads, not `head | tr` in a $( ): on Git Bash those two pipelines were 4 of ~11 processes and ~250 ms
   # of ~395 ms per call (measured on stock Windows). `read` takes the first line; the CR is stripped by expansion.
   # The braces matter: a failed `<` reports before a trailing 2>/dev/null applies (measured: 450 bytes of stderr).
-  VER=""; { IFS= read -r VER < "$_dir/.claude/VERSION"; } 2>/dev/null; VER="${VER%$'\r'}"; VER="${VER:-unknown}"
+  VER=""; { IFS= read -r VER < "$_dir/.claude/VERSION"; } 2>/dev/null; VER="${VER%$'\r'}"
+  # The plugin edition has no .claude/VERSION: its version is the manifest's, beside this file at ../../.
+  if [ -z "$VER" ]; then
+    _here="${BASH_SOURCE%[/\\]*}"; [ "$_here" = "${BASH_SOURCE}" ] && _here=.
+    [ -f "$_here/../../.claude-plugin/plugin.json" ] && [ -f "$_here/settings-json.awk" ] && \
+      VER="$(awk -v op=get -v path=version -f "$_here/settings-json.awk" "$_here/../../.claude-plugin/plugin.json" 2>/dev/null)"
+    VER="${VER#\"}"; VER="${VER%\"}"            # the reader prints a JSON string with its quotes
+    case "$VER" in *[!0-9A-Za-z.-]*) VER="" ;; esac
+  fi
+  VER="${VER:-unknown}"
+  _key=crewforth-star; [ "${3:-}" = doctor ] && _key=crewforth-star-doctor
   # GIT_DIR/GIT_WORK_TREE dropped: exported by a caller (a hook), they would point the marker at another repo.
-  MARK="$(cd "$_dir" 2>/dev/null && env -u GIT_DIR -u GIT_WORK_TREE git rev-parse --git-path crewforth-star 2>/dev/null)" || MARK=""
+  MARK="$(cd "$_dir" 2>/dev/null && env -u GIT_DIR -u GIT_WORK_TREE git rev-parse --git-path "$_key" 2>/dev/null)" || MARK=""
   case "$MARK" in
-    '') MARK="$_dir/.claude/star-shown" ;;
+    '') MARK="$_dir/.claude/star-shown"; [ "$_key" = crewforth-star ] || MARK="$MARK-doctor" ;;
     /*|[A-Za-z]:*) ;;                          # absolute (POSIX or a Windows drive path from git)
     *) MARK="$_dir/$MARK" ;;                   # git answers relative to the directory it was asked in
   esac
@@ -65,6 +78,9 @@ _mt() {
 _mt '⭐ If Crewforth saves you a review round, a star helps others find it: %s' "$CREW_REPO_URL"
 # The marker only after the line actually went out: a closed stdout must not record "shown".
 if printf '%s\n' "$_M" && [ -n "$MARK" ]; then
+  # A plugin project may have no .claude/ yet: without one the marker would never be written and the line would
+  # come back on every run.
+  [ -d "${MARK%/*}" ] || mkdir -p "${MARK%/*}" 2>/dev/null
   { printf '%s\n' "$VER" > "$MARK"; } 2>/dev/null
 fi
 exit 0

package/kit/eval/lib/statusline.settings.json

@@ -0,0 +1,6 @@
+{
+  "statusLine": {
+    "type": "command",
+    "command": "cd \"$CLAUDE_PROJECT_DIR\" 2>/dev/null; bash .claude/eval/lib/statusline.sh"
+  }
+}

package/kit/eval/lib/statusline.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# statusline.sh — Crewforth's status line: one line, from what Claude Code hands it on stdin and what the hooks
+# have already written. It decides nothing and blocks nothing; it only says.
+#
+#   🛡 BLOCK §4.2 · ✓ commit approved 24m · ⚙ 2 crew agents · 🔋 34% · ~$1.20
+#
+# Each part is shown only when there is something to say, and only for THIS session:
+#   🛡  the gate's last word in this session: the last line of the gate log, if it was written after the session's
+#       first status line (the log carries no time, so a line from last week must not read as now)
+#   ✓   an approval the user gave for a commit or a push that still holds (the record prompt-approval.sh keeps in
+#       the git directory, 30 minutes, emptied at the user's next message)
+#   ⚙   crew agents started in this session that have not stopped yet (model routing's records)
+#   🔋  the context fill Claude Code measured (context_window.used_percentage), never an estimate
+#   ~$  what Claude Code puts the session's cost at (cost.total_cost_usd), at API list price
+#
+# Wired by the installers only where no status line is set already (theirs is never replaced), from
+# statusline.settings.json beside this file.
+# COST. Claude Code runs this after every change, debounced at 300 ms. Measured: awk (the stdin JSON) and tail (the
+# gate log), and on bash older than 4.2 one date; the rest is builtins. No git, no jq, no python.
+set -u
+_here="${BASH_SOURCE%[/\\]*}"; [ "$_here" = "${BASH_SOURCE}" ] && _here=.
+
+# --install, from the project root: put this status line into .claude/settings.json only where NO status line is
+# set (the project's settings, its local settings, or the user's own); a user's line is never replaced, because
+# the project's setting would win over it. Prints one word: installed · kept (one is set) · none (no settings.json)
+# · failed (the file is left as it was). A managed settings layer is not read. The merge is Crewforth's own JSON reader.
+if [ "${1:-}" = --install ]; then
+  # The setting itself is data beside this file (statusline.settings.json); the rule for putting a default in is
+  # one helper, shared with the subagent model's default.
+  exec bash "$_here/settings-default.sh" --install statusLine "$_here/statusline.settings.json"
+fi
+
+IFS= read -r -d '' IN || true
+[ -n "$IN" ] || exit 0
+# One read of the four values the line needs.
+F="$(printf '%s' "$IN" | awk -v op=gets -v 'path=session_id|context_window.used_percentage|cost.total_cost_usd|workspace.project_dir' -f "$_here/settings-json.awk" - 2>/dev/null)" || F=""
+IFS=$'\t' read -r SID PCT COST PDIR <<< "$F"
+# The reader prints a string with its quotes; taken off by expansion, not a subshell (this runs every few seconds).
+SID="${SID:-}"; SID="${SID#\"}"; SID="${SID%\"}"; PDIR="${PDIR:-}"; PDIR="${PDIR#\"}"; PDIR="${PDIR%\"}"
+case "$SID" in ''|*[!A-Za-z0-9._-]*) SID="" ;; esac
+[ -n "$PDIR" ] && [ -d "$PDIR/.claude" ] && cd "$PDIR" 2>/dev/null
+
+OUT=()
+# The session's baseline: made on its first status line. What is newer than it happened in this session.
+BASE=""
+if [ -n "$SID" ] && [ -d .claude ]; then
+  BASE=".claude/state/statusline/$SID"
+  if [ ! -e "$BASE" ]; then
+    mkdir -p .claude/state/statusline 2>/dev/null
+    : > "$BASE" 2>/dev/null || BASE=""
+  fi
+fi
+
+# 🛡 The gate's last word in this session.
+GL="${CREW_GATE_LOG:-.claude/gate-log.tsv}"
+if [ -n "$BASE" ] && [ -f "$GL" ] && [ "$GL" -nt "$BASE" ]; then
+  last="$(tail -n 1 "$GL" 2>/dev/null)"
+  IFS=$'\t' read -r verdict section _ <<< "$last"
+  case "$verdict" in BLOCK|ASK|ALLOW|NOTE) OUT+=("🛡 $verdict ${section:-}") ;; esac
+fi
+
+# ✓ An approval that still holds: the record is in the git directory (a worktree's .git is a file naming it).
+G=""
+if [ -d .git ]; then G=".git"
+elif [ -f .git ]; then IFS= read -r l < .git 2>/dev/null; case "$l" in "gitdir: "*) G="${l#gitdir: }"; G="${G%$'\r'}" ;; esac; fi
+if [ -n "$G" ] && [ -s "$G/crewforth-approval" ]; then
+  op=""; ts=""
+  while IFS='=' read -r k v; do v="${v%$'\r'}"; case "$k" in op) op="$v" ;; ts) ts="$v" ;; esac; done < "$G/crewforth-approval"
+  if [ "${BASH_VERSINFO[0]}" -ge 5 ] || { [ "${BASH_VERSINFO[0]}" -eq 4 ] && [ "${BASH_VERSINFO[1]}" -ge 2 ]; }; then printf -v now '%(%s)T' -1; else now="$(date +%s)"; fi
+  case "$ts" in ''|*[!0-9]*) ;; *)
+    left=$(( (1800 - (now - ts)) / 60 ))
+    case "$op" in commit|push|commit+push) [ "$left" -ge 0 ] && [ "$((now - ts))" -le 1800 ] && OUT+=("✓ $op approved ${left}m") ;; esac ;;
+  esac
+fi
+
+# ⚙ Crew agents started in this session and not stopped: a record under agents/ with no result beside it.
+if [ -n "$BASE" ] && [ -d .claude/state/crew-model/agents ]; then
+  n=0
+  for a in .claude/state/crew-model/agents/*; do
+    [ -f "$a" ] || continue
+    case "$a" in *.claim|*.used) continue ;; esac
+    [ "$a" -nt "$BASE" ] || continue
+    [ -e ".claude/state/crew-model/results/${a##*/}" ] && continue
+    n=$((n + 1))
+  done
+  pl=s; [ "$n" -eq 1 ] && pl=""
+  [ "$n" -gt 0 ] && OUT+=("⚙ $n crew agent$pl")
+fi
+
+# 🔋 and ~$: Claude Code's own numbers, shown as they are.
+case "${PCT:-}" in ''|null|*[!0-9.]*) ;; *) OUT+=("🔋 ${PCT%%.*}%") ;; esac
+case "${COST:-}" in ''|null|*[!0-9.]*) ;; *)
+  printf -v c '%.2f' "$COST" 2>/dev/null && OUT+=("~\$$c") ;;
+esac
+
+[ "${#OUT[@]}" -gt 0 ] || exit 0
+line="${OUT[0]}"
+for p in "${OUT[@]:1}"; do line="$line · $p"; done
+printf '%s\n' "$line"
+exit 0

package/kit/eval/lib/version.sh

@@ -0,0 +1,41 @@
+# Sourced, not run. The ONE definition of how Crewforth reads and orders its own version numbers.
+#
+# An install's VERSION holds X.Y.Z, or X.Y.Z-rc.N when it came from a release candidate. An rc comes before its
+# final (3.2.0-rc.1 < 3.2.0), so someone who tried the rc is offered the final when it ships. Read by the update
+# check (hooks/session-update-check.sh), doctor and adopt.sh; each used to split on "." and read 3.2.0-rc.1 as 3.2.0.
+#
+# Builtins only: sourcing this costs no process, which matters in hooks on Git Bash.
+
+# The version an install may hold in its own VERSION file: X.Y.Z or X.Y.Z-rc.N, nothing else; printed, or rc 1.
+# A value off the network is not read with this: the update check holds that to X.Y.Z alone.
+crew_local_version(){
+  local v="${1:-}" base n
+  v="${v//[!0-9A-Za-z.-]/}"
+  base="${v%%-rc.*}"
+  case "$base" in
+    *[!0-9.]*|'')           return 1 ;;
+    [0-9]*.[0-9]*.[0-9]*.*) return 1 ;;
+    [0-9]*.[0-9]*.[0-9]*)   ;;
+    *)                      return 1 ;;
+  esac
+  if [ "$base" != "$v" ]; then
+    n="${v#"$base"-rc.}"
+    case "$n" in ''|*[!0-9]*) return 1 ;; esac
+  fi
+  printf '%s' "$v"
+}
+
+# vcmp(a, b): 1 when a is newer, -1 when older, 0 when the same. Prepended to an awk program:
+#   awk -v a="$X" -v b="$Y" "$CREW_VCMP_AWK"' BEGIN { exit !(vcmp(a, b) > 0) }'
+CREW_VCMP_AWK='
+function vrc(v) { return match(v, /-rc\.[0-9]+$/) ? substr(v, RSTART + 4) + 0 : -1 }
+function vcmp(a, b,   x, y, i, ra, rb) {
+  ra = vrc(a); rb = vrc(b); sub(/-.*/, "", a); sub(/-.*/, "", b)
+  split(a, x, "."); split(b, y, ".")
+  for (i = 1; i <= 3; i++) { if (x[i] + 0 > y[i] + 0) return 1; if (x[i] + 0 < y[i] + 0) return -1 }
+  if (ra == rb) return 0
+  if (ra < 0) return 1
+  if (rb < 0) return -1
+  return ra > rb ? 1 : -1
+}
+'