@mmerterden/multi-agent-pipeline 16.27.0 → 16.29.0

package/pipeline/scripts/phase-tracker.sh

@@ -570,7 +570,11 @@ tracker_next_hint() {
   [ "${TRACKER_QUIET:-0}" = "1" ] && return 0
   name=$(load_state | jq -r --arg id "$pid" '(.phases[] | select(.id == $id) | .name) // ""')
   case "$(host_kind)" in
-    claude) mirror="TaskUpdate(\"Phase $pid $name\", status=\"$status\")" ;;
+    claude) mirror="TaskUpdate(\"$(subjects "$pid")\", status=\"$status\")  -  the subject is re-read from \`phase-tracker.sh subjects $pid\` so the widget carries the model, the elapsed time and the tokens; if TaskUpdate is not one of your tools, paste the card above into your reply VERBATIM in a code block (every phase on its own line, keep the elapsed and token columns; do not redraw or compact it)" ;;
+    # Not every session carries the task tools: Claude Code provides them by
+    # default only up to Opus 4.7 / Sonnet 4.6, a default that landed in
+    # v2.1.268. Naming the fallback on the same line is what keeps a newer model
+    # from advancing eight phases in silence.
     codex) mirror="update_plan: set step \"Phase $pid $name\" to $status (send the FULL step list, it is not a delta)" ;;
     *) mirror="no task widget on this host - reprint the card above inside your reply text" ;;
   esac
@@ -661,6 +665,61 @@ EOF
   printf '\n'
 }
 
+# The native widget renders one row per task and gives us exactly one string to
+# fill it: the subject. So the numbers a reader wants - which model is spending,
+# how long the phase has run, what it cost - have to travel IN the subject or not
+# at all. `render` already computes all of it for the fallback card; this prints
+# the same values in the one shape the host will accept.
+#
+# Every segment is omitted while it is empty, so a pending phase is just its name
+# and a finished one carries its whole bill. Separator is ` - `, not a middle dot:
+# a subject is a task title and travels through surfaces that are not a terminal.
+subjects() {
+  need_jq
+  local state want="${1:-}"
+  state=$(load_state)
+  local prices_json='{"prices":{}}'
+  if [ -f "$COST_TABLE" ]; then
+    prices_json=$(cat "$COST_TABLE" 2>/dev/null) || prices_json='{"prices":{}}'
+    echo "$prices_json" | jq empty 2>/dev/null || prices_json='{"prices":{}}'
+  fi
+  local now_s; now_s=$(now_epoch)
+  local rows
+  rows=$(echo "$state" | jq -r --argjson prices "$prices_json" "$COST_JQ_DEFS"'
+    def usd_of(p): cost_usd_of($prices.prices[p.model // ""] // null; (p.tokens_in // 0); (p.tokens_out // 0); (p.tokens_cached // 0));
+    .phases // []
+    | sort_by(.id | (tonumber? // 9999))
+    | .[] | [
+      (.id // ""), (.name // ""), (.status // ""),
+      (.started_at // ""), (.completed_at // ""), (.model // ""),
+      (((.tokens_in // 0) + (.tokens_out // 0)) | tostring),
+      (usd_of(.) | if . == null then "" else (((. * 100) | floor) / 100 | tostring) end)
+    ] | join("\u001f")')
+  local pid pname pstatus p_start p_end pmodel ptok pusd
+  while IFS=$'\x1f' read -r pid pname pstatus p_start p_end pmodel ptok pusd; do
+    [ -n "$pid" ] || continue
+    [ -z "$want" ] || [ "$want" = "$pid" ] || continue
+    local line="Phase $pid $pname"
+    [ -n "$pmodel" ] && line="$line - $pmodel"
+    local s_ep e_ep el=""
+    s_ep=$(iso_to_epoch "$p_start")
+    e_ep=$(iso_to_epoch "$p_end")
+    if [ -n "$s_ep" ]; then
+      case "$pstatus" in
+        completed|failed|skipped) [ -n "$e_ep" ] && el=$((e_ep - s_ep)) ;;
+        in_progress) el=$((now_s - s_ep)) ;;
+      esac
+    fi
+    if [ -n "$el" ] && [ "$el" -lt 0 ] 2>/dev/null; then el=0; fi
+    [ -n "$el" ] && line="$line - $(format_elapsed "$el")"
+    if [ "${ptok:-0}" -gt 0 ] 2>/dev/null; then
+      line="$line - $(format_tokens "$ptok") tok"
+      [ -n "$pusd" ] && line="$line - $(printf '~$%.2f' "$pusd" 2>/dev/null || echo '')"
+    fi
+    printf '%s\n' "$line"
+  done <<< "$rows"
+}
+
 render() {
   need_jq
   local state
@@ -1156,6 +1215,10 @@ GATE
     fi
     ;;
 
+  subjects)
+    subjects "${1:-}"
+    ;;
+
   tiles)
     need_jq
     tiles_state=$(load_state)
@@ -1166,10 +1229,44 @@ GATE
     }
     case "$(host_kind)" in
       claude)
+        # The task tools are not in every session, and the reason is the model,
+        # not the CLI version. Claude Code provides TaskCreate / TaskUpdate by
+        # default only on Claude 3.x, Opus 4 through 4.7, Sonnet 4 through 4.6
+        # and Haiku 4.5; on any newer model it leaves them out unless the user
+        # opts in, and that default landed in v2.1.268. This contract was written
+        # when the tools were universal and stayed true for years, so nothing
+        # noticed: the tracker state was written correctly, every phase advanced,
+        # and the screen stayed empty for a whole run.
+        #
+        # A shell script cannot probe the model's tool list, so the branch is
+        # taken where the information actually lives - the model knows which
+        # tools it has. And the fallback is not enough on its own: a user looking
+        # at a missing widget needs the one command that brings it back, which is
+        # why the opt-in is printed next to it.
         echo "REQUIRED  -  create one native tile per phase, in this exact order,"
         echo "BEFORE any TaskUpdate. The widget renders by creation order, not by"
         echo "phase number, so an out-of-order call scrambles the stack."
-        echo "$tiles_state" | jq -r '.phases[] | "  TaskCreate(subject: \"Phase \(.id) \(.name)\")"'
+        subjects | sed 's/^/  TaskCreate(subject: "/; s/$/")/'
+        echo
+        echo "At every phase boundary re-run \`phase-tracker.sh subjects <id>\` and"
+        echo "pass that line as the subject of the TaskUpdate. The subject is the only"
+        echo "string the native widget renders, so the model, the elapsed time and the"
+        echo "token count reach the user through it or not at all."
+        echo
+        echo "IF TaskCreate IS NOT ONE OF YOUR TOOLS this session's model does not"
+        echo "carry them (default since v2.1.268 on models newer than Opus 4.7 /"
+        echo "Sonnet 4.6). Then the card below IS the widget, and at every phase"
+        echo "boundary you run \`phase-tracker.sh render\` and paste its output"
+        echo "into your reply VERBATIM, inside a code block  -  every phase on"
+        echo "its own line, with the elapsed time, the token count and the total"
+        echo "row exactly as printed. Do NOT redraw it, do not compact phases"
+        echo "onto one line, do not drop the columns: those numbers are the"
+        echo "whole reason the card is worth showing. Tool output is collapsed,"
+        echo "so a card left in stdout never reaches the user."
+        echo "Say once, in outputLanguage, that the native widget returns with:"
+        echo "  CLAUDE_CODE_ENABLE_TODO_TOOLS=1 claude"
+        echo
+        render
         ;;
       codex)
         echo "REQUIRED  -  register the plan in ONE update_plan call with this step"
@@ -1195,7 +1292,7 @@ GATE
     ;;
 
   *)
-    echo "phase-tracker: unknown action '$ACTION' (use init|add|update|sub|tokens|model|meta|now|cost|render)" >&2
+    echo "phase-tracker: unknown action '$ACTION' (use init|add|update|sub|tokens|model|meta|now|cost|render|subjects)" >&2
     exit 64
     ;;
 esac

package/pipeline/scripts/scan-agent-config.sh

@@ -18,7 +18,24 @@ set -uo pipefail
 
 # ROOT defaults to the repo root; SCAN_ROOT overrides it (used by the smoke test
 # to point at a fixture tree of planted-bad configs).
-ROOT="${SCAN_ROOT:-$(cd "$(dirname "$0")/../.." && pwd)}"
+#
+# Two layouts, and this script ships into the second one. From the checkout, $0
+# is <repo>/pipeline/scripts/... and `../..` is the repo. From an install it is
+# ~/.claude/scripts/... and `../..` is the HOME directory, where none of the
+# shipped config paths exist - the scan then found zero files and called itself
+# clean. Same defect class as the one skill-siblings.mjs carried, so it gets the
+# same two-candidate resolution: try the repo layout, fall back to the install.
+if [ -n "${SCAN_ROOT:-}" ]; then
+  ROOT="$SCAN_ROOT"
+else
+  _here="$(cd "$(dirname "$0")" && pwd)"
+  _repo="$(cd "$_here/../.." && pwd)"
+  if [ -d "$_repo/pipeline/agents" ]; then
+    ROOT="$_repo"
+  else
+    ROOT="$HOME/.claude"
+  fi
+fi
 
 HIGH=0; MED=0
 high() { HIGH=$((HIGH+1)); echo "  [HIGH]   $1"; }
@@ -27,18 +44,39 @@ med()  { MED=$((MED+1));  echo "  [MEDIUM] $1"; }
 # Shipped config surface (globs expanded safely; missing paths are skipped).
 TARGETS=()
 add() { [ -e "$1" ] && TARGETS+=("$1"); }
-add "$ROOT/install/templates/claude-hooks.json"
-add "$ROOT/install/templates/copilot-instructions.md"
-add "$ROOT/pipeline/preferences-template.json"
-for f in "$ROOT"/pipeline/agents/*.md; do add "$f"; done
-# (figma component skills + their scripts now live in the ai-*-toolkit
-#  marketplace plugin, not in this repo, so there is nothing figma to scan here.)
-add "$ROOT/pipeline/scripts/agent-guard.sh"
-add "$ROOT/pipeline/scripts/pre-commit-check.sh"
+# The same surface under either layout: `pipeline/`-prefixed in the checkout,
+# flat under ~/.claude once installed.
+if [ -d "$ROOT/pipeline/agents" ]; then
+  add "$ROOT/install/templates/claude-hooks.json"
+  add "$ROOT/install/templates/copilot-instructions.md"
+  add "$ROOT/pipeline/preferences-template.json"
+  for f in "$ROOT"/pipeline/agents/*.md; do add "$f"; done
+  # (figma component skills + their scripts now live in the ai-*-toolkit
+  #  marketplace plugin, not in this repo, so there is nothing figma to scan here.)
+  add "$ROOT/pipeline/scripts/agent-guard.sh"
+  add "$ROOT/pipeline/scripts/pre-commit-check.sh"
+else
+  # settings.json is deliberately NOT in this list. It is the USER's file, not
+  # something the pipeline ships, and their own permission choices are theirs to
+  # make - scanning it turned a personal setting into a release blocker.
+  for f in "$ROOT"/templates/*; do add "$f"; done
+  for f in "$ROOT"/agents/*.md; do add "$f"; done
+  add "$ROOT/scripts/agent-guard.sh"
+  add "$ROOT/scripts/pre-commit-check.sh"
+fi
 
 rel() { echo "${1#$ROOT/}"; }
 
-echo "→ scanning ${#TARGETS[@]} shipped config files"
+echo "→ scanning ${#TARGETS[@]} shipped config files (root: $ROOT)"
+
+# Zero targets is a resolution failure, not a clean bill: `"${TARGETS[@]}"` on an
+# empty array is also an unbound-variable error under bash 3.2 with `set -u`, so
+# the script died here instead of saying what went wrong.
+if [ "${#TARGETS[@]}" -eq 0 ]; then
+  echo "  [HIGH]   no shipped config file found under $ROOT - nothing was scanned"
+  echo "→ config hygiene: 1 HIGH, 0 MEDIUM"
+  exit 1
+fi
 
 for f in "${TARGETS[@]}"; do
   [ -f "$f" ] || continue

package/pipeline/scripts/skill-siblings.mjs

@@ -44,14 +44,23 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..", "..");
 const HOME = homedir();
 
-const CMD_DIR = join(ROOT, "pipeline", "commands", "multi-agent");
-const CORE_DIR = join(ROOT, "pipeline", "skills", "shared", "core");
+// Two layouts, and the script ships into the second one. From the repo checkout
+// HERE is <repo>/pipeline/scripts, so the authored trees sit one level up. From
+// an install HERE is ~/.claude/scripts and there is no `pipeline/` above it:
+// resolving blind reported "no commands found" and made every caller believe
+// the tree had changed. Try the repo first, fall back to the install.
+const REPO_ROOT = resolve(HERE, "..", "..");
+const REPO_CMD_DIR = join(REPO_ROOT, "pipeline", "commands", "multi-agent");
+const IN_REPO = existsSync(REPO_CMD_DIR);
+const ROOT = IN_REPO ? REPO_ROOT : HOME;
+
+const CMD_DIR = IN_REPO ? REPO_CMD_DIR : join(HOME, ".claude", "commands", "multi-agent");
+const CORE_DIR = join(REPO_ROOT, "pipeline", "skills", "shared", "core");
 const COPILOT_DIR = join(HOME, ".copilot", "skills");
 const CODEX_DIR = join(HOME, ".codex", "multi-agent-refs", "commands");
-// The dispatcher is the one skill Codex installs as a SKILL: the 51 sub-commands
+// The dispatcher is the one skill Codex installs as a SKILL: the sub-commands
 // become refs there, because Codex truncates a large skills block. Resolving it
 // under the refs tree like the others reported a false "absent" - and a sibling
 // check that invents a missing copy is worse than none, since it sends the next
@@ -107,11 +116,23 @@ function siblingsOf(name) {
   );
   const installedName = name === "multi-agent" ? "multi-agent" : `multi-agent-${name}`;
 
+  // The two authored surfaces exist only in the checkout. From an install they
+  // are not missing, they are not applicable, and counting them as absent would
+  // report every command as 3/5 forever - a number that reads as damage and is
+  // really just the layout. In an install CMD_DIR is also the claude tree, so
+  // listing "authored" there would double-count one file as two surfaces.
+  const authoredSurfaces = IN_REPO
+    ? [
+        { tree: "command (authored)", path: authored, exists: existsSync(authored), inRepo: true },
+        { tree: "shared core skill", path: shared, exists: existsSync(shared), inRepo: true },
+      ]
+    : [];
+
   return {
     name,
+    layout: IN_REPO ? "repo" : "install",
     surfaces: [
-      { tree: "command (authored)", path: authored, exists: existsSync(authored), inRepo: true },
-      { tree: "shared core skill", path: shared, exists: existsSync(shared), inRepo: true },
+      ...authoredSurfaces,
       {
         tree: "claude (installed)",
         path: join(CLAUDE_DIR, name === "multi-agent" ? "SKILL.md" : join(name, "SKILL.md")),
@@ -145,11 +166,23 @@ if (AUDIT) {
   });
   const broken = rows.filter((r) => r.missingRepo.length > 0);
   if (JSON_OUT) {
-    process.stdout.write(JSON.stringify({ commands: names.length, broken, rows }, null, 2) + "\n");
+    process.stdout.write(
+      JSON.stringify(
+        { layout: IN_REPO ? "repo" : "install", commands: names.length, broken, rows },
+        null,
+        2,
+      ) + "\n",
+    );
   } else {
-    process.stdout.write(`${names.length} command(s) checked\n`);
+    process.stdout.write(`${names.length} command(s) checked (${IN_REPO ? "repo" : "install"})\n`);
     if (broken.length === 0) {
-      process.stdout.write("  every command has its authored sibling in the repo\n");
+      // From an install there is no authored side to check, and claiming one
+      // was checked is the failure this script exists to prevent one level up.
+      process.stdout.write(
+        IN_REPO
+          ? "  every command has its authored sibling in the repo\n"
+          : "  authored siblings not checked  -  no repo checkout resolved from here\n",
+      );
     }
     for (const r of broken) {
       process.stdout.write(`  MISSING  ${r.name}: ${r.missingRepo.join(", ")}\n`);