@mmerterden/multi-agent-pipeline 16.31.1 → 17.1.0

package/pipeline/lib/autopilot-activation.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+# autopilot-activation.sh  -  which repos may this machine pick work up from.
+#
+# The answer is NEVER "all of them" and never "whatever has the label". Measured
+# on one machine: 66 repos grant push, and a good half belong to other people -
+# a colleague's backend, someone's side project. A label is a filter, not a gate:
+# anyone able to open an issue in a repo you happen to have push on could put
+# `agent-queue` on it. The gate is this picker, and the picker is per machine.
+#
+# Two lists come out, and the difference matters:
+#
+#   eligible    push rights AND a checkout on this machine
+#   unavailable push rights, no checkout - LISTED, with that as the reason
+#
+# The second list is printed rather than dropped. Silently hiding 40 repos from a
+# 66-repo answer looks exactly like a permissions problem, and the user then goes
+# looking for a token fault that does not exist.
+#
+# Usage:
+#   bash autopilot-activation.sh list            # TSV: state, nameWithOwner, localPath
+#   bash autopilot-activation.sh list --json
+#   . autopilot-activation.sh; ma_ap_local_path <owner/repo>
+#
+# Exit: 0 on success (including an empty list), 2 on usage, 3 when gh cannot answer.
+
+set -uo pipefail
+
+# Repo roots to search for checkouts. $HOME's immediate children covers the
+# normal layout; MA_AUTOPILOT_REPO_ROOTS overrides it for tests and for anyone
+# who keeps checkouts somewhere else.
+MA_AP_ROOTS="${MA_AUTOPILOT_REPO_ROOTS:-$HOME}"
+
+# owner/repo for a checkout, read from its origin remote. Both URL forms, and a
+# trailing .git is stripped - `git@github.com:o/r.git` and
+# `https://github.com/o/r` are the same repo and a picker that treats them as
+# two shows the user a duplicate they cannot explain.
+ma_ap_remote_slug() {
+  local dir="$1" url
+  url=$(git -C "$dir" remote get-url origin 2>/dev/null) || return 1
+  url="${url%.git}"
+  case "$url" in
+    *github.com[:/]*) printf '%s\n' "${url##*github.com[:/]}" ;;
+    *) return 1 ;;
+  esac
+}
+
+# Every checkout under the roots, as `slug<TAB>path`. One pass, so the lookup
+# below is a grep rather than a walk per repo.
+ma_ap_checkout_index() {
+  local root d slug
+  for root in $MA_AP_ROOTS; do
+    [ -d "$root" ] || continue
+    for d in "$root"/*/; do
+      [ -d "$d/.git" ] || continue
+      slug=$(ma_ap_remote_slug "${d%/}") || continue
+      printf '%s\t%s\n' "$slug" "${d%/}"
+    done
+  done
+}
+
+ma_ap_local_path() { # $1 = owner/repo
+  ma_ap_checkout_index | awk -F'\t' -v s="$1" 'tolower($1)==tolower(s){print $2; exit}'
+}
+
+# Repos the authenticated account may push to.
+#
+# The query string form is deliberate: `gh api user/repos --field affiliation=...`
+# sends the value as a BODY field on a GET, which this endpoint ignores - it
+# answers with the default affiliation and the caller never learns the filter did
+# not apply. Measured: the --field form returned 0 rows here, the query string
+# form returned 66.
+ma_ap_writable_repos() {
+  gh api "user/repos?affiliation=owner,collaborator,organization_member&per_page=100" \
+    --paginate -q '.[] | select(.permissions.push == true) | .full_name' 2>/dev/null
+}
+
+ma_ap_list() {
+  local json="${1:-}" slug path index
+  index=$(ma_ap_checkout_index)
+  local repos
+  repos=$(ma_ap_writable_repos)
+  if [ -z "$repos" ]; then
+    echo "autopilot-activation: gh returned no writable repos - check 'gh auth status'" >&2
+    return 3
+  fi
+
+  local first=1
+  [ "$json" = "--json" ] && printf '['
+  while IFS= read -r slug; do
+    [ -n "$slug" ] || continue
+    path=$(printf '%s\n' "$index" | awk -F'\t' -v s="$slug" 'tolower($1)==tolower(s){print $2; exit}')
+    local state="eligible"
+    [ -z "$path" ] && state="unavailable"
+    if [ "$json" = "--json" ]; then
+      [ "$first" -eq 0 ] && printf ','
+      first=0
+      printf '{"state":"%s","nameWithOwner":"%s","localPath":"%s"}' "$state" "$slug" "$path"
+    else
+      printf '%s\t%s\t%s\n' "$state" "$slug" "$path"
+    fi
+  done <<EOF
+$repos
+EOF
+  [ "$json" = "--json" ] && printf ']\n'
+  return 0
+}
+
+if [ "${BASH_SOURCE[0]:-$0}" = "$0" ]; then
+  case "${1:-}" in
+    list) ma_ap_list "${2:-}" ;;
+    "" | -h | --help) grep -E '^#( |$)' "$0" | sed -E 's/^# ?//' ;;
+    *)
+      echo "autopilot-activation: unknown command ${1}" >&2
+      exit 2
+      ;;
+  esac
+fi

package/pipeline/lib/autopilot-state.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+# autopilot-state.sh  -  where continuous mode keeps its state, and who may read it.
+#
+# Everything lives under ~/.claude/autopilot/ and NOT in
+# multi-agent-preferences.json. That file has `additionalProperties: false` and a
+# migration chain, so a block there would push keys into every local user's
+# preferences forever - including everyone who never turns this on. Separation
+# also gives the off state a definition that cannot be got wrong: the directory
+# is absent.
+#
+#   config.json      the repo selection. Survives autopilot-off on purpose, so
+#                    turning the mode back on does not re-ask which repos.
+#   queue.json       the current ordered list plus whatever is in flight
+#   status.json      what the menu bar renders. Written by the runner, read-only
+#                    to everything else
+#   attempted.jsonl  append-only: {source,id,taskId,outcome,prUrl,at}
+#   runner.pid       pid + the in-flight sessionId + kern.boottime
+#   runner.log
+#   bin/menubar      built on demand from scripts/autopilot-menubar.swift
+#
+# 0700 throughout. The queue names real tickets and real repos, and on a shared
+# machine that is somebody's roadmap.
+#
+# Usage:
+#   . autopilot-state.sh
+#   ma_ap_root                 # prints the dir, creating it 0700 only when asked
+#   ma_ap_is_on                # exit 0 when configured, 1 otherwise. NO side effects
+#   ma_ap_write <file> <-      # atomic write from stdin, 0600
+
+set -uo pipefail
+
+MA_AP_ROOT="${MA_AUTOPILOT_ROOT:-$HOME/.claude/autopilot}"
+
+ma_ap_root() { printf '%s\n' "$MA_AP_ROOT"; }
+
+MA_AP_LABEL="${MA_AUTOPILOT_LABEL:-com.multi-agent.autopilot}"
+MA_AP_PLIST="${MA_AUTOPILOT_PLIST:-$HOME/Library/LaunchAgents/$MA_AP_LABEL.plist}"
+
+# Two different questions, and conflating them was a real bug in the first draft
+# of this file: `autopilot-off` deliberately KEEPS config.json so turning the
+# mode back on does not re-ask which repos, so a predicate reading the config
+# would still answer "on" after you turned it off.
+#
+#   configured = a repo selection exists
+#   on         = launchd holds the job
+#
+# On is the launchd job because that is the thing that actually makes work
+# happen; anything else is a claim about a file.
+ma_ap_is_configured() { [ -f "$MA_AP_ROOT/config.json" ]; }
+
+ma_ap_is_on() { [ -f "$MA_AP_PLIST" ] && launchctl list 2>/dev/null | grep -q "$MA_AP_LABEL"; }
+
+# The failure mode a `resume` command would have papered over: configured and
+# meant to be running, but launchd does not hold the job - an OS update dropped
+# the plist, or it was booted out by hand. doctor reports this; there is no
+# command to remember.
+ma_ap_is_orphaned() { ma_ap_is_configured && ! ma_ap_is_on && [ -f "$MA_AP_PLIST" ]; }
+
+# Deliberately no side effects in any of the three. A predicate that creates its
+# own directory turns "is autopilot on?" into "autopilot is now half on", and
+# every status command, hook and doctor check calls these.
+
+ma_ap_ensure_root() {
+  [ -d "$MA_AP_ROOT" ] || mkdir -p "$MA_AP_ROOT" || return 1
+  chmod 700 "$MA_AP_ROOT" 2>/dev/null
+  [ -d "$MA_AP_ROOT/bin" ] || mkdir -p "$MA_AP_ROOT/bin" 2>/dev/null
+  chmod 700 "$MA_AP_ROOT/bin" 2>/dev/null
+  return 0
+}
+
+# Write via a temp file in the SAME directory then rename. The menu bar polls
+# status.json every few seconds, and a reader that catches a half-written file
+# shows an empty menu; rename is atomic on the same filesystem, so it never sees
+# a partial one.
+ma_ap_write() { # $1 = filename under the root; content on stdin
+  ma_ap_ensure_root || return 1
+  local dst="$MA_AP_ROOT/$1" tmp="$MA_AP_ROOT/.$1.$$"
+  cat > "$tmp" || {
+    rm -f "$tmp"
+    return 1
+  }
+  chmod 600 "$tmp" 2>/dev/null
+  mv -f "$tmp" "$dst"
+}
+
+ma_ap_append() { # $1 = filename, content on stdin - for the jsonl
+  ma_ap_ensure_root || return 1
+  local dst="$MA_AP_ROOT/$1"
+  cat >> "$dst" || return 1
+  chmod 600 "$dst" 2>/dev/null
+}
+
+ma_ap_read() { # $1 = filename; empty and exit 1 when absent
+  local src="$MA_AP_ROOT/$1"
+  [ -f "$src" ] || return 1
+  cat "$src"
+}
+
+# jq with a default, so a caller never has to distinguish "key absent" from
+# "file absent" from "file unparseable" - all three mean "use the default".
+ma_ap_cfg() { # $1 = jq path, $2 = default
+  local v
+  v=$(ma_ap_read config.json 2>/dev/null | jq -r "$1 // empty" 2>/dev/null)
+  [ -n "$v" ] && printf '%s\n' "$v" || printf '%s\n' "$2"
+}
+
+# AC or battery. The mode holds a sleep assertion only on AC: a queue that keeps
+# a laptop awake on battery is a bug, and `StartInterval` does not wake a
+# sleeping Mac anyway, so on battery the work resumes when you plug in.
+ma_ap_power() {
+  case "$(pmset -g ps 2>/dev/null | head -1)" in
+    *"AC Power"*) printf 'ac\n' ;;
+    *) printf 'battery\n' ;;
+  esac
+}
+
+# Boot time, so a stale runner.pid cannot be mistaken for a live runner. After a
+# restart pids start low and the recorded 4711 may belong to something unrelated;
+# a pid recorded BEFORE the current boot is stale by definition, with no probing.
+# The pattern is ANCHORED on purpose. `kern.boottime` prints
+# `{ sec = 1788181644, usec = 618574 } Mon Aug 31 ...`, and `.*sec = ` is greedy:
+# it walks past `sec` to `usec` and captures 618574, the microseconds. The
+# original form here did exactly that, so this returned a six-digit number that
+# looked plausible and never matched the same fact read anywhere else - which is
+# how the runner's staleness check compared two different numbers and called a
+# live runner dead.
+ma_ap_boottime() {
+  sysctl -n kern.boottime 2>/dev/null | sed -n 's/^{ *sec = \([0-9]*\).*/\1/p'
+}
+
+# The machine's honest ceiling, so raising `slots` is a measured decision. RAM
+# and cores bound the concurrent Claude sessions; disk bounds the worktrees
+# (0.75 GB each, measured at 11 GB across 15). The hard cap is 4 because beyond
+# that the bottleneck stops being this machine.
+ma_ap_slot_ceiling() {
+  local ram_gb cores free_gb a b c
+  ram_gb=$(( $(sysctl -n hw.memsize 2>/dev/null || echo 0) / 1073741824 ))
+  cores=$(sysctl -n hw.ncpu 2>/dev/null || echo 2)
+  free_gb=$(df -g "$HOME" 2>/dev/null | awk 'NR==2{print $4}')
+  [ -n "$free_gb" ] || free_gb=0
+  a=$(((ram_gb - 4) * 10 / 25))
+  b=$((cores / 2))
+  c=$(((free_gb - 20) * 100 / 75))
+  local m=$a
+  [ "$b" -lt "$m" ] && m=$b
+  [ "$c" -lt "$m" ] && m=$c
+  [ "$m" -gt 4 ] && m=4
+  [ "$m" -lt 1 ] && m=1
+  printf '%s\n' "$m"
+}

package/pipeline/lib/issue-fetcher.sh

@@ -49,8 +49,23 @@
 
 set -euo pipefail
 
+# Sourcing this file hands a caller the provider helpers - `jira_search`,
+# `fetch_jira`, `fetch_github` and the `jira_curl` underneath them - without
+# resolving anything. Executing it resolves one input, exactly as before.
+#
+# The guard exists because the alternative is worse than it looks: a second
+# consumer of `jira_search` with no way to source would have to copy
+# `jira_curl`, and that function is not a URL - it is the credential resolution,
+# the host lookup and the rule that keeps a token off argv. Three copies of that
+# is three places for a token to leak.
+MA_IF_EXECUTED=0
+[ "${BASH_SOURCE[0]}" = "$0" ] && MA_IF_EXECUTED=1
+
 INPUT="${1:-}"
-[ -z "$INPUT" ] && { echo '{"error":"input required"}'; exit 1; }
+if [ "$MA_IF_EXECUTED" = 1 ] && [ -z "$INPUT" ]; then
+  echo '{"error":"input required"}'
+  exit 1
+fi
 
 JIRA_TOKEN_KEY="${ACCOUNT_JIRA_TOKEN_KEY:-}"
 JIRA_HOST="${ACCOUNT_JIRA_HOST:-}"
@@ -361,6 +376,7 @@ PY
 }
 
 # --- Dispatch -----------------------------------------------------------------
+if [ "$MA_IF_EXECUTED" = 1 ]; then
 case "$KIND" in
   jira-id)
     KEY="$INPUT"
@@ -592,3 +608,4 @@ sys.stdout.write("\x1f".join(parts))
       "description=" "branchHint=$branch"
     ;;
 esac
+fi

package/pipeline/lib/plan-todos.sh

@@ -94,6 +94,24 @@ 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-2-planning.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.
+  if jq -e '.tasks and (.todos | not)' <<<"$plan_blob" >/dev/null 2>&1; then
+    plan_blob=$(jq '{
+      title: (.summary // .title // "plan"),
+      todos: [ .tasks[] | {
+        id: .id,
+        task: (.title // .subject // ""),
+        status: "pending",
+        deps: (.dependsOn // .blockedBy // [])
+      } ]
+    }' <<<"$plan_blob")
+  fi
+
   # Validate against schema (best-effort  -  jq syntax check, then required-field probe).
   if ! jq -e '.title and (.todos | type == "array")' <<<"$plan_blob" >/dev/null 2>&1; then
     echo "plan-todos: input must be an object with .title (string) and .todos (array)" >&2

package/pipeline/lib/stack-detect.sh

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+# stack-detect.sh  -  answer "what is this repo built with" from the repo itself.
+#
+# Why this exists: `/multi-agent:stack` writes `enabledPlugins` and a human picks
+# the stack. When that conversation never happens the repo inherits the global
+# setting, and on the machine this was written against only 3 of 25 checkouts had
+# ever had it - so a Next.js site and several Node CLIs were all routed to the iOS
+# toolkit. An unsupervised run has nobody to notice.
+#
+# So: infer, deterministically, from file markers - never a model call - so the
+# same repo always answers the same way and the answer can be shown with its
+# reason.
+#
+# This file answers ONE question: which of `ios android web backend` describes
+# this repo. It deliberately does not know plugin names. "Which plugin carries a
+# stack" is a different question with a different owner
+# (`pipeline/scripts/_stack-routing.mjs`), and the two were one table here until
+# that put a tenth copy of the stack-to-plugin mapping in the tree - the exact
+# duplication `multi-agent-refs/stack-skill-routing.md` exists to prevent.
+#
+# Usage:
+#   . stack-detect.sh; ma_stack_detect <repo-root>   # sets MA_STACKS, MA_STACK_WHY
+#   bash stack-detect.sh <repo-root>                 # prints KEY=VALUE
+#   bash stack-detect.sh --json <repo-root>
+#
+# Output: MA_STACKS is a space-separated subset of `ios android web backend`, in
+# that fixed order so two runs on the same repo produce the same string. Empty is
+# a real answer and means "no marker matched", NOT "not looked" - MA_STACK_WHY
+# distinguishes them, because a caller that cannot tell those apart will treat an
+# unreadable directory as a language-free repo.
+
+# Markers whose mere presence decides a stack, as data rather than a `case`
+# cascade: `stack:glob:maxdepth`. Adding a language is one line here, which is
+# the point - a contributor who has to edit control flow to add Rust will
+# instead widen somebody else's regex.
+#
+# Not every rule fits this shape, and forcing the two that do not would be worse
+# than keeping them in code: Android is decided by FILE CONTENT (Gradle alone is
+# a JVM service), and one package.json can be web, backend or both. Those two
+# run after the table, with their reasoning at the point of decision.
+MA_STACK_MARKERS="\
+ios:Package.swift:3
+ios:*.xcodeproj:3
+ios:*.xcworkspace:3
+ios:Podfile:3
+web:vite.config.*:3
+web:nuxt.config.*:3
+web:angular.json:3
+web:svelte.config.*:3
+backend:requirements.txt:3
+backend:pyproject.toml:3
+backend:go.mod:3
+backend:Cargo.toml:3
+backend:pom.xml:3"
+
+# Dependency names that decide which side of one package.json a repo is on. A
+# Next app with API routes is honestly both, so both may be recorded.
+MA_STACK_WEB_DEPS='"(react|next|vue|svelte|@angular/core|solid-js|astro|preact|remix)"[[:space:]]*:'
+MA_STACK_BACKEND_DEPS='"(express|fastify|@nestjs/core|koa|hapi|@trpc/server|apollo-server)"[[:space:]]*:'
+
+ma_stack_detect() {
+  local root="${1:-$PWD}"
+  MA_STACKS=""
+  MA_STACK_WHY=""
+
+  if [ -z "$root" ] || [ ! -d "$root" ]; then
+    MA_STACK_WHY="unreadable: $root"
+    return 1
+  fi
+  # Strip trailing slashes before anything builds a path from $root. `find`
+  # prints `<root>/x`, so a root ending in `/` makes every `-path "$root/$sub"`
+  # prune carry a double slash and match nothing - the submodule prune then
+  # silently does not fire, and a vendored Package.swift reports a Compose app
+  # as iOS. A caller passing a directory with a trailing slash is normal.
+  while [ "${root%/}" != "$root" ] && [ "$root" != "/" ]; do root="${root%/}"; done
+
+  # Submodule paths are pruned: a vendored checkout is somebody else's repo and
+  # its markers are not this repo's stack. Measured, not theorised - the Android
+  # app vendors the shared configuration repo, which ships a Package.swift, and a
+  # depth-first scan reported that Compose app as an iOS repo.
+  local _prunes=(
+    -name node_modules -o -name .build -o -name Pods -o -name build -o -name dist
+    -o -name .next -o -name .gradle -o -name DerivedData -o -name .worktrees
+    -o -name .git -o -name vendor -o -name Carthage
+  )
+  local _sub _subs=()
+  if [ -f "$root/.gitmodules" ]; then
+    while IFS= read -r _sub; do
+      [ -n "$_sub" ] && _subs+=(-o -path "$root/$_sub")
+    done <<< "$(sed -n 's/^[[:space:]]*path[[:space:]]*=[[:space:]]*//p' "$root/.gitmodules" 2>/dev/null)"
+  fi
+
+  # The repo ROOT is checked before anything deeper, and that ordering is the
+  # whole correctness argument: the root manifest is the repo's own declaration,
+  # while every deeper hit belongs to a submodule, a build output or a vendored
+  # dependency. Without it the answer is decided by `find` traversal order, which
+  # is arbitrary - it read a generated .next/package.json as a Next.js app's
+  # manifest and found no framework in it.
+  _ma_has() { # $1 = -name pattern; prints the first hit, empty when none
+    local _g
+    for _g in "$root"/$1; do
+      [ -e "$_g" ] && {
+        printf '%s\n' "$_g"
+        return 0
+      }
+    done
+    # No -mindepth here, deliberately. -mindepth suppresses predicate evaluation
+    # for shallower entries, so with -mindepth 2 the prune never fired on a
+    # depth-1 submodule directory and find walked straight into it. The root glob
+    # above already returned any root-level hit, so re-visiting depth 1 is free.
+    find "$root" -maxdepth "${2:-3}" \
+      -type d \( "${_prunes[@]}" "${_subs[@]}" \) -prune -o \
+      -name "$1" -print 2>/dev/null | head -1
+  }
+
+  _ma_add() { # $1 = stack, $2 = why-suffix
+    case " $MA_STACKS " in *" $1 "*) return 0 ;; esac
+    MA_STACKS="${MA_STACKS:+$MA_STACKS }$1"
+    _why="${_why:+$_why }$1<-$2"
+  }
+
+  local _why="" hit row stack pat depth
+
+  # --- table markers ----------------------------------------------------
+  while IFS=: read -r stack pat depth; do
+    [ -n "$stack" ] || continue
+    case " $MA_STACKS " in *" $stack "*) continue ;; esac
+    hit=$(_ma_has "$pat" "$depth")
+    [ -n "$hit" ] && _ma_add "$stack" "${hit##*/}"
+  done <<EOF
+$MA_STACK_MARKERS
+EOF
+
+  # --- android, by content ----------------------------------------------
+  # Gradle alone does NOT mean Android - a JVM service builds with Gradle too.
+  # AndroidManifest.xml or the Android Gradle plugin is what separates them, and
+  # getting this wrong loads the Compose toolkit onto a Spring repo.
+  # AndroidManifest.xml lives at <module>/src/main/, which is depth 4 in every
+  # multi-module app, so this one search goes deeper than the rest.
+  hit=$(_ma_has "AndroidManifest.xml" 5)
+  if [ -z "$hit" ]; then
+    # A version catalogue is where a modern build declares the Android plugin;
+    # the root build.gradle.kts of the reference app names it nowhere.
+    local g
+    for g in "$root/gradle/libs.versions.toml" "$(_ma_has 'build.gradle*')" "$(_ma_has 'settings.gradle*')"; do
+      [ -n "$g" ] && [ -f "$g" ] || continue
+      if grep -qE "com\.android\.(application|library)|androidx|\bagp\b" "$g" 2>/dev/null; then
+        hit="$g"
+        break
+      fi
+    done
+  fi
+  [ -n "$hit" ] && _ma_add "android" "${hit##*/}"
+
+  # --- web / backend, by dependency -------------------------------------
+  local pkg
+  pkg=$(_ma_has "package.json")
+  if [ -n "$pkg" ]; then
+    local is_web=0
+    grep -qE "$MA_STACK_WEB_DEPS" "$pkg" 2>/dev/null && is_web=1
+    [ "$is_web" -eq 1 ] && _ma_add "web" "package.json"
+    if grep -qE "$MA_STACK_BACKEND_DEPS" "$pkg" 2>/dev/null; then
+      _ma_add "backend" "package.json"
+    elif [ "$is_web" -eq 0 ]; then
+      # A package.json with no web framework is still a Node project, and the
+      # backend toolkit is the one that covers Node. Reporting nothing here would
+      # send the caller to its no-marker fallback for a repo whose language is
+      # not in doubt.
+      _ma_add "backend" "package.json(node)"
+    fi
+  fi
+
+  # Fixed order, so the same repo always yields the same string.
+  local ordered="" s
+  for s in ios android web backend; do
+    case " $MA_STACKS " in *" $s "*) ordered="${ordered:+$ordered }$s" ;; esac
+  done
+  MA_STACKS="$ordered"
+  MA_STACK_WHY="${_why:-no marker matched}"
+  unset -f _ma_has _ma_add
+  return 0
+}
+
+if [ "${BASH_SOURCE[0]:-$0}" = "$0" ]; then
+  _json=0
+  case "${1:-}" in --json)
+    _json=1
+    shift
+    ;;
+  esac
+  ma_stack_detect "${1:-$PWD}" || true
+  if [ "$_json" -eq 1 ]; then
+    _arr=""
+    for _s in $MA_STACKS; do _arr="${_arr:+$_arr,}\"$_s\""; done
+    printf '{"stacks":[%s],"why":"%s"}\n' "$_arr" "$MA_STACK_WHY"
+  else
+    printf 'MA_STACKS=%s\n' "$(printf '%q' "$MA_STACKS")"
+    printf 'MA_STACK_WHY=%s\n' "$(printf '%q' "$MA_STACK_WHY")"
+  fi
+fi