@mmerterden/multi-agent-pipeline 20.23.2 → 20.25.0

package/pipeline/lib/model-rung.sh

@@ -69,7 +69,7 @@ host_note() {
       echo "Claude Code: the fable rung is Fable 5. This switch is live here."
       ;;
     copilot)
-      echo "Copilot CLI: Fable 5 is not offered; its personas never sat on this rung."
+      echo "Copilot CLI: Fable is not offered; its personas never sat on this rung."
       echo "This setting is recorded but changes nothing on this host."
       ;;
     codex)

package/pipeline/lib/plan-todos.sh

@@ -13,11 +13,25 @@
 # Subcommands:
 #   init      <task-id> [title]            Initialize with empty todos[] (Phase 2 usually pipes the JSON instead)
 #   set       <task-id> <plan-json>        Replace the whole plan from a JSON blob on stdin or arg
+#                                          (exit 2 when a dep names no todo id exactly)
 #   start     <task-id> <todo-id>          Mark in_progress, set startedAt; refuses if deps unsatisfied
-#   complete  <task-id> <todo-id> [notes]  Mark completed, set completedAt
+#                                          or the todo awaits re-plan confirmation
+#   complete  <task-id> <todo-id> [notes] [--no-tests <reason>]
+#                                          Mark completed, set completedAt; refuses what start refuses
+#                                          (unsatisfied deps on a pending todo, re-plan unconfirmed); checks TDD evidence per
+#                                          prefs.global.tddEvidence.mode (off | warn | enforce, default warn)
+#   tdd-red   <task-id> <todo-id> <results> [--tests a,b] [--already-passing <reason>]
+#                                          Record the RED run (a named test fails) from JUnit XML / xcresult / log
+#                                          (under enforce, --tests needs results that name failing tests)
+#   tdd-green <task-id> <todo-id> <results> Record the GREEN run (no failures, RED's tests among them)
 #   fail      <task-id> <todo-id> <reason> Mark failed
 #   skip      <task-id> <todo-id> <reason> Mark skipped (counts as satisfied for dependents)
-#   next      <task-id>                    Print next pending todo (deps-respecting); empty if none
+#   next      <task-id>                    Print the next ready todo (deps-respecting, ranked by what it unblocks); empty if none, blocked todos named on stderr
+#   drift     <task-id> <todo-id> [--files <path|->] [--not-done N] [--reason <text>]
+#                                          The todo ended off-plan (files outside its files[],
+#                                          planned items not done, or a stated reason): flag its
+#                                          pending transitive dependents needsReplan; prints JSON
+#   confirm-replan <task-id> <todo-id> [note]  Confirm a flagged todo's plan still holds, so it can start
 #   list      <task-id>                    Render Markdown checklist
 #   status    <task-id>                    Print one-line summary: "2/5 done, 1 in progress"
 #   show      <task-id>                    Print the full plan JSON
@@ -59,7 +73,7 @@ CMD="${1:-}"
 shift || true
 
 usage() {
-  sed -n '2,30p' "$0" >&2
+  sed -n '2,37p' "$0" >&2
   exit 64
 }
 
@@ -71,10 +85,9 @@ resolve_state() {
   local task_id="$1"
   local found=""
   # multi-repo-pipeline.sh writes agent-state.json under a per-project
-  # directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/) - not the
-  # ~/.claude/projects/*/state/ path this used to glob, which no writer in
-  # the pipeline ever populates.
-  # This globbed ONLY the nested layout; flat-layout runs resolved to nothing.
+  # directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/), other
+  # writers write it flat; no writer uses ~/.claude/projects/*/state/.
+  # ma_resolve_run_file checks both layouts.
   found="$(ma_resolve_run_file "$task_id" agent-state.json 2>/dev/null || true)"
   if [ -z "$found" ]; then
     echo "plan-todos: agent-state.json not found for task=$task_id" >&2
@@ -115,12 +128,8 @@ do_set() {
   if [ -z "$plan_blob" ] || [ "$plan_blob" = "-" ]; then
     plan_blob=$(cat)
   fi
-  # A planning-output document is accepted directly and converted here.
-  #
-  # The conversion used to live as a jq blob inside phase-1-plan.md, which
-  # made the mapping from `tasks[]` to `todos[]` a thing two files defined - and
-  # the phase doc was the copy nothing tested. Accepting both shapes costs four
-  # lines and removes the second definition.
+  # A planning-output document is accepted directly and converted here, so the
+  # mapping from `tasks[]` to `todos[]` has one tested definition.
   if jq -e '.tasks and (.todos | not)' <<<"$plan_blob" >/dev/null 2>&1; then
     plan_blob=$(jq '{
       title: (.summary // .title // "plan"),
@@ -129,7 +138,9 @@ do_set() {
         task: (.title // .subject // ""),
         status: "pending",
         deps: (.dependsOn // .blockedBy // [])
-      } ]
+      } + (if (.files | type) == "array" then {files: .files} else {} end)
+        + (if (.creates | type) == "array" then {creates: .creates} else {} end)
+        + (if .type then {type: .type} else {} end) ]
     }' <<<"$plan_blob")
   fi
 
@@ -144,6 +155,23 @@ do_set() {
     echo "plan-todos: every todo must be an object with string .id and .task fields" >&2
     exit 2
   fi
+  # Every dependency must name a todo exactly. Ids are compared as written, so
+  # `t1` against a todo `T1` would leave the dependent blocked for good; the
+  # error names the id that differs only by case.
+  local bad_deps
+  bad_deps=$(jq -r '
+    [.todos[].id] as $ids
+    | [.todos[] | .id as $owner | (.deps // [])[]
+        | select((type != "string") or (. as $d | $ids | index($d) | not))
+        | . as $d
+        | ($ids | map(select(($d | type) == "string" and ascii_downcase == ($d | ascii_downcase)))) as $near
+        | "\($owner) depends on \($d | tojson), which is no todo id"
+          + (if ($near | length) > 0 then " (did you mean \($near | map(tojson) | join(", "))?)" else "" end)]
+    | .[]' <<<"$plan_blob" 2>/dev/null)
+  if [ -n "$bad_deps" ]; then
+    printf 'plan-todos: %s\n' "$bad_deps" >&2
+    exit 2
+  fi
   local state_path; state_path=$(resolve_state "$task_id")
   local now; now=$(iso_now)
   local new
@@ -169,6 +197,22 @@ deps_satisfied() {
   ' <<<"$state" >/dev/null 2>&1
 }
 
+refuse_unconfirmed_replan() {
+  # $1 state JSON, $2 task_id, $3 todo_id. A todo planned on top of one that
+  # drifted waits for a person to confirm its plan: exits 2 until confirm-replan.
+  local replan
+  replan=$(jq -r --arg id "$3" '
+    (.plan.todos // []) | map(select(.id == $id))[0].needsReplan
+    | select(. != null and (.confirmedAt // "") == "")
+    | "\(.because)\t\(.reason // "")"
+  ' <<<"$1")
+  if [ -n "$replan" ]; then
+    printf "plan-todos: '%s' awaits re-plan confirmation: %s drifted (%s). Check its plan, then: plan-todos.sh confirm-replan %s %s\n" \
+      "$3" "${replan%%$'\t'*}" "${replan#*$'\t'}" "$2" "$3" >&2
+    exit 2
+  fi
+}
+
 do_start() {
   local task_id="${1:-}"; local todo_id="${2:-}"
   [ -z "$task_id" ] || [ -z "$todo_id" ] && { echo "usage: start <task-id> <todo-id>" >&2; exit 64; }
@@ -184,6 +228,7 @@ do_start() {
     echo "plan-todos: deps for '$todo_id' not satisfied (still pending/in_progress/failed)" >&2
     exit 2
   fi
+  refuse_unconfirmed_replan "$state" "$task_id" "$todo_id"
   local now; now=$(iso_now)
   local new
   new=$(jq --arg id "$todo_id" --arg t "$now" '
@@ -202,18 +247,85 @@ require_todo() {
   fi
 }
 
+TDD_EVIDENCE="$_MA_RP_HERE/tdd-evidence.mjs"
+
+tdd_mode() {
+  local prefs="${MULTI_AGENT_PREFS:-$HOME/.claude/multi-agent-preferences.json}" mode
+  mode=$(jq -r '.global.tddEvidence.mode // "warn"' "$prefs" 2>/dev/null) || mode=warn
+  case "$mode" in off|warn|enforce) printf '%s' "$mode" ;; *) printf 'warn' ;; esac
+}
+
+write_tdd() {
+  # $1 state path, $2 todo_id, $3 tdd record JSON
+  local new
+  new=$(jq --arg id "$2" --argjson r "$3" '
+    .plan.todos |= map(if .id == $id then .tdd = $r else . end)
+  ' "$1")
+  write_state "$1" "$new"
+}
+
+do_tdd_run() {
+  # $1 red|green, then <task-id> <todo-id> <results> [flags passed to tdd-evidence.mjs]
+  local kind="$1"; shift
+  local task_id="${1:-}"; local todo_id="${2:-}"; local results="${3:-}"
+  [ -z "$task_id" ] || [ -z "$todo_id" ] || [ -z "$results" ] && { echo "usage: tdd-$kind <task-id> <todo-id> <results-file> [flags]" >&2; exit 64; }
+  shift 3
+  # Only the caller-owned flags pass through; --state, --todo, --results and
+  # --mode come from the pipeline, so a trailing copy cannot override them.
+  local extra=()
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --tests|--already-passing)
+        [ $# -ge 2 ] || { echo "tdd-$kind: $1 needs a value" >&2; exit 64; }
+        extra+=("$1" "$2"); shift 2 ;;
+      *) echo "tdd-$kind: unsupported flag '$1' (only --tests and --already-passing)" >&2; exit 64 ;;
+    esac
+  done
+  local state_path; state_path=$(resolve_state "$task_id")
+  require_todo "$state_path" "$todo_id"
+  local record mode_flag=()
+  [ "$kind" = "red" ] && mode_flag=(--mode "$(tdd_mode)")
+  record=$(node "$TDD_EVIDENCE" "$kind" --state "$state_path" --todo "$todo_id" --results "$results" ${mode_flag[@]+"${mode_flag[@]}"} ${extra[@]+"${extra[@]}"}) || exit 2
+  write_tdd "$state_path" "$todo_id" "$record"
+}
+
 do_complete() {
-  local task_id="${1:-}"; local todo_id="${2:-}"; local notes="${3:-}"
-  [ -z "$task_id" ] || [ -z "$todo_id" ] && { echo "usage: complete <task-id> <todo-id> [notes]" >&2; exit 64; }
+  local task_id="${1:-}"; local todo_id="${2:-}"; local notes="" no_tests=""
+  [ -z "$task_id" ] || [ -z "$todo_id" ] && { echo "usage: complete <task-id> <todo-id> [notes] [--no-tests <reason>]" >&2; exit 64; }
+  shift 2
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --no-tests) no_tests="${2:-}"; [ -z "$no_tests" ] && { echo "complete: --no-tests needs a reason" >&2; exit 64; }; shift 2 ;;
+      *) notes="$1"; shift ;;
+    esac
+  done
   local state_path; state_path=$(resolve_state "$task_id")
   require_todo "$state_path" "$todo_id"
+  local state; state=$(cat "$state_path")
+  refuse_unconfirmed_replan "$state" "$task_id" "$todo_id"
+  # A todo that never started skipped the deps check start makes.
+  if [ "$(jq -r --arg id "$todo_id" '(.plan.todos // []) | map(select(.id == $id))[0].status // "pending"' <<<"$state")" = "pending" ] \
+     && ! deps_satisfied "$state" "$todo_id"; then
+    echo "plan-todos: deps for '$todo_id' not satisfied (still pending/in_progress/failed); it cannot complete before they do" >&2
+    exit 2
+  fi
+  local verdict action
+  verdict=$(node "$TDD_EVIDENCE" check --state "$state_path" --todo "$todo_id" --mode "$(tdd_mode)" \
+    ${no_tests:+--no-tests "$no_tests"}) || exit 2
+  action=$(jq -r '.action' <<<"$verdict")
+  if [ "$action" = "refuse" ]; then
+    echo "plan-todos: $(jq -r '.message' <<<"$verdict") - tddEvidence.mode is enforce" >&2
+    exit 2
+  fi
+  [ "$action" = "warn" ] && echo "plan-todos: warning: $(jq -r '.message' <<<"$verdict"); recorded as unverified" >&2
   local now; now=$(iso_now)
   local new
-  new=$(jq --arg id "$todo_id" --arg t "$now" --arg n "$notes" '
+  new=$(jq --arg id "$todo_id" --arg t "$now" --arg n "$notes" --argjson v "$verdict" '
     .plan.todos |= map(
       if .id == $id then
         .status = "completed" | .completedAt = $t
         | if ($n != "") then .notes = $n else . end
+        | if ($v.tdd != null) then .tdd = $v.tdd else . end
       else . end
     )
   ' "$state_path")
@@ -254,25 +366,47 @@ do_next() {
   local task_id="${1:-}"
   [ -z "$task_id" ] && { echo "usage: next <task-id>" >&2; exit 64; }
   local state_path; state_path=$(resolve_state "$task_id")
-  # Pick the first pending todo whose deps are all completed|skipped.
-  jq -r '
-    (.plan.todos // []) as $all
-    | $all
-    | map(select(.status == "pending"))
-    | map(
-        . as $t
-        | select(
-            (.deps // [])
-            | all(
-                . as $d
-                | $all | map(select(.id == $d))[0] // null
-                | . != null and (.status == "completed" or .status == "skipped")
-              )
-          )
-      )
-    | (.[0] // empty)
-    | if . == null or . == "" then "" else (.id // "") + "\t" + (.task // "") end
-  ' "$state_path"
+  # Ready set ranked by the work each todo unblocks; blocked todos are named on stderr.
+  node "$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)/task-graph.mjs" next "$state_path" --task-id "$task_id"
+}
+
+do_drift() {
+  local task_id="${1:-}"; local todo_id="${2:-}"
+  [ -z "$task_id" ] || [ -z "$todo_id" ] && { echo "usage: drift <task-id> <todo-id> [--files <path|->] [--not-done N] [--reason <text>]" >&2; exit 64; }
+  shift 2
+  local state_path; state_path=$(resolve_state "$task_id")
+  require_todo "$state_path" "$todo_id"
+  local result rc=0
+  result=$(node "$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)/task-graph.mjs" drift "$state_path" "$todo_id" "$@") || rc=$?
+  [ "$rc" -eq 0 ] || exit "$rc"
+  if [ "$(jq -r '.drifted' <<<"$result")" = "true" ]; then
+    local new
+    new=$(jq --argjson r "$result" '.plan.todos = $r.todos' "$state_path")
+    write_state "$state_path" "$new"
+  fi
+  jq -c 'del(.todos)' <<<"$result"
+}
+
+do_confirm_replan() {
+  local task_id="${1:-}"; local todo_id="${2:-}"; local note="${3:-}"
+  [ -z "$task_id" ] || [ -z "$todo_id" ] && { echo "usage: confirm-replan <task-id> <todo-id> [note]" >&2; exit 64; }
+  local state_path; state_path=$(resolve_state "$task_id")
+  require_todo "$state_path" "$todo_id"
+  if ! jq -e --arg id "$todo_id" '(.plan.todos // []) | map(select(.id == $id))[0].needsReplan | type == "object"' "$state_path" >/dev/null 2>&1; then
+    echo "plan-todos: '$todo_id' has no re-plan flag to confirm" >&2
+    exit 2
+  fi
+  local now; now=$(iso_now)
+  local new
+  new=$(jq --arg id "$todo_id" --arg t "$now" --arg n "$note" '
+    .plan.todos |= map(
+      if .id == $id then
+        .needsReplan.confirmedAt = $t
+        | if ($n != "") then .needsReplan.note = $n else . end
+      else . end
+    )
+  ' "$state_path")
+  write_state "$state_path" "$new"
 }
 
 do_list() {
@@ -294,7 +428,9 @@ do_list() {
         | ($marks[.status] // "- [ ]") + " **" + (.id // "") + "** " + (.task // "")
           + (if (.notes // "") != "" then "  _(" + .notes + ")_" else "" end)
           + (if (.failureReason // "") != "" then "  _**failed:** " + .failureReason + "_" else "" end)
-          + (if (.skipReason    // "") != "" then "  _**skipped:** "    + .skipReason    + "_" else "" end))
+          + (if (.skipReason    // "") != "" then "  _**skipped:** "    + .skipReason    + "_" else "" end)
+          + (if (.needsReplan // null) != null and (.needsReplan.confirmedAt // "") == ""
+             then "  _**needs re-plan:** " + (.needsReplan.because // "?") + " drifted_" else "" end))
       )
     | .[]
   ' "$state_path"
@@ -332,9 +468,13 @@ case "$CMD" in
   set)      do_set      "$@" ;;
   start)    do_start    "$@" ;;
   complete) do_complete "$@" ;;
+  tdd-red)   do_tdd_run red   "$@" ;;
+  tdd-green) do_tdd_run green "$@" ;;
   fail)     do_fail     "$@" ;;
   skip)     do_skip     "$@" ;;
   next)     do_next     "$@" ;;
+  drift)    do_drift    "$@" ;;
+  confirm-replan) do_confirm_replan "$@" ;;
   list)     do_list     "$@" ;;
   status)   do_status   "$@" ;;
   show)     do_show     "$@" ;;

package/pipeline/lib/post-pr-review.sh

@@ -107,12 +107,10 @@ if [ -z "$TASK_ID" ]; then
 fi
 
 # Resolve agent-state.json. multi-repo-pipeline.sh writes it under a
-# per-project directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/)
-# - not the ~/.claude/projects/*/state/ path this used to glob, which no
-# writer in the pipeline ever populates.
-# This globbed ONLY the nested layout. phase-tracker.sh and most Phase 0 paths
-# write flat, so on a real machine the majority of runs resolved to nothing and
-# this script reported "no agent-state.json" for a run whose state existed.
+# per-project directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/),
+# while phase-tracker.sh and most Phase 0 paths write it flat; no writer uses
+# ~/.claude/projects/*/state/. ma_resolve_run_file checks both layouts, so a
+# run whose state exists is always found.
 AGENT_STATE="$(ma_resolve_run_file "$TASK_ID" agent-state.json 2>/dev/null || true)"
 
 if [ -z "$AGENT_STATE" ]; then

package/pipeline/lib/route-state.sh

@@ -77,7 +77,7 @@ free_savings() {
   since=$(( $(date +%s) - 7 * 86400 ))
   jq -rs --argjson since "$since" --slurpfile ct "$COST_TABLE" '
       map(select((.ts | sub("\\.[0-9]+Z$"; "Z") | fromdateiso8601? // 0) >= $since))
-    | ($ct[0].prices.haiku // {inPerMtok: 1, outPerMtok: 5}) as $h
+    | ($ct[0].prices.haiku // {inPerMtok: 0.5, outPerMtok: 2.5}) as $h
     | {
         n: length,
         ok: (map(select(.ok and (.cached | not))) | length),

package/pipeline/lib/shadow-git.sh

@@ -227,11 +227,10 @@ do_prune() {
     printf 'shadow-git: pruned shadow repo for %s\n' "$task_id" >&2
   else
     [ ! -d "$sd/.git" ] && { err "no shadow for $task_id"; exit 1; }
-    # Retention never touches a real work-tree: this used to run
-    # `reset --hard` with --work-tree=$(pwd), silently rewriting whatever
-    # directory prune happened to be invoked from, and it kept the OLDEST
-    # commit inside the window while discarding every newer one - backwards
-    # for a "keep the last N days" policy. Every git call below is
+    # Retention never touches a real work-tree: a `reset --hard` with
+    # --work-tree=$(pwd) would silently rewrite whatever directory prune is
+    # invoked from. It keeps every commit inside the window and drops the
+    # older ones, as a "keep the last N days" policy requires. Every git call below is
     # git-dir-only plumbing (log/rev-parse/commit-tree/update-ref/gc - no
     # checkout, no reset, no clean); the one --work-tree `sg` still wants
     # points at $sd itself, which prune already owns.