@mmerterden/multi-agent-pipeline 20.2.1 → 20.3.1

package/pipeline/scripts/autopilot-status.sh

@@ -8,21 +8,33 @@
 #
 #   (default)    a paragraph for a human reading the terminal
 #   --short      one line, for autopilot-off and the session hook
-#   --json       status.json, which is what bin/menubar renders
+#   --json       status.json, which is what bin/menubar renders. Besides the
+#                queue it carries the runner's operations: inhibitorHeld,
+#                lastGcReport, lastDigest (paths, empty when none),
+#                maxParallelAgents (null when unlimited) and
+#                awake: {held, display} from the awake agent.
 #   --write      compute and write status.json, print nothing
 #   --subjects   one line per in-flight item for the native task widget
 #
 # `--json` and `--write` produce the SAME bytes. A menu bar fed by a different
 # code path than the terminal is a second source of truth with a nicer font.
 #
-# Exit: 0 always when it can read the state, 2 on usage. Never non-zero because
-# the mode is off - "off" is an answer.
+# Every line a person reads renders in `prefs.global.outputLanguage`, including
+# the ones that travel to the menu bar inside status.json: this script is the
+# only place that wording exists, so the corner of the screen and the terminal
+# cannot say it two ways.
+#
+# Exit: 0 always when it can read the state, 2 on usage, 3 when --json or
+# --write cannot build the envelope (jq missing, or jq rejecting an input;
+# --json still prints a JSON {"error": ...} object, --write leaves the previous
+# status.json in place). Never non-zero because the mode is off - "off" is an
+# answer.
 
 set -uo pipefail
 
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=/dev/null
-. "$HERE/../lib/autopilot-state.sh" 2>/dev/null || . "$HOME/.claude/lib/autopilot-state.sh"
+if [ -f "$HERE/../lib/autopilot-state.sh" ]; then . "$HERE/../lib/autopilot-state.sh"; else . "$HOME/.claude/lib/autopilot-state.sh"; fi
 
 MODE="human"
 case "${1:-}" in
@@ -41,7 +53,105 @@ case "${1:-}" in
     ;;
 esac
 
-command -v jq >/dev/null 2>&1 || { echo "autopilot-status: jq is required"; exit 0; }
+# A decoder reads stdout, so under --json even this failure is JSON, and the exit
+# code says the envelope is not a status.
+if ! command -v jq >/dev/null 2>&1; then
+  case "$MODE" in
+    json) printf '%s\n' '{"error":"jq-required","message":"autopilot-status: jq is required"}'; exit 3 ;;
+    write) echo "autopilot-status: jq is required" >&2; exit 3 ;;
+    *) echo "autopilot-status: jq is required"; exit 0 ;;
+  esac
+fi
+
+# The same resolver every other shipped script reads, so a run whose preferences
+# are pointed at a fixture renders this surface and the arming verdict inside it
+# from one file. The codes are the schema's, lowercase and exact.
+OUT_LANG=$(ma_output_lang 2>/dev/null || echo en)
+case "$OUT_LANG" in tr | en) ;; *) OUT_LANG=en ;; esac
+
+# One table, both languages on the same line, so a wording change cannot land on
+# one of them. English is the default and the fallback for a language the table
+# does not carry.
+msg() { # $1 = key, $2.. = printf arguments
+  local key="$1" en='' tr='' fmt=''
+  shift
+  case "$key" in
+    power-ac)
+      en='plugged in, sleep is held while a run is in flight'
+      tr='prizde, bir koşu sürerken uyku engelleniyor' ;;
+    power-battery)
+      en='on battery, sleep is free - it continues when you plug in'
+      tr='bataryada, uyku serbest - prize takınca devam eder' ;;
+    awake-held)
+      en='kept awake while autopilot is on - system sleep held on AC, idle sleep on battery too'
+      tr='autopilot açıkken uyanık tutuluyor - prizde sistem uykusu, bataryada da boşta uyku engelleniyor' ;;
+    awake-held-display)
+      en='kept awake while autopilot is on, display included'
+      tr='autopilot açıkken ekran dahil uyanık tutuluyor' ;;
+    orphaned)
+      en='the config is on but launchd holds no job - re-arm with %s'
+      tr='config açık ama launchd bir iş tutmuyor - %s ile yeniden kur' ;;
+    phase-word)
+      en='Phase'
+      tr='Faz' ;;
+    awaiting-subject)
+      en='waiting for an answer'
+      tr='cevap bekliyor' ;;
+    short-off)
+      en='autopilot: off (%s repos selected)'
+      tr='autopilot: kapalı (%s repo seçili)' ;;
+    short-absent)
+      en='autopilot: not set up'
+      tr='autopilot: kurulu değil' ;;
+    short-on)
+      en='autopilot: on · %s running, %s queued, %s awaiting an answer · %s'
+      tr='autopilot: açık · %s koşuyor, %s sırada, %s cevap bekliyor · %s' ;;
+    human-absent)
+      en='autopilot: not set up on this machine.'
+      tr='autopilot: bu makinede kurulu değil.' ;;
+    human-turn-on)
+      en='  To turn it on: %s'
+      tr='  Açmak için: %s' ;;
+    human-on)
+      en='autopilot: ON · %s repos · %s slots (this machine holds %s) · scanning every %ss'
+      tr='autopilot: AÇIK · %s repo · %s slot (bu makine %s kaldırır) · her %ssn tarıyor' ;;
+    human-off)
+      en='autopilot: OFF · %s repos selected, nothing scheduled'
+      tr='autopilot: KAPALI · %s repo seçili, zamanlama yok' ;;
+    heading-running)
+      en='Running (%s):'
+      tr='Koşuyor (%s):' ;;
+    heading-queued)
+      en='Queued (%s):'
+      tr='Sırada (%s):' ;;
+    heading-awaiting)
+      en='Waiting for an answer (%s) - the open questions are posted, and it continues once they are answered:'
+      tr='Cevap bekliyor (%s) - açık soruları yorumladık, cevap gelince devam edecek:' ;;
+    queue-empty)
+      en='Nothing queued.'
+      tr='Sırada iş yok.' ;;
+    queue-empty-hint)
+      en='  To give it an item: add the label to a GitHub issue, or to a Jira item assigned to you.'
+      tr='  Bir madde alması için: GitHub issue veya sana atanmış Jira maddesine label ekle.' ;;
+    blocked)
+      en='Not taking new items: %s'
+      tr='Yeni madde alınmıyor: %s' ;;
+    spend)
+      en='Last 24 hours: $%s / $%s'
+      tr='Son 24 saat: $%s / $%s' ;;
+    heading-reports)
+      en='Last 24 hours (%s PRs):'
+      tr='Son 24 saat (%s PR):' ;;
+    *)
+      printf 'autopilot-status: no message for %s\n' "$key" >&2
+      return 1 ;;
+  esac
+  # English is the fallback per key, not only per language: a key whose Turkish
+  # half is absent renders its English one rather than a bare newline.
+  if [ "$OUT_LANG" = tr ] && [ -n "$tr" ]; then fmt="$tr"; else fmt="$en"; fi
+  # shellcheck disable=SC2059
+  printf "$fmt\n" "$@"
+}
 
 ON=false; ma_ap_is_on && ON=true
 CONFIGURED=false; ma_ap_is_configured && CONFIGURED=true
@@ -81,40 +191,95 @@ if [ -f "$(ma_ap_root)/attempted.jsonl" ]; then
     | sort_by(-.finishedAt) | .[0:10]' "$(ma_ap_root)/attempted.jsonl" 2>/dev/null || echo '[]')
 fi
 TODAY_N=$(printf '%s' "$REPORTS" | jq 'length' 2>/dev/null || echo 0)
+
+# The operations the runner owns. The inhibitor is held when the pid its
+# record names is alive; a record left by a runner that died is not a held lock.
+AP_ROOT=$(ma_ap_root)
+INHIBITOR_HELD=false
+INH_PID=$(jq -r '.pid // empty' "$AP_ROOT/inhibitor.json" 2>/dev/null || true)
+case "$INH_PID" in
+  "" | *[!0-9]*) ;;
+  *) kill -0 "$INH_PID" 2>/dev/null && INHIBITOR_HELD=true ;;
+esac
+latest_daily() { # $1 = prefix; the newest <prefix><date>.json, or empty
+  local f last=""
+  for f in "$AP_ROOT/$1"*.json; do [ -f "$f" ] && last="$f"; done
+  printf '%s' "$last"
+}
+LAST_GC=$(latest_daily gc-report-)
+LAST_DIGEST=$(latest_daily digest-)
+# The awake agent: the launchd job that holds sleep off for as long as the mode
+# is on, read by the same script that installs and removes it.
+AWAKE='{"held":false,"display":false}'
+AWAKE_SCRIPT=$(ma_ap_asset scripts/autopilot-awake.mjs 2>/dev/null || true)
+if [ -n "$AWAKE_SCRIPT" ]; then
+  AWAKE_OUT=$(node "$AWAKE_SCRIPT" status --json 2>/dev/null || true)
+  if printf '%s' "$AWAKE_OUT" | jq -e '(.held|type=="boolean") and (.display|type=="boolean")' >/dev/null 2>&1; then
+    AWAKE=$(printf '%s' "$AWAKE_OUT" | jq -c '{held, display}')
+  fi
+fi
+AWAKE_HELD=$(printf '%s' "$AWAKE" | jq -r '.held')
+AWAKE_DISPLAY=$(printf '%s' "$AWAKE" | jq -r '.display')
+MAX_PAR=$(ma_ap_cfg '.maxParallelAgents' null 2>/dev/null || echo null)
+case "$MAX_PAR" in "" | *[!0-9]*) MAX_PAR=null ;; esac
 TODAY_USD=$(printf '%s' "$QUEUE" | jq -r '.todayUsd // 0' 2>/dev/null || echo 0)
 
 NOTE=""
 if [ "$ON" = true ]; then
-  if [ "$POWER" = "ac" ]; then NOTE="prizde, uyku engelleniyor"; else NOTE="bataryada, uyku serbest - prize takınca devam eder"; fi
+  if [ "$AWAKE_HELD" = true ] && [ "$AWAKE_DISPLAY" = true ]; then NOTE=$(msg awake-held-display)
+  elif [ "$AWAKE_HELD" = true ]; then NOTE=$(msg awake-held)
+  elif [ "$POWER" = "ac" ]; then NOTE=$(msg power-ac)
+  else NOTE=$(msg power-battery); fi
 fi
 if ma_ap_is_orphaned; then
-  NOTE="config açık ama launchd'de iş yok - /multi-agent:autopilot-on ile yeniden kur"
+  NOTE=$(msg orphaned "$(ma_ap_command autopilot-on)")
 fi
 
+STOP_COMMAND=$(ma_ap_command autopilot-off)
+
 build_json() {
   jq -nc \
     --argjson on "$ON" --argjson slots "$SLOTS" \
     --argjson running "$RUNNING" --argjson queued "$QUEUED" --argjson awaiting "$AWAITING" \
     --argjson reports "$REPORTS" --argjson todayCount "$TODAY_N" --argjson todayUsd "$TODAY_USD" \
-    --arg power "$POWER" --arg note "$NOTE" \
+    --arg power "$POWER" --arg note "$NOTE" --arg stopCommand "$STOP_COMMAND" \
     --arg emptyReason "$EMPTY_REASON" --arg blockedReason "$BLOCKED" \
     --argjson interval "$INTERVAL" --argjson spendUsd "${SPEND:-0}" \
     --argjson ceilingUsd "${CEILING_USD:-0}" \
     --argjson lastTickAt "${LAST_TICK:-null}" \
+    --argjson inhibitorHeld "$INHIBITOR_HELD" --arg lastGcReport "$LAST_GC" \
+    --arg lastDigest "$LAST_DIGEST" --argjson maxParallelAgents "$MAX_PAR" \
+    --argjson awake "$AWAKE" \
     '{on:$on, slots:$slots, running:$running, queued:$queued, awaiting:$awaiting,
       reports:$reports, todayCount:$todayCount, todayUsd:$todayUsd,
-      lastTickAt:$lastTickAt, power:$power, note:$note,
+      lastTickAt:$lastTickAt, power:$power, note:$note, stopCommand:$stopCommand,
       scanIntervalSeconds:$interval, emptyReason:$emptyReason,
-      blockedReason:$blockedReason, spendUsd:$spendUsd, ceilingUsd:$ceilingUsd}'
+      blockedReason:$blockedReason, spendUsd:$spendUsd, ceilingUsd:$ceilingUsd,
+      inhibitorHeld:$inhibitorHeld, lastGcReport:$lastGcReport, lastDigest:$lastDigest,
+      maxParallelAgents:$maxParallelAgents, awake:$awake}'
 }
 
+# The envelope, or nothing when jq could not build a JSON object from the inputs
+# (a config value of the wrong type, for one). status.json is only ever replaced
+# by a complete envelope, so the menu bar keeps its last good answer.
+ENVELOPE=$(build_json 2>/dev/null) || ENVELOPE=""
+printf '%s' "$ENVELOPE" | jq -e 'type == "object"' >/dev/null 2>&1 || ENVELOPE=""
+
 case "$MODE" in
   json)
-    build_json
+    if [ -z "$ENVELOPE" ]; then
+      printf '%s\n' '{"error":"envelope-failed","message":"autopilot-status: could not build the status envelope"}'
+      exit 3
+    fi
+    printf '%s\n' "$ENVELOPE"
     exit 0
     ;;
   write)
-    build_json | ma_ap_write status.json
+    if [ -z "$ENVELOPE" ]; then
+      echo "autopilot-status: could not build the status envelope; status.json left unchanged" >&2
+      exit 3
+    fi
+    printf '%s\n' "$ENVELOPE" | ma_ap_write status.json || exit 3
     exit 0
     ;;
 esac
@@ -125,8 +290,8 @@ esac
 # that never turned this on, `ma_ap_write` would create ~/.claude/autopilot/ and
 # quietly break the guarantee that a clean install writes nothing. Caught by
 # running this file on this machine, which then had the directory.
-if [ "$CONFIGURED" = true ]; then
-  build_json | ma_ap_write status.json 2>/dev/null || true
+if [ "$CONFIGURED" = true ] && [ -n "$ENVELOPE" ]; then
+  printf '%s\n' "$ENVELOPE" | ma_ap_write status.json 2>/dev/null || true
 fi
 
 NR=$(printf '%s' "$RUNNING" | jq 'length')
@@ -136,78 +301,78 @@ NA=$(printf '%s' "$AWAITING" | jq 'length')
 if [ "$MODE" = "subjects" ]; then
   # One line per item, with the numbers INSIDE the string: the widget takes
   # exactly one string per row, so anything the reader needs has to travel in it.
-  printf '%s' "$RUNNING" | jq -r '.[] |
-    "\(.id) · \(.depth // "full" | ascii_upcase[0:1] + .[1:]) · Faz \(.phase // "?")\(if .phaseTotal then "/\(.phaseTotal)" else "" end) \(.phaseName // "") · \(.stack // "")"'
-  printf '%s' "$AWAITING" | jq -r '.[] | "\(.id) · cevap bekliyor"'
+  printf '%s' "$RUNNING" | jq -r --arg phase "$(msg phase-word)" '.[] |
+    "\(.id) · \($phase) \(.phase // "?")\(if .phaseTotal then "/\(.phaseTotal)" else "" end) \(.phaseName // "") · \(.stack // "")"'
+  printf '%s' "$AWAITING" | jq -r --arg awaiting "$(msg awaiting-subject)" '.[] | "\(.id) · \($awaiting)"'
   exit 0
 fi
 
 if [ "$MODE" = "short" ]; then
   if [ "$ON" != true ]; then
     if [ "$CONFIGURED" = true ]; then
-      echo "autopilot: kapalı ($(ma_ap_cfg '.repos | length' 0) repo seçili)"
+      msg short-off "$(ma_ap_cfg '.repos | length' 0)"
     else
-      echo "autopilot: kurulu değil"
+      msg short-absent
     fi
     exit 0
   fi
-  echo "autopilot: açık · $NR koşuyor, $NQ sırada, $NA cevap bekliyor · $NOTE"
+  msg short-on "$NR" "$NQ" "$NA" "$NOTE"
   exit 0
 fi
 
 # --- human -------------------------------------------------------------------
 if [ "$CONFIGURED" != true ]; then
-  echo "autopilot: bu makinede kurulu değil."
-  echo "  Açmak için: /multi-agent:autopilot-on"
+  msg human-absent
+  msg human-turn-on "$(ma_ap_command autopilot-on)"
   exit 0
 fi
 
 NREPOS=$(ma_ap_cfg '.repos | length' 0)
 if [ "$ON" = true ]; then
-  echo "autopilot: AÇIK · $NREPOS repo · $SLOTS slot (bu makine $CEILING kaldırır) · her ${INTERVAL}sn tarıyor"
+  msg human-on "$NREPOS" "$SLOTS" "$CEILING" "$INTERVAL"
 else
-  echo "autopilot: KAPALI · $NREPOS repo seçili, zamanlama yok"
-  echo "  Açmak için: /multi-agent:autopilot-on"
+  msg human-off "$NREPOS"
+  msg human-turn-on "$(ma_ap_command autopilot-on)"
 fi
 [ -n "$NOTE" ] && echo "  $NOTE"
 
 echo
 if [ "$NR" -gt 0 ]; then
-  echo "Koşuyor ($NR):"
+  msg heading-running "$NR"
   printf '%s' "$RUNNING" | jq -r '.[] | "  \(.id) · \(.phaseName // .phase // "?") · \(.stack // "")"'
 fi
 if [ "$NQ" -gt 0 ]; then
-  echo "Sırada ($NQ):"
+  msg heading-queued "$NQ"
   printf '%s' "$QUEUED" | jq -r '.[0:8][] | "  \(.id)"'
 fi
 if [ "$NA" -gt 0 ]; then
-  echo "Cevap bekliyor ($NA) - açık soruları yorumladık, cevap gelince devam edecek:"
+  msg heading-awaiting "$NA"
   printf '%s' "$AWAITING" | jq -r '.[] | "  \(.id)"'
 fi
 if [ "$NR" -eq 0 ] && [ "$NQ" -eq 0 ] && [ "$NA" -eq 0 ]; then
-  echo "Sırada iş yok."
+  msg queue-empty
   # The single most common "why is nothing happening" answer, and it is not a
   # fault: no item carries the label yet. When intake recorded a more specific
   # reason, that one is truer and goes first.
   if [ -n "$EMPTY_REASON" ]; then
     echo "  $EMPTY_REASON"
   fi
-  echo "  Bir madde almasi icin: GitHub issue'ya ya da sana atanmis Jira maddesine label ekle."
+  msg queue-empty-hint
 fi
 
 # The queue refusing to take work is not the same as having none, and reading
 # one as the other is the whole reason this line exists separately.
 if [ -n "$BLOCKED" ]; then
   echo
-  echo "Yeni madde alınmıyor: $BLOCKED"
+  msg blocked "$BLOCKED"
 fi
 if [ "$CEILING_USD" != "0" ]; then
-  echo "Son 24 saat: \$$SPEND / \$$CEILING_USD"
+  msg spend "$SPEND" "$CEILING_USD"
 fi
 
 if [ "$TODAY_N" -gt 0 ]; then
   echo
-  echo "Son 24 saat ($TODAY_N PR):"
+  msg heading-reports "$TODAY_N"
   printf '%s' "$REPORTS" | jq -r '.[0:6][] | "  \(.id) · \(.url)"'
 fi
 exit 0

package/pipeline/scripts/build-lock.sh

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+#
+# build-lock.sh  -  the build queue: one xcodebuild or Gradle build at a time
+# across every worktree on this machine.
+#
+# DerivedData, simulators and the Gradle daemon contend across parallel
+# worktrees, so every ios/android build and test call sits between
+# `acquire` and `release`. The lock is a directory, because `mkdir` is atomic.
+# `owner` inside it names the task holding it on its first line and, when
+# MA_BUILD_LOCK_PID is set, the process that holds it (`pid=<n>`). The owner
+# file is written to a temporary name and renamed into place, so a reader sees
+# either no owner or a complete one.
+#
+# A waiter takes the lock over only when its holder is gone: the recorded
+# owner process no longer exists, the owner file is older than the stale limit,
+# or there is no owner file and the lock directory is older than the grace
+# window (the holder crashed between `mkdir` and writing its owner).
+#
+# Two separate calls, so the build itself stays a command the caller runs (and
+# the unattended guard judges) on its own:
+#   bash build-lock.sh acquire <task-id>
+#   xcodebuild ... 2>&1 | tail -5
+#   bash build-lock.sh release <task-id>
+# `release` removes the lock only when <task-id> matches its owner.
+#
+# Environment: MA_BUILD_LOCK (default /tmp/claude-xcodebuild.lock),
+# MA_BUILD_LOCK_STALE_SEC (default 900), MA_BUILD_LOCK_POLL_SEC (default 5),
+# MA_BUILD_LOCK_GRACE_SEC (default 5), MA_BUILD_LOCK_PID (owner process, optional).
+#
+# Exit: 0 acquired or released, 1 release refused (lock held by another task),
+# 2 usage.
+set -uo pipefail
+
+BUILD_LOCK="${MA_BUILD_LOCK:-/tmp/claude-xcodebuild.lock}"
+STALE_SEC="${MA_BUILD_LOCK_STALE_SEC:-900}"
+POLL_SEC="${MA_BUILD_LOCK_POLL_SEC:-5}"
+GRACE_SEC="${MA_BUILD_LOCK_GRACE_SEC:-5}"
+
+# GNU first: `stat -f` is a valid GNU flag (file-system status) that succeeds
+# with the wrong answer, so BSD-first would silently win on Linux.
+mtime() {
+  stat -c "%Y" "$1" 2>/dev/null || stat -f "%m" "$1" 2>/dev/null || echo 0
+}
+
+owner_task() {
+  head -n 1 "$BUILD_LOCK/owner" 2>/dev/null
+}
+
+owner_pid() {
+  sed -n 's/^pid=\([0-9][0-9]*\)$/\1/p' "$BUILD_LOCK/owner" 2>/dev/null | head -n 1
+}
+
+# Prints the reason the current lock may be taken over, or nothing.
+takeover_reason() {
+  local now pid age
+  now=$(date +%s)
+  if [ ! -f "$BUILD_LOCK/owner" ]; then
+    age=$((now - $(mtime "$BUILD_LOCK")))
+    [ -d "$BUILD_LOCK" ] && [ "$age" -gt "$GRACE_SEC" ] && echo "no owner after ${age}s"
+    return 0
+  fi
+  pid=$(owner_pid)
+  if [ -n "$pid" ] && ! kill -0 "$pid" 2>/dev/null; then
+    echo "owner process $pid is gone"
+    return 0
+  fi
+  age=$((now - $(mtime "$BUILD_LOCK/owner")))
+  [ "$age" -gt "$STALE_SEC" ] && echo "stale (${age}s)"
+  return 0
+}
+
+write_owner() {
+  local tmp="$BUILD_LOCK/.owner.$$"
+  {
+    printf '%s\n' "$1"
+    if [ -n "${MA_BUILD_LOCK_PID:-}" ]; then printf 'pid=%s\n' "$MA_BUILD_LOCK_PID"; fi
+  } >"$tmp" && mv -f "$tmp" "$BUILD_LOCK/owner"
+}
+
+case "${1:-}" in
+  acquire)
+    task="${2:-unknown}"
+    while ! mkdir "$BUILD_LOCK" 2>/dev/null; do
+      judged=$(cat "$BUILD_LOCK/owner" 2>/dev/null || echo "")
+      reason=$(takeover_reason)
+      if [ -n "$reason" ]; then
+        current=$(cat "$BUILD_LOCK/owner" 2>/dev/null || echo "")
+        if [ "$current" = "$judged" ]; then
+          echo "Taking over the build lock: $reason"
+          trash="$BUILD_LOCK.stale.$$"
+          mv "$BUILD_LOCK" "$trash" 2>/dev/null && rm -rf "$trash"
+        fi
+        continue
+      fi
+      owner=$(owner_task)
+      age=$(($(date +%s) - $(mtime "$BUILD_LOCK/owner")))
+      echo "Build queue: waiting (${owner:-unknown}, ${age}s)"
+      sleep "$POLL_SEC"
+    done
+    write_owner "$task"
+    ;;
+  release)
+    task="${2:-}"
+    if [ -z "$task" ]; then
+      echo "usage: build-lock.sh release <task-id>" >&2
+      exit 2
+    fi
+    [ -d "$BUILD_LOCK" ] || exit 0
+    owner=$(owner_task)
+    if [ "$owner" != "$task" ]; then
+      echo "build lock is held by ${owner:-an unknown owner}, not $task; left in place" >&2
+      exit 1
+    fi
+    rm -rf "$BUILD_LOCK"
+    ;;
+  *)
+    echo "usage: build-lock.sh acquire <task-id> | release <task-id>" >&2
+    exit 2
+    ;;
+esac

package/pipeline/scripts/build-references.mjs

@@ -23,6 +23,7 @@
 
 import { readFileSync } from "node:fs";
 import { runMain } from "../lib/fatal.mjs";
+import { outputLanguage } from "../lib/user-facing.mjs";
 
 const HEADERS = {
   tr: ["Tür", "Kaynak", "URL / Yol", "Sürüm / Ref", "Rol", "Erişim", "Notlar"],
@@ -352,7 +353,9 @@ function main() {
     return;
   }
 
-  const lang = argOf(argv, "--lang") ?? spec.language ?? "tr";
+  // The table is part of an analysis document a person reads, so the language
+  // is the run's own when the state records one and the preference otherwise.
+  const lang = argOf(argv, "--lang") ?? spec.language ?? outputLanguage();
   if (!HEADERS[lang]) {
     process.stderr.write(`ERROR: unknown language "${lang}"; expected tr or en\n`);
     process.exitCode = 2;

package/pipeline/scripts/build-stack-plugins.mjs

@@ -18,10 +18,17 @@
  * ai-analyst-toolkit (neither is copied into each stack plugin). Apple/
  * Xcode-only vendored skills that match no stack pattern belong to iOS only.
  *
+ * A vendored skill ships beside its upstream's NOTICE-*.md. Before anything is
+ * written, every NOTICE's `## Skills (N)` list is checked against the skills'
+ * `metadata.source` lines (_notices.mjs); a vendored skill no NOTICE lists stops
+ * the build, so an unattributed copy is never published.
+ *
  * Usage:
  *   node build-stack-plugins.mjs [--plugins-repo <path>] [--pipeline <path>] [--dry-run]
+ *   node build-stack-plugins.mjs --check-routing | --check-notices
  *
- * Exit code 0 always (report-only); prints a JSON-ish summary + per-plugin diff.
+ * Exit code 0 on a build, 1 when the attribution check fails or a --check-* mode
+ * finds a problem; prints a JSON-ish summary + per-plugin diff.
  */
 import {
   readdirSync,
@@ -58,11 +65,10 @@ const getArg = (k, d) => {
   }
   return v;
 };
-// HOME is unset on Windows (USERPROFILE is the variable); fall back so join()
-// gets a string instead of throwing a raw TypeError before any diagnostic.
-const HOME = process.env.HOME || process.env.USERPROFILE;
+// Checked up front so join() never throws a raw TypeError before any diagnostic.
+const HOME = process.env.HOME;
 if (!HOME) {
-  console.error("ERROR: neither HOME nor USERPROFILE is set; cannot resolve default paths.");
+  console.error("ERROR: HOME is not set; cannot resolve default paths.");
   process.exit(2);
 }
 const PLUGINS_REPO = getArg("--plugins-repo", join(HOME, "multi-agent-plugins"));
@@ -85,6 +91,7 @@ import {
   STACK_ONLY,
   STACK_PATTERNS,
 } from "./_stack-routing.mjs";
+import { NOTICE_FILE, noticeProblems, readNotices } from "./_notices.mjs";
 
 const isDir = (p) => {
   try {
@@ -209,7 +216,24 @@ if (args.includes("--check-routing")) {
   process.exit(0);
 }
 
+// --- 2c. attribution audit ----------------------------------------------
+const attribution = noticeProblems(EXTERNAL);
+if (attribution.length) {
+  console.error(`check-notices: ${attribution.length} attribution problem(s); nothing was written`);
+  for (const a of attribution) console.error(`  FAIL ${a}`);
+  console.error(
+    'fix: list each vendored skill in its NOTICE-*.md "## Skills (N)" section, with a matching metadata.source',
+  );
+  process.exit(1);
+}
+if (args.includes("--check-notices")) {
+  console.log(`check-notices: clean (${readNotices(EXTERNAL).length} NOTICE files)`);
+  process.exit(0);
+}
+
 // --- 3. sync each plugin's knowledge/ + regenerate plugin.json -----------
+// A NOTICE covers exactly the skills its `## Skills (N)` section lists.
+const noticeFiles = readNotices(EXTERNAL);
 const report = [];
 for (const [plugin, want] of Object.entries(desired)) {
   const pdir = join(PLUGINS_REPO, "plugins", plugin);
@@ -226,23 +250,12 @@ for (const [plugin, want] of Object.entries(desired)) {
   const setChanged = toAdd.length > 0 || toRemove.length > 0;
 
   // Compare EVERY wanted skill against the source, not just the newly added
-  // ones, and replace (rm + copy) rather than overlay.
-  //
-  // This used to copy only on a set change, which quietly broke the single-source
-  // claim: editing a skill in shared/external left the plugin serving the old text
-  // forever, because the set had not changed. Found by editing a promoted skill and
-  // seeing the plugin copy stay stale while the generator reported "all plugins up
-  // to date".
-  //
-  // The rm-before-copy matters too: cpSync overlays and never deletes, so a file
-  // REMOVED inside a still-wanted skill survived in every plugin copy forever -
-  // and because the overlay kept the orphan on both sides of the fingerprint
-  // comparison, the version was not bumped either.
-  // Detect content drift in BOTH modes so --dry-run (the pre-flight for a
-  // destructive run) reports the same "would change" verdict a real run acts on.
-  // Previously contentChanged was computed only inside `if (!DRY)`, so dry-run
-  // was blind to a file edit that did not change set membership - exactly the
-  // case the fingerprint machinery was added to catch.
+  // ones: an edit inside a skill changes no set membership, and the plugin has to
+  // serve the edited text all the same. Replace (rm + copy) rather than overlay,
+  // because cpSync never deletes, so a file removed from a still-wanted skill
+  // would survive in the plugin copy and sit on both sides of the fingerprint.
+  // Drift is detected in BOTH modes so --dry-run, the pre-flight for a
+  // destructive run, reports the verdict a real run acts on.
   if (!DRY && !existsSync(kdir)) mkdirSync(kdir, { recursive: true });
   let contentChanged = false;
   for (const s of want) {
@@ -258,6 +271,30 @@ for (const [plugin, want] of Object.entries(desired)) {
   if (!DRY) {
     for (const s of toRemove) rmSync(join(kdir, s), { recursive: true, force: true });
   }
+
+  // A vendored skill ships with its upstream's notice. A plugin carries every
+  // NOTICE that lists one of its skills and none that lists none of them.
+  for (const notice of noticeFiles) {
+    const to = join(kdir, notice.file);
+    const needed = [...want].some((sk) => notice.skills.has(sk));
+    const present = existsSync(to);
+    if (needed) {
+      if (present && readFileSync(to).equals(notice.bytes)) continue;
+      contentChanged = true;
+      if (!DRY) writeFileSync(to, notice.bytes);
+    } else if (present) {
+      contentChanged = true;
+      if (!DRY) rmSync(to, { force: true });
+    }
+  }
+  // A notice whose source file was deleted is in no list above, so it is found
+  // by what the plugin holds rather than by what the source names.
+  const sourceNotices = new Set(noticeFiles.map((n) => n.file));
+  for (const file of existsSync(kdir) ? readdirSync(kdir) : []) {
+    if (!NOTICE_FILE.test(file) || sourceNotices.has(file)) continue;
+    contentChanged = true;
+    if (!DRY) rmSync(join(kdir, file), { force: true });
+  }
   const changed = setChanged || contentChanged;
 
   // regenerate plugin.json skills[]: keep non-knowledge entries, rebuild knowledge set

package/pipeline/scripts/capture-flush.sh

@@ -62,7 +62,7 @@ while [ "$#" -gt 0 ]; do
   esac
 done
 
-LOGS="$HOME/.claude/logs/multi-agent"
+LOGS="${LOGS_ROOT:-$HOME/.claude/logs/multi-agent}"
 SCRIPTS="$HOME/.claude/scripts"
 [ -d "$SCRIPTS" ] || SCRIPTS="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"