crewforth 3.5.0-rc.1 → 3.5.0-rc.2

package/CHANGELOG.md

@@ -34,6 +34,13 @@ versioning follows [SemVer](https://semver.org/).
 
 ### Added
 
+- **`/crew-todo` shows the plan as a to-do list under the status line.** The status line ends with the plan's count
+  (`📋 7/12`); the command opens a panel under it and closes it again: the plan's phases and tasks, done ones ticked,
+  open ones boxed, the phase and the task in work marked, cut to a window around the task in work (`CREW_TODO_LINES`).
+  It reads the plan's own boxes (`- [ ]`, `- [x]`, `- [~]` in work) under its headings and never writes the plan;
+  `spec-planning` now gives every task a box and tells whoever works the plan to tick it when its check passes.
+  `/crew-todo <file>` reads another plan, `/crew-todo show` prints the panel in the chat. The drawing is cached
+  until the plan changes, so a status line refresh starts no process for it.
 - **A compaction no longer loses what the user asked for.** The PreCompact snapshot keeps the user's first and last
   three prompts and the skills used in the session, and gives them back after the compaction, in the same session
   only; secrets and `<private>` text are left out. The `handoff` template carries the user's words, the dead ends
@@ -127,6 +134,11 @@ versioning follows [SemVer](https://semver.org/).
 - **Studio shows what a session it started has changed.** The strip above the conversation says how many files
   changed since the session started (lines added and removed) and how many new files git does not track yet,
   counted against the commit recorded at the start. It is read without git rewriting the index and kept in memory.
+- **Studio speaks Turkish.** The **TR** button in the top bar, beside the theme button, puts the panel in Turkish
+  and **EN** puts it back; English stays the default, and the choice is kept per browser. What Studio shows from
+  elsewhere (the conversation, agent and tool names, a reason the server gave) stays as it was written. The Studio
+  gate fails when a sentence on screen has no Turkish, when a translation is left over, or when the two disagree
+  on a `{slot}`.
 - **`/crew-doctor` names a linked worktree with no `.claude/settings.json`**, where a resumed session runs none of
   Crewforth's hooks. One Claude Code makes under `.claude/worktrees/` is not named: it still runs this checkout's.
 - **`npx crewforth remove` takes Crewforth out of a project.** By default it lists what it would change and changes
@@ -140,6 +152,11 @@ versioning follows [SemVer](https://semver.org/).
   A `CREW_` variable set in the environment that no Crewforth file reads (a typo) is named, and so is a switch that
   takes a whole number set to something else.
 
+- **Studio's summary box says what each kind of agent spent.** Open **Agents** and, as **Cost** does for models, it
+  lists one line per agent type (`Backend`, `Test ×2`, …) with its new tokens and estimated cost, the most spent
+  first; a type that ran more than once shows how many times. Without an agent to break down, the row still opens on
+  the token kinds.
+
 ### Changed
 
 - **`dependency-audit` asks which registry answers an internal name** (scope mappings, `--index-url` against
@@ -161,6 +178,11 @@ versioning follows [SemVer](https://semver.org/).
 - **Studio's Map spreads lines that share a side of a card**, so a module with three dependents shows three lines
   instead of one. Measured first on the crew-map test fixtures and Crewforth's own map: 48 line ends shared a pixel
   across 46 edges; now none do. Sideways lines between ends at two heights turn square instead of running slanted.
+- **Studio's graph uses both sides of a wide window.** The session stands in the middle: the agents that build
+  (backend, frontend, database, test, devops, performance) grow to its left and every other agent to its right, so
+  one tall column beside an empty half of the pane becomes two short ones. The side follows the agent's type, never
+  the count, so an agent that arrives moves nothing already drawn. A narrow window keeps the left-to-right tree, and
+  **Order** keeps its waves.
 - **Frontend work checks more of what users hit.** `a11y` separates criteria from conventions (a failed A/AA
   criterion is a finding, AAA or a 44 px target a recommendation), adds a skip link, flashing, an error summary and
   positive `tabindex`, a table of patterns to grep before finishing, and recipes for focus, forms and which
@@ -230,6 +252,16 @@ versioning follows [SemVer](https://semver.org/).
 
 ### Fixed
 
+- **A session no longer tells the user that a command is not installed when it only cannot see it.** The commands
+  marked user-only (`/crew-interview`, `/crew-approve`, `/crew-pr`…) are left out of the model's skill list, so a
+  session asked about `/crew-interview` answered that no such command existed, while the files were in
+  `.claude/skills`. The discipline now says so in one sentence and points at `ls .claude/skills`.
+- **An approval refused in a background session now says so.** Claude Code reports a session started with
+  `claude --bg`, or from the agent view, as unattended (`CLAUDE_CODE_SESSION_ATTENDED=0`) even when the user attaches
+  and types into it, so `/crew-approve` was refused with "started with -p, or by a program" and no way on. Measured on
+  2.1.319: a background session and `claude -p` both report 0, and a prompt started by a program in the background is
+  recorded as a human one, so the gate cannot tell them apart and stays closed. The refusal now names the background
+  case and the two ways on: a regular session, or the commit in the user's own terminal.
 - **`adopt` refuses a `settings.json` whose hook entries Claude Code would reject.** Claude Code ignores the whole
   file when one hook entry has the wrong shape, so merging Crewforth's hooks into it installed gates that never ran.
   adopt now names the entries and stops the merge, and the merged result is checked the same way before it is

package/README.md

@@ -32,7 +32,7 @@ Then open Claude Code and run `/crew-doctor` to confirm the setup. Requires bash
 
 - **14 specialist agents**, from `crew-planner` to `crew-commit-agent`, each owning one domain.
 - **40 skills** holding the method: testing, migrations, API contracts, observability, accessibility, deployment.
-- **17 commands**, each started with its `/crew-…` name: `/crew-plan`, `/crew-review`, `/crew-ship`, `/crew-handoff`, `/crew-brainstorm`, `/crew-update`, `/crew-doctor`, `/crew-gates`, `/crew-skill`, `/crew-studio`, `/crew-approve`, `/crew-loosen`, `/crew-allow-verify`, `/crew-map`, `/crew-audit`, `/crew-interview`, `/crew-pr`.
+- **18 commands**, each started with its `/crew-…` name: `/crew-plan`, `/crew-review`, `/crew-ship`, `/crew-handoff`, `/crew-brainstorm`, `/crew-update`, `/crew-doctor`, `/crew-gates`, `/crew-skill`, `/crew-studio`, `/crew-approve`, `/crew-loosen`, `/crew-allow-verify`, `/crew-map`, `/crew-audit`, `/crew-interview`, `/crew-pr`, `/crew-todo`.
 - In `auto` mode a commit or a push waits for you: type `/crew-approve` and what was just refused is approved, tied to what is staged.
 - A stopped destructive command says what it would have touched; a review starts from a deterministic pre-pass, and `crew-refuter` tries to refute each finding that blocks.
 - **Organisation presets.** `npx crewforth init --preset strict` (or `solo`, or your own JSON file) carries critical paths, model floors and verify commands to every project.

package/VERSION

@@ -1 +1 @@
-3.5.0-rc.1
+3.5.0-rc.2

package/kit/CLAUDE.md

@@ -46,7 +46,7 @@ What the user sees → **crew-frontend-expert** · server behaviour → **crew-b
 **crew-privacy-agent** (personal data) · **crew-test-expert** · **crew-performance-expert** · docs/legal/store
 text → **crew-docs-agent** · what to build →
 **crew-planner** · unknown cause → **general-purpose** + `systematic-debugging`. Two domains → delegate in
-sequence. All are installed: "no owner" is an `ls`.
+sequence. All are installed: "no owner" is an `ls`. The user-only commands (`/crew-interview`, `/crew-approve`…) are missing from your skill list by design, not uninstalled: `ls .claude/skills`.
 
 1. **Diagnose, then plan** — unknown cause → `systematic-debugging` first; unclear scope → **crew-planner** (`/crew-plan`).
 2. **Produce** — the domain owner above.

package/kit/eval/lib/statusline.sh

@@ -12,11 +12,14 @@
 #   ⚙   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
+#   📋  the plan's count of done tasks (docs/PLAN.md, todo.sh); with the panel open (/crew-todo), the panel itself is
+#       drawn under the line instead: phases and tasks, ✓ done, ☐ open, ▸ the phase and the task in work
 #
 # 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.
+# gate log), and on bash older than 4.2 one date; the rest is builtins. No git, no jq, no python. The plan panel
+# adds one awk only when the plan (or its drawing code) changed since the last line; otherwise it reads its cache.
 set -u
 _here="${BASH_SOURCE%[/\\]*}"; [ "$_here" = "${BASH_SOURCE}" ] && _here=.
 
@@ -93,8 +96,22 @@ 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"
+# 📋 The plan: its count on the line, or with the panel open (/crew-todo), the panel under it.
+PANEL=""
+if [ -d .claude ] && [ -f "$_here/todo.sh" ]; then
+  . "$_here/todo.sh"
+  if [ -e .claude/state/todo/open ]; then
+    col=1; [ -n "${NO_COLOR:-}" ] && col=0
+    crew_todo_read "$col"; PANEL="$_CREW_TODO_PANEL"
+  elif [ -f docs/PLAN.md ] || [ -s .claude/state/todo/path ]; then
+    crew_todo_read 1; [ -n "$_CREW_TODO_HINT" ] && OUT+=("$_CREW_TODO_HINT")
+  fi
+fi
+
+if [ "${#OUT[@]}" -gt 0 ]; then
+  line="${OUT[0]}"
+  for p in "${OUT[@]:1}"; do line="$line · $p"; done
+  printf '%s\n' "$line"
+fi
+[ -n "$PANEL" ] && printf '%s\n' "$PANEL"
 exit 0

package/kit/eval/lib/todo.awk

@@ -0,0 +1,167 @@
+# todo.awk — reads a plan (docs/PLAN.md by default) and draws its to-do panel: the phases and the tasks, a tick on
+# what is done, an empty box on what is not, and the phase and the task in work marked.
+#
+#   LC_ALL=C awk -v color=1 -v maxl=14 -v name=docs/PLAN.md -f todo.awk docs/PLAN.md
+#
+# Run it under LC_ALL=C: lengths are counted in bytes, so a cut never depends on the locale (and is mended so it never
+# splits a UTF-8 character).
+#
+# What it reads, and nothing else:
+#   a task      a list item whose text starts with a box:  `- [ ] …`  `- [x] …`  `1. [ ] …`  (at the margin)
+#               [ ] open · [x] done · [~] or [>] in work. A box indented under a task is a sub-step, not a task.
+#   a phase     a heading (## or deeper) with at least one task under it.
+#   the scope   when the plan has a `## Tasks` heading (or Görevler, İşler, To-do), only what is under it; else the
+#               whole file. An `Acceptance criteria` section is never a phase: its boxes are counted as AC n/m.
+#   code blocks are skipped (a template quoted in the plan is not the plan).
+# The task in work is the first one marked [~]/[>]; with none marked, the first open one. Its phase is the active one.
+#
+# Output: line 1 the short count for the status line ("📋 7/12"), or nothing when the plan has no task; then the panel.
+# It decides nothing and changes nothing.
+BEGIN {
+  if (maxl + 0 < 6) maxl = 14
+  wmax = 64
+  E = sprintf("%c", 27)
+  if (color + 0) { DIM = E "[2m"; BOLD = E "[1m"; ACT = E "[1;36m"; RST = E "[0m" } else { DIM = BOLD = ACT = RST = "" }
+  for (i = 128; i < 192; i++) CONT = CONT sprintf("%c", i)
+  for (i = 192; i < 256; i++) LEAD = LEAD sprintf("%c", i)
+  TICK = "✓"; BOX = "☐"; HERE = "▸"
+  nev = 0; fence = ""
+}
+
+# A fenced code block: skipped whole.
+/^[ ]*(```|~~~)/ {
+  f = $0; sub(/^[ ]*/, "", f); f = substr(f, 1, 3)
+  if (fence == "") fence = f; else if (f == fence) fence = ""
+  next
+}
+fence != "" { next }
+
+/^#+[ \t]/ {
+  t = $0; match(t, /^#+/); lv = RLENGTH
+  t = substr(t, lv + 1); sub(/^[ \t]+/, "", t); sub(/[ \t]+#*[ \t]*$/, "", t); sub(/\r$/, "", t)
+  nev++; EV[nev] = "H"; LV[nev] = lv; TX[nev] = t
+  next
+}
+
+{
+  line = $0; sub(/\r$/, "", line)
+  match(line, /^ */); ind = RLENGTH
+  if (ind > 1) next
+  rest = substr(line, ind + 1)
+  if (match(rest, /^[-*+][ \t]+\[[ xX~>]\][ \t]+/)) num = ""
+  else if (match(rest, /^[0-9]+[.)][ \t]+\[[ xX~>]\][ \t]+/)) { num = rest; sub(/[.)].*/, "", num) }
+  else next
+  head = substr(rest, 1, RLENGTH); txt = substr(rest, RLENGTH + 1)
+  b = head; sub(/^[^[]*\[/, "", b); b = substr(b, 1, 1)
+  st = (b == "x" || b == "X") ? "d" : (b == "~" || b == ">") ? "w" : "o"
+  # The task's name is what comes before its first " — " (the plan's fields: satisfies, size, risk…).
+  k = index(txt, " — "); if (k > 0) txt = substr(txt, 1, k - 1)
+  sub(/[ \t]+$/, "", txt)
+  if (num != "") txt = num ". " txt
+  nev++; EV[nev] = "I"; ST[nev] = st; TX[nev] = txt
+}
+
+function isac(t) { return t ~ /^([Aa]cceptance [Cc]riteria|[Kk]abul [Kk]riter)/ }
+function istasks(t) { return t ~ /^([Tt]asks|TASKS|[Gg]örevler|GÖREVLER|[İi]şler|İŞLER|[Tt]o-?[Dd]o|TODO)([^A-Za-z]|$)/ }
+# A cut in bytes that never leaves half a UTF-8 character: drop trailing continuation bytes, then their lead byte.
+function cut(s, n,   r) {
+  if (length(s) <= n) return s
+  r = substr(s, 1, n - 1)
+  while (length(r) && index(CONT, substr(r, length(r), 1))) r = substr(r, 1, length(r) - 1)
+  if (length(r) && index(LEAD, substr(r, length(r), 1))) r = substr(r, 1, length(r) - 1)
+  return r "…"
+}
+function mark(st) { return st == "d" ? TICK : st == "w" ? HERE : BOX }
+function out(s) { L[++nl] = s }
+
+END {
+  # The scope: under a Tasks heading when the plan has one.
+  s0 = 1; s1 = nev; base = 1; title = ""
+  for (i = 1; i <= nev; i++) if (EV[i] == "H" && LV[i] == 1 && title == "") title = TX[i]
+  for (i = 1; i <= nev; i++) if (EV[i] == "H" && LV[i] >= 2 && istasks(TX[i])) {
+    s0 = i + 1; s1 = nev; base = LV[i]
+    for (j = i + 1; j <= nev; j++) if (EV[j] == "H" && LV[j] <= LV[i]) { s1 = j - 1; break }
+    break
+  }
+  # Acceptance criteria, wherever they are: counted, never shown as a phase.
+  ac = 0; acd = 0; inac = 0
+  for (i = 1; i <= nev; i++) {
+    if (EV[i] == "H") { if (inac && LV[i] <= aclv) inac = 0; if (isac(TX[i])) { inac = 1; aclv = LV[i] } }
+    else if (inac) { ac++; if (ST[i] == "d") acd++ }
+  }
+  # Phases and tasks inside the scope. A heading opens a phase; tasks before any heading sit in an unnamed one.
+  np = 0; cur = 0; skip = 0; skiplv = 0; nt = 0; done = 0
+  for (i = s0; i <= s1; i++) {
+    if (EV[i] == "H") {
+      if (skip && LV[i] <= skiplv) skip = 0
+      if (LV[i] <= base && base > 1) continue
+      if (isac(TX[i]) || (LV[i] == 1 && base == 1)) { if (isac(TX[i])) { skip = 1; skiplv = LV[i] }; cur = 0; continue }
+      if (skip) continue
+      np++; PN[np] = TX[i]; PT[np] = 0; PD[np] = 0; cur = np
+      continue
+    }
+    if (skip) continue
+    if (cur == 0) { np++; PN[np] = ""; PT[np] = 0; PD[np] = 0; cur = np }
+    PT[cur]++; nt++; T[cur, PT[cur]] = i
+    if (ST[i] == "d") { PD[cur]++; done++ }
+  }
+  if (nt == 0) { print ""; print "📋 " cut(name != "" ? name : FILENAME, wmax) ": no task with a box yet ( - [ ] task · - [x] done · - [~] in work )"; exit }
+
+  # The task in work: the first marked [~]/[>], else the first open one.
+  ap = 0; at = 0
+  for (p = 1; p <= np && !ap; p++) for (t = 1; t <= PT[p]; t++) if (ST[T[p, t]] == "w") { ap = p; at = t; break }
+  for (p = 1; p <= np && !ap; p++) for (t = 1; t <= PT[p]; t++) if (ST[T[p, t]] == "o") { ap = p; at = t; break }
+
+  # Phases with no task are not phases.
+  m = 0
+  for (p = 1; p <= np; p++) if (PT[p] > 0) { m++; PN[m] = PN[p]; PT[m] = PT[p]; PD[m] = PD[p]; for (t = 1; t <= PT[p]; t++) T[m, t] = T[p, t]; if (p == ap) ap = m }
+  np = m
+  phased = (np > 1 || PN[1] != "")
+
+  print "📋 " done "/" nt
+  hd = BOLD "📋 " (title != "" ? cut(title, wmax) : "Plan") RST " · " done "/" nt " done"
+  if (phased && ap) hd = hd " · phase " ap "/" np
+  if (ac) hd = hd " · AC " acd "/" ac
+  if (!ap) hd = hd " · all done"
+  out(hd)
+
+  # Which phases get a line: all of them when they fit, else the active one with its neighbours and a count of the rest.
+  budget = maxl - 1
+  pa = 1; pb = np
+  if (phased && np > budget - 3) {
+    c = (ap ? ap : np); pa = c - 1; if (pa < 1) pa = 1; pb = pa + (budget - 6); if (pb > np) pb = np
+    if (pb - pa < budget - 6) { pa = pb - (budget - 6); if (pa < 1) pa = 1 }
+  }
+  # The tasks of the active phase (or of the plan, when it has no phases) get what is left.
+  room = budget - (phased ? (pb - pa + 1) + (pa > 1) + (pb < np) : 0)
+  if (room < 3) room = 3
+
+  if (phased && pa > 1) { k = 0; for (p = 1; p < pa; p++) k += (PD[p] == PT[p]); out(DIM "… " (pa - 1) " phase" (pa > 2 ? "s" : "") " before (" k " done)" RST) }
+  for (p = (phased ? pa : 1); p <= (phased ? pb : 1); p++) {
+    if (phased) {
+      nm = (PN[p] != "" ? cut(PN[p], wmax) : "(no phase)") "  " PD[p] "/" PT[p]
+      if (p == ap) out(ACT HERE " " nm RST)
+      else if (PD[p] == PT[p]) out(DIM TICK " " nm RST)
+      else out(BOX " " nm)
+    }
+    if (p != ap && !(phased == 0 && !ap)) continue
+    # A window over the tasks that keeps the one in work in sight: one before it, the rest after.
+    n = PT[p]; lo = 1; hi = n
+    if (n > room) {
+      lo = (at > 1 ? at - 1 : 1)
+      hi = (lo == 1) ? room - 1 : lo + room - 3
+      if (hi >= n) { hi = n; lo = n - room + 2; if (lo < 1) lo = 1 }
+    }
+    ind = (phased ? "   " : "")
+    if (lo > 1) out(ind DIM "… " (lo - 1) " above" RST)
+    for (t = lo; t <= hi; t++) {
+      e = T[p, t]; s = mark(ST[e]) " " cut(TX[e], wmax)
+      if (t == at && p == ap) out(ind ACT HERE " " cut(TX[e], wmax) RST)
+      else if (ST[e] == "d") out(ind DIM s RST)
+      else out(ind s)
+    }
+    if (hi < n) out(ind DIM "… " (n - hi) " more" RST)
+  }
+  if (phased && pb < np) { k = 0; for (p = pb + 1; p <= np; p++) k += PT[p] - PD[p]; out(BOX " … " (np - pb) " more phase" (np - pb > 1 ? "s" : "") " (" k " open)") }
+  for (i = 1; i <= nl; i++) print L[i]
+}

package/kit/eval/lib/todo.sh

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# todo.sh — the plan's to-do panel: what is done (✓), what is not (☐), and the phase and the task in work (▸), read
+# from the plan file (docs/PLAN.md unless /crew-todo named another). The drawing is todo.awk; this file keeps the
+# panel's two bits of state and serves both its readers.
+#
+#   bash .claude/eval/lib/todo.sh             open the panel if it is closed, close it if it is open
+#   bash .claude/eval/lib/todo.sh on [FILE]   open it (and read FILE from now on)        · off: close it
+#   bash .claude/eval/lib/todo.sh FILE        the same as `on FILE`
+#   bash .claude/eval/lib/todo.sh show [FILE] print the panel here, once (no status line needed)
+#   bash .claude/eval/lib/todo.sh status      one line: open or closed, which file, how far
+#
+# The status line sources this file and calls crew_todo_read: open, the panel is drawn under the line; closed, the
+# line carries only the count ("📋 7/12"). Nothing here decides or blocks anything, and the plan is never written:
+# the plan's own boxes are the record ([ ] open · [x] done · [~] in work), ticked by whoever does the work.
+#
+# State, per project, under .claude/state/todo/: `open` (present = the panel is open) and `path` (the plan file, when
+# it is not docs/PLAN.md); `view` is a cache of the drawing, made again only when the plan, todo.awk or the settings
+# changed, so a status line refresh costs no process at all while the plan stands still.
+# Settings: CREW_TODO_LINES (the panel's height, default 14) · NO_COLOR (set: no colours).
+
+_CREW_TODO_LIB="${BASH_SOURCE%[/\\]*}"; [ "$_CREW_TODO_LIB" = "${BASH_SOURCE}" ] && _CREW_TODO_LIB=.
+_CREW_TODO_DIR=.claude/state/todo
+
+# The plan file this project's panel reads: _CREW_TODO_PLAN. Run from the project root.
+crew_todo_plan(){
+  _CREW_TODO_PLAN=""
+  [ -s "$_CREW_TODO_DIR/path" ] && { IFS= read -r _CREW_TODO_PLAN < "$_CREW_TODO_DIR/path"; _CREW_TODO_PLAN="${_CREW_TODO_PLAN%$'\r'}"; }
+  [ -n "$_CREW_TODO_PLAN" ] || _CREW_TODO_PLAN=docs/PLAN.md
+}
+
+# The drawing: _CREW_TODO_HINT (the count, "" when the plan has no task) and _CREW_TODO_PANEL (its lines, joined with
+# newlines). $1 = color (1/0). From the cache when the cache still matches; one awk when it does not.
+crew_todo_read(){
+  local col="${1:-1}" maxl="${CREW_TODO_LINES:-14}" v="$_CREW_TODO_DIR/view" key l first=1
+  _CREW_TODO_HINT=""; _CREW_TODO_PANEL=""
+  case "$maxl" in ''|*[!0-9]*) maxl=14 ;; esac
+  crew_todo_plan
+  if [ ! -f "$_CREW_TODO_PLAN" ]; then
+    _CREW_TODO_PANEL="📋 no plan at $_CREW_TODO_PLAN yet: /crew-plan writes one, /crew-todo <file> reads another"
+    return 0
+  fi
+  key="k=$col/$maxl/$_CREW_TODO_PLAN"
+  # The cache holds when it is newer than the plan and than the drawing code, and was drawn with these settings.
+  if [ -f "$v" ] && [ "$v" -nt "$_CREW_TODO_PLAN" ] && ! [ "$_CREW_TODO_LIB/todo.awk" -nt "$v" ]; then
+    IFS= read -r l < "$v" 2>/dev/null || l=""
+    [ "$l" = "$key" ] || l=""
+  else l=""; fi
+  if [ -z "$l" ]; then
+    [ -d "$_CREW_TODO_DIR" ] || mkdir -p "$_CREW_TODO_DIR" 2>/dev/null
+    { printf '%s\n' "$key"; LC_ALL=C awk -v color="$col" -v maxl="$maxl" -v name="$_CREW_TODO_PLAN" -f "$_CREW_TODO_LIB/todo.awk" "$_CREW_TODO_PLAN" 2>/dev/null; } > "$v" 2>/dev/null || return 0
+  fi
+  {
+    IFS= read -r l                                     # the key
+    IFS= read -r _CREW_TODO_HINT
+    while IFS= read -r l; do
+      if [ "$first" = 1 ]; then _CREW_TODO_PANEL="$l"; first=0; else _CREW_TODO_PANEL="$_CREW_TODO_PANEL"$'\n'"$l"; fi
+    done
+  } < "$v"
+  return 0
+}
+
+# Sourced: the functions only.
+[ "${BASH_SOURCE[0]}" = "$0" ] || return 0
+
+set -u
+[ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -d "$CLAUDE_PROJECT_DIR/.claude" ] && cd "$CLAUDE_PROJECT_DIR" 2>/dev/null
+if [ ! -d .claude ]; then echo "todo: no .claude/ here: run it from the project root of a Crewforth install" >&2; exit 1; fi
+
+cmd="${1:-toggle}"; file="${2:-}"
+case "$cmd" in on|off|toggle|show|status) ;; -h|--help) sed -n '2,12p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+  -*) echo "todo: unknown option $cmd (on · off · show · status · a plan file)" >&2; exit 2 ;;
+  *) file="$cmd"; cmd=on ;;
+esac
+case "$file" in *$'\n'*|*$'\r'*) echo "todo: a file name with a line break is not read" >&2; exit 2 ;; esac
+
+if [ "$cmd" = show ]; then
+  # Drawn here, not from the cache, and coloured only on a terminal: this may go to a chat that does not take colour.
+  crew_todo_plan; [ -n "$file" ] && _CREW_TODO_PLAN="$file"
+  if [ ! -f "$_CREW_TODO_PLAN" ]; then echo "📋 no plan at $_CREW_TODO_PLAN yet: /crew-plan writes one"; exit 0; fi
+  c=0; [ -t 1 ] && [ -z "${NO_COLOR:-}" ] && c=1
+  LC_ALL=C awk -v color="$c" -v maxl=999 -v name="$_CREW_TODO_PLAN" -f "$_CREW_TODO_LIB/todo.awk" "$_CREW_TODO_PLAN" | sed 1d
+  exit 0
+fi
+
+mkdir -p "$_CREW_TODO_DIR" 2>/dev/null || { echo "todo: cannot write $_CREW_TODO_DIR" >&2; exit 1; }
+if [ -n "$file" ]; then
+  [ -f "$file" ] || echo "todo: $file does not exist yet; the panel will read it once it does"
+  if [ "$file" = docs/PLAN.md ]; then rm -f "$_CREW_TODO_DIR/path"; else printf '%s\n' "$file" > "$_CREW_TODO_DIR/path"; fi
+fi
+[ "$cmd" = toggle ] && { if [ -e "$_CREW_TODO_DIR/open" ]; then cmd=off; else cmd=on; fi; }
+case "$cmd" in
+  on) : > "$_CREW_TODO_DIR/open" ;;
+  off) rm -f "$_CREW_TODO_DIR/open" ;;
+esac
+
+crew_todo_read 0
+st=closed; [ -e "$_CREW_TODO_DIR/open" ] && st=open
+how=""
+if [ -n "$_CREW_TODO_HINT" ]; then
+  how="${_CREW_TODO_HINT#📋 } done"
+  inwork="$(printf '%s\n' "$_CREW_TODO_PANEL" | grep '▸ ' | tail -n 1 | sed 's/^ *▸ //')"
+  [ -n "$inwork" ] && how="$how, in work: $inwork"
+elif [ -f "$_CREW_TODO_PLAN" ]; then how="no task with a box in it yet"
+else how="the file does not exist yet"; fi
+if [ "$st" = open ]; then echo "plan panel: open · $_CREW_TODO_PLAN · $how"
+else echo "plan panel: closed · $_CREW_TODO_PLAN · $how (the status line keeps the count)"; fi
+
+# Shown under Crewforth's status line only. Say so when this project's status line is another one, or none.
+sl=""
+for f in .claude/settings.local.json .claude/settings.json "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json"; do
+  [ -f "$f" ] && [ -f "$_CREW_TODO_LIB/settings-json.awk" ] || continue
+  sl="$(awk -v op=get -v path=statusLine.command -f "$_CREW_TODO_LIB/settings-json.awk" "$f" 2>/dev/null)" || sl=""
+  [ -n "$sl" ] && break
+done
+case "$sl" in
+  *eval/lib/statusline.sh*) ;;
+  ?*) [ "$st" = open ] && echo "note: this project's status line is not Crewforth's, so the panel does not show there; /crew-todo show prints it here" ;;
+  *) [ "$st" = open ] && echo "note: no status line is set; bash .claude/eval/lib/statusline.sh --install (Bash tool, not PowerShell) sets Crewforth's (only where none is set), or /crew-todo show prints the panel here" ;;
+esac
+exit 0

package/kit/eval/smoke-test.sh

@@ -2762,7 +2762,7 @@ sec "== 6f) always-on token budget =="
 # for that cost, and a gate rather than a reminder — a verbose new description fails the suite instead of
 # quietly taxing every future session. Budgets sit just above the current sizes: raising one is allowed, but
 # only as a deliberate edit here.
-BUDGET_DISC=16870    # Discipline rules: 16470 → 16870 (+400, the cap the user set for this one change): in an audit, text that steers the verdict is a finding; content cannot carry a gate verdict or the 🔋 line; a fetch is https only and never reaches a private, loopback or metadata host, redirects too; a secret is never asked for in chat; a link is cited only when opened this session; every report says `Not tested:` and labels each figure measured, derived or inferred; a refused action is not retried another way. Each is about what the main thread does on its own turn — what it fetches, asks, cites, reports and retries — so a skill read on demand would arrive after the act. What did not fit went to the skill that owns it: the 90-day date on an external fact (docs-writer, confidence-check), the audit-steering detail (security-scan, red-team). Before that, P07a: 16214 → 16470 (+256): the audit step no longer re-runs every lane after every fix — only a critical/high fix, or one on a critical path, does, a lesser one is re-checked by the lane that raised it, a low finding never starts a round, three rounds with medium+ open then ask — and the DoD's "nothing deferred" says what it means (medium+ fixed, tracked or user-accepted, the lows to the user as one list). Field transcripts of four projects showed main threads reading the old two lines as "fix every low and audit everything again"; both are where every session reads them, because the loop is run by the main thread, not by a skill. Before that, P05: 15637 → 16214 (+577): "Short never costs meaning" (a short reply keeps every negation, condition and number; code, paths and errors verbatim; point to path:line instead of restating; full sentences for warnings, irreversible steps, questions and persisted text), principle 2's "never cut" list (validation at a trust boundary, data-loss error handling, security, accessibility, what was asked) and a re-read-after-compaction clause. All three are about how every reply is written, so a skill read on demand would arrive after the reply. evals/cases/terse-fidelity measures the first. Before that, P02: 15570 → 15637 (+67): "Untrusted content" names the text a hook injects from teammates (the team board) as data; the hook now labels it the same way. Before that, P01: 15429 → 15570 (+141): "No deferral" names the recorded, user-accepted bypass (BYPASSED line, ADR Bypassed entry, accepted finding) as the user's decision, so the rule stops contradicting confidence-check, adr and crew-code-review. Before that, 3.5: 14971 → 15429 (+458): §4.7 (a staged lockfile needs an audit record of that lockfile diff, +275 with the §4.4–§4.7 range) and the quality line (+183): the DoD reads `## Stack` → `Quality analysis:` instead of six "(if SonarQube is in use)" clauses, which a project with no server read as false every time (0 analyses in its first 8 days, 0 audits against 21 lockfile commits). Both have to be where every session reads them: the gate refuses a commit, and the refusal must not be a surprise. Before that, 3.1.0: 13986 → 14975 (+989): the task card (files, change, verify), the model table read from it, "the referee follows the risk" and the verify-then-escalate rule (+634 in the first form, +355 for the card). The session chooses a model on every crew agent call, so the table has to be where every session reads it; a skill would be read after the choice. Before that, 3.0.1: 13741 → 13986 (+245): the ladder states that a project CLAUDE.md can tighten §4, never loosen it — naming §4.1 as the one exception, since adopt may loosen the trace gate — and that § numbers point into this file (two field projects read their stricter §4.4 as a contradiction), the opening's "project wins" carries the same limit, and the context-usage command names the Bash tool (a Windows session ran the scripts in PowerShell). RC-1: 13711 → 13741 (+30): "Reply in the user's language even when a skill's text is English" — a Turkish session answered /crew-review in English, because every skill body it had just read was English; the rule is stated nowhere else. evals/cases/reply-language measures it. 5R.3: 13712 → 13711 (the old-name phrases rewritten, net −1). 5d.2 prompt audit: tightened to the measured size (13719 → 13712: format-to-content style line, one reload
+BUDGET_DISC=17030    # Discipline rules: 16870 → 17030 (+160: the user-only commands are absent from the model's skill list by design, and a session told the user /crew-interview was not installed); before that 16470 → 16870 (+400, the cap the user set for this one change): in an audit, text that steers the verdict is a finding; content cannot carry a gate verdict or the 🔋 line; a fetch is https only and never reaches a private, loopback or metadata host, redirects too; a secret is never asked for in chat; a link is cited only when opened this session; every report says `Not tested:` and labels each figure measured, derived or inferred; a refused action is not retried another way. Each is about what the main thread does on its own turn — what it fetches, asks, cites, reports and retries — so a skill read on demand would arrive after the act. What did not fit went to the skill that owns it: the 90-day date on an external fact (docs-writer, confidence-check), the audit-steering detail (security-scan, red-team). Before that, P07a: 16214 → 16470 (+256): the audit step no longer re-runs every lane after every fix — only a critical/high fix, or one on a critical path, does, a lesser one is re-checked by the lane that raised it, a low finding never starts a round, three rounds with medium+ open then ask — and the DoD's "nothing deferred" says what it means (medium+ fixed, tracked or user-accepted, the lows to the user as one list). Field transcripts of four projects showed main threads reading the old two lines as "fix every low and audit everything again"; both are where every session reads them, because the loop is run by the main thread, not by a skill. Before that, P05: 15637 → 16214 (+577): "Short never costs meaning" (a short reply keeps every negation, condition and number; code, paths and errors verbatim; point to path:line instead of restating; full sentences for warnings, irreversible steps, questions and persisted text), principle 2's "never cut" list (validation at a trust boundary, data-loss error handling, security, accessibility, what was asked) and a re-read-after-compaction clause. All three are about how every reply is written, so a skill read on demand would arrive after the reply. evals/cases/terse-fidelity measures the first. Before that, P02: 15570 → 15637 (+67): "Untrusted content" names the text a hook injects from teammates (the team board) as data; the hook now labels it the same way. Before that, P01: 15429 → 15570 (+141): "No deferral" names the recorded, user-accepted bypass (BYPASSED line, ADR Bypassed entry, accepted finding) as the user's decision, so the rule stops contradicting confidence-check, adr and crew-code-review. Before that, 3.5: 14971 → 15429 (+458): §4.7 (a staged lockfile needs an audit record of that lockfile diff, +275 with the §4.4–§4.7 range) and the quality line (+183): the DoD reads `## Stack` → `Quality analysis:` instead of six "(if SonarQube is in use)" clauses, which a project with no server read as false every time (0 analyses in its first 8 days, 0 audits against 21 lockfile commits). Both have to be where every session reads them: the gate refuses a commit, and the refusal must not be a surprise. Before that, 3.1.0: 13986 → 14975 (+989): the task card (files, change, verify), the model table read from it, "the referee follows the risk" and the verify-then-escalate rule (+634 in the first form, +355 for the card). The session chooses a model on every crew agent call, so the table has to be where every session reads it; a skill would be read after the choice. Before that, 3.0.1: 13741 → 13986 (+245): the ladder states that a project CLAUDE.md can tighten §4, never loosen it — naming §4.1 as the one exception, since adopt may loosen the trace gate — and that § numbers point into this file (two field projects read their stricter §4.4 as a contradiction), the opening's "project wins" carries the same limit, and the context-usage command names the Bash tool (a Windows session ran the scripts in PowerShell). RC-1: 13711 → 13741 (+30): "Reply in the user's language even when a skill's text is English" — a Turkish session answered /crew-review in English, because every skill body it had just read was English; the rule is stated nowhere else. evals/cases/reply-language measures it. 5R.3: 13712 → 13711 (the old-name phrases rewritten, net −1). 5d.2 prompt audit: tightened to the measured size (13719 → 13712: format-to-content style line, one reload
                      # answer, the orphaned background-warning line removed). Before that: 3.0 rename (suffix → crew- prefix): +23 B (23 occurrences), not content — measured 13696 → 13719.
                      # DISCIPLINE.md (the discipline half of CLAUDE.md); before 3.0 the ceiling was 13700, currently 13601. (2026-09-18, a second
                      # +100 B on top of the raise below, and the whole of it went into ONE sentence of §4.6: a commit
@@ -13415,9 +13415,67 @@ JSON
   _g="$(printf '{"a":{"b":1},"c":"x y"}' | awk -v op=gets -v 'path=a.b|nope|c' -f "$ROOT/eval/lib/settings-json.awk" - 2>&1)"
   [ "$_g" = "1"$'\t\t'"\"x y\"" ] && pass "settings-json.awk gets: several paths in one read, tab-separated, an absent one empty" \
     || fail "settings-json.awk gets printed '$_g'"
+  # The plan's to-do panel (todo.sh, todo.awk): the count on the line while closed, the panel under it while open,
+  # drawn from the plan's own boxes, and read from its cache until the plan changes.
+  if [ -f "$ROOT/eval/lib/todo.sh" ]; then
+    mkdir -p "$_sl/q/.claude" "$_sl/q/docs"
+    cat > "$_sl/q/docs/PLAN.md" <<'PLAN'
+# Export — Plan
+## Acceptance criteria
+- [x] AC-1: exports — proven by: e2e
+- [ ] AC-2: on Safari — proven by: manual
+## Tasks (order)
+Progress: tick a task [x] when its check passes, mark the one in work [~].
+### Phase 1 — Parser
+1. [x] Read the file — satisfies: AC-1 — size: S
+2. [x] Count the boxes — satisfies: AC-1 — size: S
+### Phase 2 — Panel
+3. [x] Draw the lines — satisfies: AC-2
+4. [ ] Wire the toggle — satisfies: AC-2
+   - [ ] a sub-step, not a task
+5. [ ] Cache the drawing
+```
+- [ ] quoted in a code block, not a task
+```
+### Phase 3 — Docs
+- [ ] README
+## Not covered by tests
+- [ ] outside the Tasks section, not a task
+PLAN
+    _tj='{"session_id":"sl2","context_window":{"used_percentage":12},"cost":{"total_cost_usd":0.5},"workspace":{"project_dir":"'"$_sl/q"'"}}'
+    _t(){ printf '%s' "$_tj" | (cd "$_sl" && env NO_COLOR=1 bash "$SLS") 2>&1; }
+    # A second between the plan and its first drawing: bash 3.2 (macOS) compares times in whole seconds, and a cache
+    # drawn in the plan's own second is not newer than it, so it is drawn again (right, but not what (3) reads).
+    sleep 1
+    _to1="$(_t)"
+    _tt="$(cd "$_sl/q" && env -u CLAUDE_PROJECT_DIR bash "$ROOT/eval/lib/todo.sh" 2>&1 | head -n 1)"
+    _to2="$(_t)"
+    _want2="🔋 12% · ~\$0.50
+📋 Export — Plan · 3/6 done · phase 2/3 · AC 1/2
+✓ Phase 1 — Parser  2/2
+▸ Phase 2 — Panel  1/3
+   ✓ 3. Draw the lines
+   ▸ 4. Wire the toggle
+   ☐ 5. Cache the drawing
+☐ Phase 3 — Docs  0/1"
+    # The cache is what a refresh reads: a planted line shows, until the plan changes and the drawing is made again.
+    _tv="$_sl/q/.claude/state/todo/view"; { IFS= read -r _tk < "$_tv"; printf '%s\n%s\n%s\n' "$_tk" '📋 9/9' 'FROM THE CACHE'; } > "$_tv.n" 2>/dev/null && mv "$_tv.n" "$_tv"
+    _to3="$(_t)"
+    sleep 1; sed 's/^4\. \[ \]/4. [x]/' "$_sl/q/docs/PLAN.md" > "$_sl/q/p.n" && mv "$_sl/q/p.n" "$_sl/q/docs/PLAN.md"
+    _to4="$(_t)"
+    (cd "$_sl/q" && env -u CLAUDE_PROJECT_DIR bash "$ROOT/eval/lib/todo.sh" off >/dev/null 2>&1)
+    _to5="$(_t)"
+    [ "$_to1" = "🔋 12% · ~\$0.50 · 📋 3/6" ] && [ "$_tt" = "plan panel: open · docs/PLAN.md · 3/6 done, in work: 4. Wire the toggle" ] \
+      && [ "$_to2" = "$_want2" ] && [ "$_to3" = "🔋 12% · ~\$0.50"$'\n'"FROM THE CACHE" ] \
+      && case "$_to4" in *"4/6 done"*"▸ 5. Cache the drawing"*) true ;; *) false ;; esac && [ "$_to5" = "🔋 12% · ~\$0.50 · 📋 4/6" ] \
+      && pass "plan panel: the count on the line while closed; open, the phases with the one in work opened, done ticked, open boxed, the task in work marked (no sub-step, no quoted box, nothing outside Tasks); read from its cache until the plan changes; closed again" \
+      || fail "plan panel: closed='$_to1' · toggle='$_tt' · open='$_to2' · cached='$_to3' · after an edit='$_to4' · closed again='$_to5'"
+  else
+    skip scope "plan panel checks skipped (this project has no eval/lib/todo.sh)"
+  fi
   rm -rf "$_sl"
 else
-  skip scope "status line checks skipped (this project has no eval/lib/statusline.sh)" 3
+  skip scope "status line checks skipped (this project has no eval/lib/statusline.sh)" 4
 fi
 
 STAR="$ROOT/eval/lib/star.sh"

package/kit/hooks/prompt-approval.sh

@@ -606,7 +606,7 @@ _crew_q_pre(){  # the PreToolUse decision: `ask`, or a refusal (exit 2) that say
                          qno "in $PM, with a PermissionRequest hook that may be wired ($_PRH), only the typed approval counts." ;;
     *) qno "in ${PM:-an unknown mode} this approval is not open (bypassPermissions and plan fail closed)." ;;
   esac
-  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) qno "this session has nobody in front of it (it was started with -p, or by a program)." ;; esac
+  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) qno "this session has nobody in front of it (it was started with -p, by a program, or in the background with claude --bg or the agent view, which Claude Code counts as unattended even when you type into it; approve in a regular session, or commit in your own terminal)." ;; esac
   case "$SID$_QTU" in *[!A-Za-z0-9._-]*) qno "the call carries no session or tool id this hook can bind the answer to." ;; esac
   { [ -n "$SID" ] && [ -n "$_QTU" ]; } || qno "the call carries no session or tool id this hook can bind the answer to."
   _crew_prh_scan && qno "a PermissionRequest hook may be wired ($_PRH). Such a hook can answer the question before the user does, and the answer cannot be told from a click."
@@ -668,7 +668,7 @@ _pa_record(){
   # HONEST SCOPE: a session started with an emptied environment and driven through a pseudo-terminal for a second
   # message passes both. guard-bash.sh refuses the forms of that it can read; a program that types is past it.
   case "${CLAUDE_CODE_SESSION_ATTENDED-}" in
-    0) no "this session has nobody in front of it (it was started with -p, or by a program), and an approval is what a person types into their own session." ;;
+    0) no "this session has nobody in front of it (it was started with -p, by a program, or in the background with claude --bg or the agent view, which Claude Code counts as unattended even when you type into it; approve in a regular session, or commit in your own terminal), and an approval is what a person types into their own session." ;;
   esac
   _json_slice "$INPUT" transcript_path >/dev/null; _json_unescape "$_JS" >/dev/null; TP="${_JU//\\//}"
   { [ -n "$TP" ] && [ -s "$TP" ]; } || no "this is the first message of this session, or the session keeps no transcript (one started from inside another session keeps none). An approval answers a commit message the session has shown: have it shown, then approve."
@@ -787,7 +787,7 @@ _pa_question(){
     no) [ -n "$REC" ] && { : > "$REC"; } 2>/dev/null
         say "Crewforth: not approved - you answered No." "The user answered No to the approval question. Do not commit or push; ask what they want changed." ;;
   esac
-  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) no "this session has nobody in front of it (it was started with -p, or by a program)." ;; esac
+  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) no "this session has nobody in front of it (it was started with -p, by a program, or in the background with claude --bg or the agent view, which Claude Code counts as unattended even when you type into it; approve in a regular session, or commit in your own terminal)." ;; esac
   _json_slice "$INPUT" transcript_path >/dev/null; _json_unescape "$_JS" >/dev/null; TP="${_JU//\\//}"
   { [ -n "$TP" ] && [ -s "$TP" ]; } || no "the session keeps no transcript on disk (one started from inside another session keeps none)."
   BARE=0
@@ -884,7 +884,7 @@ _crew_appr_op "$_JU"
 # that class from here, so the old failures do not raise it straight back.
 if [ "$OP" = loosen ]; then
   nol(){ say "Crewforth: floor NOT lowered - $1" "The user sent the command only the user can type /crew-loosen, for $LO_AGENT $LO_CHANGE $LO_RISK, and Crewforth did not lower anything: $1 Tell the user exactly that."; }
-  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) nol "this session has nobody in front of it (it was started with -p, or by a program)." ;; esac
+  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) nol "this session has nobody in front of it (it was started with -p, by a program, or in the background with claude --bg or the agent view, which Claude Code counts as unattended even when you type into it; approve in a regular session, or commit in your own terminal)." ;; esac
   _json_slice "$INPUT" transcript_path >/dev/null; _json_unescape "$_JS" >/dev/null; TP="${_JU//\\//}"
   { [ -n "$TP" ] && [ -s "$TP" ]; } || nol "this is the first message of this session, or the session keeps no transcript."
   _lh="${BASH_SOURCE%/*}"; [ "$_lh" = "${BASH_SOURCE}" ] && _lh=.
@@ -928,7 +928,7 @@ fi
 # + % - and spaces, so it can neither chain another (the gate would refuse a chain anyway) nor need escaping here.
 if [ "$OP" = allowverify ]; then
   noa(){ say "Crewforth: verify command NOT allowed - $1" "The user sent the command only the user can type /crew-allow-verify, and Crewforth added no rule: $1 Tell the user exactly that."; }
-  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) noa "this session has nobody in front of it (it was started with -p, or by a program)." ;; esac
+  case "${CLAUDE_CODE_SESSION_ATTENDED-}" in 0) noa "this session has nobody in front of it (it was started with -p, by a program, or in the background with claude --bg or the agent view, which Claude Code counts as unattended even when you type into it; approve in a regular session, or commit in your own terminal)." ;; esac
   _json_slice "$INPUT" transcript_path >/dev/null; _json_unescape "$_JS" >/dev/null; TP="${_JU//\\//}"
   { [ -n "$TP" ] && [ -s "$TP" ]; } || noa "this is the first message of this session, or the session keeps no transcript."
   _lh="${BASH_SOURCE%/*}"; [ "$_lh" = "${BASH_SOURCE}" ] && _lh=.

package/kit/skills/crew-plan/SKILL.md

@@ -21,5 +21,6 @@ Delegate to the @agent-crew-planner agent (spec-planning skill). For ambiguously
 4. Ask about ambiguities with **explicit options**; write down the assumptions.
 
 crew-planner is read-only and returns the plan; you (the main thread) write it to `docs/PLAN.md` and keep only the
-summary + file pointer in context (token-budget).
+summary + file pointer in context (token-budget). Its tasks carry boxes (`[ ]` open, `[x]` done, `[~]` in work);
+tell the user that `/crew-todo` shows them under the status line.
 Do NOT write code — this is a planning step.

package/kit/skills/crew-todo/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: crew-todo
+description: Open or close the plan's to-do panel under the status line — done tasks ticked, open ones boxed, the phase and task in work marked.
+argument-hint: "[on | off | show | status | <plan file>]  (nothing: open it if closed, close it if open)"
+disable-model-invocation: true
+metadata:
+  kind: command
+---
+# /crew-todo
+Argument: $ARGUMENTS
+
+The user wants to see where the plan stands. Run one command and pass on what it prints; change nothing else.
+
+The script is `${CLAUDE_PLUGIN_ROOT}/eval/lib/todo.sh` if that names a real path (the plugin), else
+`.claude/eval/lib/todo.sh`. From the project root, with the Bash tool (not PowerShell):
+
+```
+bash <script> $ARGUMENTS
+```
+
+- **Nothing, `on`, `off`, or a file name**: it opens or closes the panel (a file name also makes the panel read that
+  plan from now on, instead of `docs/PLAN.md`) and prints one line: open or closed, which file, how far. Say that
+  line. The panel shows at the status line's next refresh, under Crewforth's status line; when the script adds a
+  `note:` that this project's status line is another one, or none, say the note too.
+- **`show`**: it prints the panel once. Show its lines in a code block, exactly as printed.
+- **`status`**: say the one line.
+
+What the panel reads is the plan's own boxes: `- [ ]` open, `- [x]` done, `- [~]` in work, grouped under the plan's
+headings as phases (only what is under its `## Tasks` heading, when it has one). It never writes the plan. When the
+plan's tasks carry no box, say that the panel counts only tasks with one, and that ticking them as the work goes is
+the plan's rule (`spec-planning`).