@mmerterden/multi-agent-pipeline 16.28.0 → 16.30.0

package/pipeline/scripts/evidence-gate.mjs

@@ -19,6 +19,9 @@
 //                      manual is JSON-based (Phase 5 manual-test.json, see below)
 //   --status           the claimed status (only "passed" is gated; others pass through)
 //   --evidence <path>  the log / artifact that must substantiate a "passed" claim
+//   --require-screenshot  manual claim only: every "pass" criterion must name a
+//                      screenshot that exists on disk. Set by Phase 5 when
+//                      state.visualEvidence.required is true.
 //   --success-pattern  override the default success regex for the claim type (marker claims only)
 //   --failure-pattern  override the default failure regex for the claim type (marker claims only)
 //
@@ -120,7 +123,7 @@ function nonEmptyString(v) {
 // Manual-test evidence is a structured document, not a log: every acceptance
 // criterion must say what was observed and how it came out. A "fail" anywhere
 // is decisive; an untested criterion is only acceptable when it says why.
-function gateManual(claim, evidence, body) {
+function gateManual(claim, evidence, body, requireScreenshot) {
   let doc;
   try {
     doc = JSON.parse(body);
@@ -154,6 +157,32 @@ function gateManual(claim, evidence, body) {
       `${claim} evidence shows a failed criterion "${failed.spec}"  -  pass claim contradicted by ${evidence}`,
     );
   }
+  // A screenshot path is only evidence when a file is behind it. The field has
+  // been in the document shape since the gate shipped and was never read, so a
+  // criterion carrying "screenshot": null passed as a verified manual test on a
+  // UI change - which is the one case the picture was added for. Checked only
+  // when the caller says visual evidence is required for this run, because on a
+  // backend change there is nothing to photograph.
+  if (requireScreenshot) {
+    const shotless = criteria.find(
+      (item) => item.verdict === "pass" && !nonEmptyString(item.screenshot),
+    );
+    if (shotless) {
+      fail(
+        `${claim} evidence has passing criterion "${shotless.spec}" with no screenshot, and this run requires visual evidence: ${evidence} (default-FAIL)`,
+      );
+    }
+    const missing = criteria.find(
+      (item) =>
+        item.verdict === "pass" && nonEmptyString(item.screenshot) && !existsSync(item.screenshot),
+    );
+    if (missing) {
+      fail(
+        `${claim} evidence names a screenshot that is not on disk: ${missing.screenshot} (default-FAIL)`,
+      );
+    }
+  }
+
   const untested = criteria.find(
     (item) => item.verdict === "not-tested" && !nonEmptyString(item.reason),
   );
@@ -203,7 +232,7 @@ if (body.trim().length === 0) {
 }
 
 if (JSON_CLAIMS.has(claim)) {
-  gateManual(claim, evidence, body);
+  gateManual(claim, evidence, body, args["require-screenshot"] === true);
 }
 
 const successRe = userRegExp(args["success-pattern"], DEFAULT_MARKERS[claim].success, "success");

package/pipeline/scripts/phase-tracker.sh

@@ -570,10 +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
-    # Not every Claude Code build ships the tile API, and the shell cannot see
-    # the model's tool list. Naming the fallback on the same line is what keeps a
-    # build without TaskUpdate from advancing eight phases in silence.
-    claude) mirror="TaskUpdate(\"Phase $pid $name\", status=\"$status\") - or, if TaskUpdate is not one of your tools, reprint the card above inside your reply text" ;;
+    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
@@ -664,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
@@ -1159,6 +1215,10 @@ GATE
     fi
     ;;
 
+  subjects)
+    subjects "${1:-}"
+    ;;
+
   tiles)
     need_jq
     tiles_state=$(load_state)
@@ -1169,22 +1229,42 @@ GATE
     }
     case "$(host_kind)" in
       claude)
-        # The native tile API is not in every Claude Code build. This script
-        # cannot probe the model's tool list, and a run that fires nothing and
-        # says nothing is the failure that reached a user: the tracker state was
-        # written correctly, every phase advanced, and the screen stayed empty
-        # for the whole run. So the fallback is named here rather than assumed,
-        # and the branch is taken where the information actually lives - the
-        # model knows which tools it has, the shell does not.
+        # 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 build has no native tile"
-        echo "API. Do not skip the signal: the card below IS the widget then, and"
-        echo "it must be reprinted inside your reply at every phase boundary  - "
-        echo "tool output is collapsed, so a card left in stdout never arrives."
+        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
         ;;
@@ -1212,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/probe-evidence-capability.sh

@@ -0,0 +1,250 @@
+#!/usr/bin/env bash
+#
+# probe-evidence-capability.sh  -  measure what visual evidence this machine and
+# this repo can actually produce, BEFORE the user is asked to choose a test depth.
+#
+# Contract: multi-agent-refs/features/visual-evidence.md section 4.
+#
+# The order is probe, then question, then run. Offering "unit + UI test with a
+# screen recording" and only then discovering there is no UI test target, or no
+# booted simulator, spends the user's answer on something that cannot happen. So
+# the options are built from what this prints.
+#
+# Three rules this file exists to keep:
+#
+#   1. Absence carries a reason. Every empty value is paired with a *_REASON, so
+#      a closed option can say why it is closed instead of vanishing from the menu.
+#   2. Unmeasurable is `unknown`, never `false`. A probe that could not look and a
+#      probe that looked and found nothing are different facts, and collapsing
+#      them lets a missing tool read as a clean negative.
+#   3. Detection is not reimplemented here. The UI test answer comes from
+#      run-ui-tests.sh detect, which is also what actually runs the tests; a
+#      second copy is a second place for the answer to drift.
+#
+# Usage:
+#   probe-evidence-capability.sh --platform <ios|android> [--repo <path>]
+#                                [--changed <f>[,<f>...]] [--json]
+#                                [--json-out <path>] [--only all|device]
+#
+# Output: KEY='VALUE' lines (eval-able; every value is shell-quoted), or a JSON object with --json (shaped for
+# state.evidenceCapability). --json-out writes that JSON to a file while stdout
+# stays KEY=VALUE, so one run serves both the shell that builds the menu and the
+# state that records the measurement - two runs would mean two repo scans and
+# two chances to disagree.
+#
+# --only device skips the UI-test detection. Phase 3 re-checks the device right
+# before recording, and nothing else it would re-scan can have changed.
+#
+# Exit: 0 probed (whatever the verdicts), 2 usage.
+#       Never non-zero for an absent capability: absence is the finding.
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLATFORM=""; REPO="$PWD"; CHANGED=""; AS_JSON=0; JSON_OUT=""; ONLY="all"
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --platform) PLATFORM="${2:-}"; shift 2 ;;
+    --repo) REPO="${2:-}"; shift 2 ;;
+    --changed) CHANGED="${CHANGED:+$CHANGED,}${2:-}"; shift 2 ;;
+    --json) AS_JSON=1; shift ;;
+    --json-out) JSON_OUT="${2:-}"; shift 2 ;;
+    --only) ONLY="${2:-all}"; shift 2 ;;
+    *) echo "probe-evidence-capability: unknown option $1" >&2; exit 2 ;;
+  esac
+done
+case "$ONLY" in all | device) ;; *)
+  echo "probe-evidence-capability: --only takes 'all' or 'device'" >&2; exit 2 ;;
+esac
+
+case "$PLATFORM" in ios | android) ;; *)
+  echo "usage: probe-evidence-capability.sh --platform <ios|android> [--repo <path>] [--changed <f>] [--json]" >&2
+  exit 2 ;;
+esac
+[ -d "$REPO" ] || { echo "probe-evidence-capability: no such repo directory: $REPO" >&2; exit 2; }
+
+UI_TEST_TARGET=""; UI_TEST_TARGETS=""; UI_TEST_TARGET_REASON=""
+UI_TEST_MATCHES=""; UI_TEST_MATCH_REASON=""
+DEVICE=""; DEVICE_REASON=""
+RECORDER="unknown"; RECORDER_REASON=""
+MCP="unknown"; MCP_REASON=""
+
+# ---- UI test target, delegated ------------------------------------------------
+RUNNER="$HERE/run-ui-tests.sh"
+if [ "$ONLY" = "device" ]; then
+  # Phase 3 re-checks the device right before recording, and only the device.
+  # Delegating detection there would re-walk the whole repo for a row that
+  # cannot have changed, which cost 5 seconds of a phase that is already holding
+  # a green build.
+  UI_TEST_TARGET_REASON="not probed (--only device)"
+elif [ ! -x "$RUNNER" ] && [ ! -f "$RUNNER" ]; then
+  UI_TEST_TARGET_REASON="run-ui-tests.sh not found beside this script"
+else
+  DETECT_ARGS=(detect --platform "$PLATFORM" --repo "$REPO")
+  [ -n "$CHANGED" ] && DETECT_ARGS+=(--changed "$CHANGED")
+  while IFS='=' read -r k v; do
+    case "$k" in
+      UI_TEST_TARGET) UI_TEST_TARGET="$v" ;;
+      UI_TEST_TARGETS) UI_TEST_TARGETS="$v" ;;
+      UI_TEST_TARGET_REASON) UI_TEST_TARGET_REASON="$v" ;;
+      UI_TEST_MATCHES) UI_TEST_MATCHES="$v" ;;
+      UI_TEST_MATCH_REASON) UI_TEST_MATCH_REASON="$v" ;;
+    esac
+  done < <(bash "$RUNNER" "${DETECT_ARGS[@]}" 2>/dev/null)
+fi
+
+# ---- Device -------------------------------------------------------------------
+case "$PLATFORM" in
+  ios)
+    if ! command -v xcrun >/dev/null 2>&1; then
+      DEVICE_REASON="xcrun unavailable; cannot tell whether a simulator exists"
+    else
+      DEVICE=$(xcrun simctl list devices booted 2>/dev/null | grep -oE '[0-9A-F-]{36}' | head -1)
+      if [ -z "$DEVICE" ]; then
+        # Bootable is not booted, and the difference is a question the user can
+        # act on: one is "start your simulator", the other is "this machine has
+        # no iOS runtime installed".
+        if xcrun simctl list devices available 2>/dev/null | grep -q "([0-9A-F-]\{36\})"; then
+          DEVICE_REASON="no booted simulator, but one is available to boot"
+        else
+          DEVICE_REASON="no iOS simulator available on this machine"
+        fi
+      fi
+    fi
+    ;;
+  android)
+    if ! command -v adb >/dev/null 2>&1; then
+      DEVICE_REASON="adb unavailable; cannot tell whether a device is attached"
+    else
+      DEVICE=$(adb devices 2>/dev/null | awk 'NR>1 && $2=="device" {print $1; exit}')
+      [ -n "$DEVICE" ] || DEVICE_REASON="no attached device or running emulator"
+    fi
+    ;;
+esac
+
+# ---- Recorder -----------------------------------------------------------------
+# The recorder is the same CLI the capture needs, so this answers "would
+# capture-evidence.sh video start work" rather than "is some recorder installed".
+case "$PLATFORM" in
+  ios)
+    if command -v xcrun >/dev/null 2>&1; then RECORDER="true"; else
+      RECORDER="false"; RECORDER_REASON="xcrun unavailable"
+    fi
+    ;;
+  android)
+    if command -v adb >/dev/null 2>&1; then RECORDER="true"; else
+      RECORDER="false"; RECORDER_REASON="adb unavailable"
+    fi
+    ;;
+esac
+if [ "$RECORDER" = "true" ] && ! command -v ffprobe >/dev/null 2>&1; then
+  # Not fatal. ffprobe only verifies the result, so its absence downgrades what
+  # can be CHECKED about a recording, never whether one can be made.
+  RECORDER_REASON="ffprobe unavailable; a recording cannot be verified after capture"
+fi
+
+# ---- Toolkit MCP --------------------------------------------------------------
+# Registration only, never a handshake: a probe that spawns the server costs
+# seconds at intake, and the question this answers is whether tier 2 may be
+# offered at all.
+CLAUDE_JSON="$HOME/.claude.json"
+SETTINGS_JSON="$HOME/.claude/settings.json"
+if command -v node >/dev/null 2>&1; then
+  MCP=$(node -e '
+    const fs = require("fs");
+    const hit = (p) => {
+      try {
+        const j = JSON.parse(fs.readFileSync(p, "utf8"));
+        return Object.keys(j.mcpServers || {}).some((k) => /toolkit/i.test(k));
+      } catch { return false; }
+    };
+    process.stdout.write(process.argv.slice(1).some(hit) ? "true" : "false");
+  ' "$CLAUDE_JSON" "$SETTINGS_JSON" 2>/dev/null)
+  [ -n "$MCP" ] || MCP="unknown"
+  [ "$MCP" = "false" ] && MCP_REASON="no mcpServers entry matching /toolkit/i"
+  [ "$MCP" = "unknown" ] && MCP_REASON="could not read the MCP registration files"
+else
+  MCP="unknown"; MCP_REASON="node unavailable; cannot read the MCP registration"
+fi
+
+# ---- Tier verdicts ------------------------------------------------------------
+# Computed before the report so both output forms carry them: a caller that
+# persists the JSON and a caller that evals the KEY=VALUE lines must not have to
+# re-derive the same booleans and risk deriving them differently.
+# TIER1 needs a target AND a device AND a recorder; TIER2 drops the target and
+# adds MCP; tier 3 is always reachable because "record nothing and say why" is.
+T1=closed; T2=closed
+[ -n "$UI_TEST_TARGET$UI_TEST_TARGETS" ] && [ -n "$DEVICE" ] && [ "$RECORDER" = "true" ] && T1=open
+[ -n "$DEVICE" ] && [ "$RECORDER" = "true" ] && [ "$MCP" = "true" ] && T2=open
+
+# --only device did not look for a target, so tier 1 is UNKNOWN here, not closed.
+# Reporting it closed would be rule 2 broken by the file that states it: a caller
+# re-checking the device before recording would read "tier 1 unavailable" from a
+# measurement that never ran and downgrade a recording it could have made. Tier 2
+# does not depend on the target, so it stays a real verdict.
+[ "$ONLY" = "device" ] && T1=unknown
+
+emit_json() {
+  UI_TEST_TARGET="$UI_TEST_TARGET" UI_TEST_TARGETS="$UI_TEST_TARGETS" \
+  UI_TEST_TARGET_REASON="$UI_TEST_TARGET_REASON" UI_TEST_MATCHES="$UI_TEST_MATCHES" \
+  UI_TEST_MATCH_REASON="$UI_TEST_MATCH_REASON" DEVICE="$DEVICE" DEVICE_REASON="$DEVICE_REASON" \
+  RECORDER="$RECORDER" RECORDER_REASON="$RECORDER_REASON" MCP="$MCP" MCP_REASON="$MCP_REASON" \
+  PLATFORM="$PLATFORM" TIER1="$T1" TIER2="$T2" \
+  node -e '
+    const e = process.env;
+    const list = (s) => (s ? s.split(",").filter(Boolean) : []);
+    const tri = (s) => (s === "true" ? true : s === "false" ? false : null);
+    process.stdout.write(JSON.stringify({
+      platform: e.PLATFORM,
+      uiTestTarget: e.UI_TEST_TARGET || null,
+      uiTestTargets: list(e.UI_TEST_TARGETS),
+      uiTestTargetReason: e.UI_TEST_TARGET_REASON || null,
+      matchingTests: list(e.UI_TEST_MATCHES),
+      matchingTestsReason: e.UI_TEST_MATCH_REASON || null,
+      device: e.DEVICE || null,
+      deviceReason: e.DEVICE_REASON || null,
+      recorder: tri(e.RECORDER),
+      recorderReason: e.RECORDER_REASON || null,
+      mcp: tri(e.MCP),
+      mcpReason: e.MCP_REASON || null,
+      tier1: e.TIER1,
+      tier2: e.TIER2,
+    }, null, 2) + "\n");
+  '
+}
+
+if [ -n "$JSON_OUT" ]; then
+  mkdir -p "$(dirname "$JSON_OUT")" 2>/dev/null || true
+  emit_json > "$JSON_OUT" || {
+    echo "probe-evidence-capability: could not write $JSON_OUT" >&2
+    exit 2
+  }
+fi
+
+if [ "$AS_JSON" -eq 1 ]; then
+  emit_json
+  exit 0
+fi
+
+# Every value is single-quoted, because the caller EVALS this. The reasons are
+# prose - "no booted simulator, but one is available to boot" - and an unquoted
+# assignment makes eval run `booted` as a command and assign the first word. The
+# bug is invisible on a machine where the reasons happen to be empty, which is
+# exactly the machine a developer tests on.
+q() { printf "%s='%s'" "$1" "$(printf '%s' "$2" | sed "s/'/'\\\\''/g")"; printf '\n'; }
+
+q EVIDENCE_PLATFORM "$PLATFORM"
+q EVIDENCE_UI_TEST_TARGET "$UI_TEST_TARGET"
+q EVIDENCE_UI_TEST_TARGETS "$UI_TEST_TARGETS"
+q EVIDENCE_UI_TEST_TARGET_REASON "$UI_TEST_TARGET_REASON"
+q EVIDENCE_MATCHING_TESTS "$UI_TEST_MATCHES"
+q EVIDENCE_MATCHING_TESTS_REASON "$UI_TEST_MATCH_REASON"
+q EVIDENCE_DEVICE "$DEVICE"
+q EVIDENCE_DEVICE_REASON "$DEVICE_REASON"
+q EVIDENCE_RECORDER "$RECORDER"
+q EVIDENCE_RECORDER_REASON "$RECORDER_REASON"
+q EVIDENCE_MCP "$MCP"
+q EVIDENCE_MCP_REASON "$MCP_REASON"
+
+q EVIDENCE_TIER1 "$T1"
+q EVIDENCE_TIER2 "$T2"