@drunkcoding/agents-and-skills 0.0.17 → 0.0.19

package/plugins/team-superpower/hooks/task-completed.sh

@@ -53,6 +53,209 @@ case "$title" in
     ;;
 esac
 
+# v3: wave metadata. impl:* tasks must carry a `wave:` integer (planner sets
+# it; the lead mirrors it into shared-task-list metadata at dispatch time).
+case "$title" in
+  impl:*)
+    wave="$(printf '%s' "$payload" | jq -r '.task.metadata.wave // .metadata.wave // ""' 2>/dev/null || echo "")"
+    if [ -z "$wave" ] || ! printf '%s' "$wave" | grep -qE '^[0-9]+$'; then
+      printf '{"ts":"%s","hook":"task-completed","warn":"MISSING_WAVE_METADATA","title":%s}\n' \
+        "$ts" "$(printf '%s' "$title" | jq -Rs .)" >> "$LOG_FILE"
+    fi
+    ;;
+esac
+
+# v3: MAX_ITERATIONS guardrail. impl:* completions whose iteration_count
+# exceeds the per-project cap (default 8) must carry a reflection: block.
+case "$title" in
+  impl:*)
+    iteration_count="$(printf '%s' "$payload" | jq -r '.task.metadata.iteration_count // .metadata.iteration_count // 0' 2>/dev/null || echo 0)"
+    reflection="$(printf '%s' "$payload" | jq -r '.task.metadata.reflection // .metadata.reflection // ""' 2>/dev/null || echo "")"
+
+    cap=8
+    parse_helper="${CLAUDE_PLUGIN_ROOT:-}/scripts/parse-claudemd.sh"
+    if [ -z "${CLAUDE_PLUGIN_ROOT:-}" ]; then
+      # Fall back to a relative path the hook can find when CLAUDE_PLUGIN_ROOT is unset.
+      hook_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+      parse_helper="$hook_dir/../scripts/parse-claudemd.sh"
+    fi
+    if [ -f "$parse_helper" ] && [ -f "${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md" ]; then
+      configured="$(bash "$parse_helper" get limits.max_iterations_per_task "${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md" 2>/dev/null || true)"
+      if [ -n "$configured" ] && printf '%s' "$configured" | grep -qE '^[0-9]+$'; then
+        cap="$configured"
+      fi
+    fi
+
+    if [ "${iteration_count:-0}" -gt "$cap" ] && [ -z "$reflection" ]; then
+      printf '{"ts":"%s","hook":"task-completed","warn":"ITERATION_CAP_EXCEEDED","title":%s,"iteration_count":%d,"cap":%d}\n' \
+        "$ts" \
+        "$(printf '%s' "$title" | jq -Rs .)" \
+        "$iteration_count" \
+        "$cap" \
+        >> "$LOG_FILE"
+    fi
+    ;;
+esac
+
+# v4: per-task QA verification. impl:* completions must carry
+# `qa_verified_at:` metadata AND a `QA-verified: round=N` line in at least one
+# commit message body (N ≤ max_qa_rounds_per_task, default 3). The hook also
+# rejects `trivial=true` claims for diffs >20 lines or new-file additions, and
+# rejects `qa_rounds: 3` escalations missing the cross-role fields.
+case "$title" in
+  impl:*)
+    qa_verified_at="$(printf '%s' "$payload" | jq -r '.task.metadata.qa_verified_at // .metadata.qa_verified_at // ""' 2>/dev/null || echo "")"
+    qa_rounds="$(printf '%s' "$payload" | jq -r '.task.metadata.qa_rounds // .metadata.qa_rounds // 0' 2>/dev/null || echo 0)"
+    trivial_claim="$(printf '%s' "$payload" | jq -r '.task.metadata.trivial // .metadata.trivial // false' 2>/dev/null || echo false)"
+
+    qa_cap=3
+    if [ -f "$parse_helper" ] && [ -f "${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md" ]; then
+      configured_qa="$(bash "$parse_helper" get limits.max_qa_rounds_per_task "${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md" 2>/dev/null || true)"
+      if [ -n "$configured_qa" ] && printf '%s' "$configured_qa" | grep -qE '^[0-9]+$'; then
+        qa_cap="$configured_qa"
+      fi
+    fi
+
+    # Check 7a: qa_verified_at metadata present.
+    if [ -z "$qa_verified_at" ]; then
+      printf '{"ts":"%s","hook":"task-completed","warn":"MISSING_QA_VERIFICATION","title":%s,"reason":"qa_verified_at metadata missing"}\n' \
+        "$ts" "$(printf '%s' "$title" | jq -Rs .)" >> "$LOG_FILE"
+    fi
+
+    # Check 7b: QA-verified: round=N commit body line, verified via git log if commits recorded.
+    if command -v git >/dev/null 2>&1; then
+      qa_commits="$(printf '%s' "$payload" | jq -r '(.task.metadata.commits // .metadata.commits // [])[]?' 2>/dev/null || true)"
+      if [ -n "$qa_commits" ]; then
+        qa_line_found=0
+        qa_round_observed=0
+        while IFS= read -r sha; do
+          [ -z "$sha" ] && continue
+          body="$(git show --no-color --no-patch --format=%B "$sha" 2>/dev/null || true)"
+          line="$(printf '%s\n' "$body" | grep -E '^QA-verified:[[:space:]]*round=[0-9]+' | head -n1 || true)"
+          if [ -n "$line" ]; then
+            qa_line_found=1
+            n="$(printf '%s' "$line" | sed -nE 's/^QA-verified:[[:space:]]*round=([0-9]+).*/\1/p')"
+            if [ -n "$n" ] && [ "$n" -gt "$qa_round_observed" ]; then
+              qa_round_observed="$n"
+            fi
+          fi
+        done <<< "$qa_commits"
+        if [ "$qa_line_found" -ne 1 ]; then
+          printf '{"ts":"%s","hook":"task-completed","warn":"MISSING_QA_VERIFICATION","title":%s,"reason":"no QA-verified line in commit body"}\n' \
+            "$ts" "$(printf '%s' "$title" | jq -Rs .)" >> "$LOG_FILE"
+        elif [ "$qa_round_observed" -gt "$qa_cap" ]; then
+          printf '{"ts":"%s","hook":"task-completed","warn":"QA_ROUND_OVER_CAP","title":%s,"round":%d,"cap":%d}\n' \
+            "$ts" "$(printf '%s' "$title" | jq -Rs .)" "$qa_round_observed" "$qa_cap" >> "$LOG_FILE"
+        fi
+      fi
+    fi
+
+    # Check 8: qa_rounds at cap requires §7 cross-role escalation.
+    if [ "${qa_rounds:-0}" -ge "$qa_cap" ] && [ -z "$qa_verified_at" ]; then
+      # An escalation entry tagged class:cross-role with qa_rounds, what_failed, one_change_to_fix must be present.
+      escalation_ok=0
+      escalation_entries="$(printf '%s' "$payload" | jq -c '(.task.metadata.blocked_questions // .metadata.blocked_questions // [])[]?' 2>/dev/null || true)"
+      if [ -n "$escalation_entries" ]; then
+        while IFS= read -r entry; do
+          [ -z "$entry" ] && continue
+          raw="$(printf '%s' "$entry" | jq -r '.' 2>/dev/null || printf '%s' "$entry")"
+          if printf '%s' "$raw" | grep -qE 'class[[:space:]]*:[[:space:]]*cross-role' \
+            && printf '%s' "$raw" | grep -qE 'qa_rounds[[:space:]]*:' \
+            && printf '%s' "$raw" | grep -qE 'what_failed[[:space:]]*:' \
+            && printf '%s' "$raw" | grep -qE 'one_change_to_fix[[:space:]]*:'; then
+            escalation_ok=1
+            break
+          fi
+        done <<< "$escalation_entries"
+      fi
+      if [ "$escalation_ok" -ne 1 ]; then
+        printf '{"ts":"%s","hook":"task-completed","warn":"QA_CAP_EXCEEDED","title":%s,"qa_rounds":%d,"cap":%d}\n' \
+          "$ts" "$(printf '%s' "$title" | jq -Rs .)" "$qa_rounds" "$qa_cap" >> "$LOG_FILE"
+      fi
+    fi
+
+    # Pre-check: INVALID_TRIVIAL_CLAIM — trivial=true requires diff ≤20 lines AND no new files.
+    if [ "$trivial_claim" = "true" ] && command -v git >/dev/null 2>&1; then
+      tc_commits="$(printf '%s' "$payload" | jq -r '(.task.metadata.commits // .metadata.commits // [])[]?' 2>/dev/null || true)"
+      tc_added=0
+      tc_lines=0
+      if [ -n "$tc_commits" ]; then
+        while IFS= read -r sha; do
+          [ -z "$sha" ] && continue
+          st="$(git show --no-color --name-status --pretty=format: "$sha" 2>/dev/null || true)"
+          if printf '%s\n' "$st" | grep -qE '^A[[:space:]]'; then
+            tc_added=1
+          fi
+          n="$(git show --no-color --shortstat --pretty=format: "$sha" 2>/dev/null | grep -oE '[0-9]+ insertion' | head -n1 | grep -oE '[0-9]+' || echo 0)"
+          tc_lines=$((tc_lines + ${n:-0}))
+        done <<< "$tc_commits"
+        if [ "$tc_added" -eq 1 ] || [ "$tc_lines" -gt 20 ]; then
+          printf '{"ts":"%s","hook":"task-completed","warn":"INVALID_TRIVIAL_CLAIM","title":%s,"added_files":%d,"insertions":%d}\n' \
+            "$ts" "$(printf '%s' "$title" | jq -Rs .)" "$tc_added" "$tc_lines" >> "$LOG_FILE"
+        fi
+      fi
+    fi
+    ;;
+esac
+
+# v4: retrieval budget. impl:* tasks may not exceed `retrieval_budget_per_task`
+# (default 2). Also: a `Flagged-assumptions:` line in a commit body is only
+# permitted when retrieval_requests == budget (cannot flag assumptions
+# prematurely without exhausting the budget).
+case "$title" in
+  impl:*)
+    retrieval_requests="$(printf '%s' "$payload" | jq -r '.task.metadata.retrieval_requests // .metadata.retrieval_requests // 0' 2>/dev/null || echo 0)"
+    retrieval_cap=2
+    if [ -f "$parse_helper" ] && [ -f "${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md" ]; then
+      configured_r="$(bash "$parse_helper" get limits.retrieval_budget_per_task "${CLAUDE_PROJECT_DIR:-$PWD}/CLAUDE.md" 2>/dev/null || true)"
+      if [ -n "$configured_r" ] && printf '%s' "$configured_r" | grep -qE '^[0-9]+$'; then
+        retrieval_cap="$configured_r"
+      fi
+    fi
+
+    if [ "${retrieval_requests:-0}" -gt "$retrieval_cap" ]; then
+      printf '{"ts":"%s","hook":"task-completed","warn":"RETRIEVAL_BUDGET_EXCEEDED","title":%s,"requests":%d,"cap":%d}\n' \
+        "$ts" "$(printf '%s' "$title" | jq -Rs .)" "$retrieval_requests" "$retrieval_cap" >> "$LOG_FILE"
+    fi
+
+    if command -v git >/dev/null 2>&1; then
+      r_commits="$(printf '%s' "$payload" | jq -r '(.task.metadata.commits // .metadata.commits // [])[]?' 2>/dev/null || true)"
+      if [ -n "$r_commits" ]; then
+        flagged=0
+        while IFS= read -r sha; do
+          [ -z "$sha" ] && continue
+          body="$(git show --no-color --no-patch --format=%B "$sha" 2>/dev/null || true)"
+          if printf '%s\n' "$body" | grep -qE '^Flagged-assumptions:'; then
+            flagged=1; break
+          fi
+        done <<< "$r_commits"
+        if [ "$flagged" -eq 1 ] && [ "${retrieval_requests:-0}" -lt "$retrieval_cap" ]; then
+          printf '{"ts":"%s","hook":"task-completed","warn":"PREMATURE_ASSUMPTION_FLAG","title":%s,"requests":%d,"cap":%d}\n' \
+            "$ts" "$(printf '%s' "$title" | jq -Rs .)" "$retrieval_requests" "$retrieval_cap" >> "$LOG_FILE"
+        fi
+      fi
+    fi
+    ;;
+esac
+
+# v4: AGENTS.md protection. Agents never write to docs/superpowers/AGENTS.md.
+# Reviewer writes only to docs/superpowers/AGENTS.suggestions.md. If any commit
+# on this task touches AGENTS.md, warn AGENT_WROTE_AGENTS_MD — the owner is the
+# only role that may promote suggestions to AGENTS.md.
+if command -v git >/dev/null 2>&1; then
+  agm_commits="$(printf '%s' "$payload" | jq -r '(.task.metadata.commits // .metadata.commits // [])[]?' 2>/dev/null || true)"
+  if [ -n "$agm_commits" ]; then
+    while IFS= read -r sha; do
+      [ -z "$sha" ] && continue
+      files="$(git show --no-color --name-only --pretty=format: "$sha" 2>/dev/null || true)"
+      if printf '%s\n' "$files" | grep -qE '^docs/superpowers/AGENTS\.md$'; then
+        printf '{"ts":"%s","hook":"task-completed","warn":"AGENT_WROTE_AGENTS_MD","title":%s,"sha":%s}\n' \
+          "$ts" "$(printf '%s' "$title" | jq -Rs .)" "$(printf '%s' "$sha" | jq -Rs .)" >> "$LOG_FILE"
+      fi
+    done <<< "$agm_commits"
+  fi
+fi
+
 # v2: migration serialization. If this is a migration task, verify no other
 # `impl:be-migration-*` task is currently in_progress in the shared task list
 # (payload.tasks[]). The lead also enforces this; the hook is a backstop.

package/plugins/team-superpower/hooks/task-created.sh

@@ -59,10 +59,17 @@ if [ -d "$SESSIONS_DIR" ]; then
   fi
 fi
 
-printf '{"ts":"%s","hook":"task-created","title":%s,"shape":%s}\n' \
+wave="$(printf '%s' "$payload" | jq -r '.task.metadata.wave // .metadata.wave // ""' 2>/dev/null || echo "")"
+wave_json="null"
+if printf '%s' "$wave" | grep -qE '^[0-9]+$'; then
+  wave_json="$wave"
+fi
+
+printf '{"ts":"%s","hook":"task-created","title":%s,"shape":%s,"wave":%s}\n' \
   "$ts" \
   "$(printf '%s' "$title" | jq -Rs .)" \
   "$(printf '%s' "$shape" | jq -Rs .)" \
+  "$wave_json" \
   >> "$LOG_FILE"
 
 # Top-level prefix check
@@ -77,6 +84,40 @@ case "$title" in
     ;;
 esac
 
+# v3: solo-mode guard. If checkpoint mode is solo, impl:* tasks are invalid
+# (solo means the lead does the work itself; no implementer is spawned).
+mode_meta="$(printf '%s' "$payload" | jq -r '.task.metadata.mode // .metadata.mode // ""' 2>/dev/null || echo "")"
+mode_marker=""
+if [ -z "$mode_meta" ] && [ -d "$SESSIONS_DIR" ]; then
+  # Look for a <slug>.mode file the lead writes when it picks a mode.
+  marker_file=""
+  if [ -n "$slug" ] && [ -f "$SESSIONS_DIR/$slug.mode" ]; then
+    marker_file="$SESSIONS_DIR/$slug.mode"
+  else
+    count="$(find "$SESSIONS_DIR" -maxdepth 1 -type f -name '*.mode' 2>/dev/null | wc -l | tr -d ' ')"
+    if [ "$count" = "1" ]; then
+      marker_file="$(find "$SESSIONS_DIR" -maxdepth 1 -type f -name '*.mode' 2>/dev/null | head -n1)"
+    fi
+  fi
+  if [ -n "$marker_file" ] && [ -f "$marker_file" ]; then
+    mode_marker="$(head -n1 "$marker_file" | tr -d '[:space:]')"
+  fi
+fi
+effective_mode="${mode_meta:-$mode_marker}"
+
+case "$title" in
+  impl:*)
+    if [ "$effective_mode" = "solo" ]; then
+      printf '{"ts":"%s","hook":"task-created","warn":"INVALID_FOR_SOLO_MODE","title":%s}\n' \
+        "$ts" "$(printf '%s' "$title" | jq -Rs .)" >> "$LOG_FILE"
+    fi
+    if [ -z "$wave" ]; then
+      printf '{"ts":"%s","hook":"task-created","warn":"MISSING_WAVE_METADATA","title":%s}\n' \
+        "$ts" "$(printf '%s' "$title" | jq -Rs .)" >> "$LOG_FILE"
+    fi
+    ;;
+esac
+
 # At this point title starts with `impl:`. Strip prefix and require a known
 # sub-prefix.
 rest="${title#impl:}"

package/plugins/team-superpower/scripts/assess-complexity.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# assess-complexity.sh — encode the team-superpower v3 heuristic ladder.
+#
+# Inputs:
+#   $1 — owner's launch message (required)
+#   $2 — repo root (optional, default $PWD); reads CLAUDE.md's
+#        security.domain to bias size and stack to seed `shape:`.
+#
+# Output: YAML on stdout. Always emits `mode:`, `shape:`, `mode_reasoning:`.
+# Emits `size:` only when mode == team.
+#
+# Exit codes:
+#   0 — confident decision
+#   1 — ambiguous (mode could plausibly be single-agent OR team; defaults to
+#       team and notes the ambiguity in mode_reasoning).
+#
+# This script never spawns or writes outside stdout. The lead handles writes.
+
+set -euo pipefail
+
+if [ "${1:-}" = "" ]; then
+  echo "usage: assess-complexity.sh <launch-message> [repo-root]" >&2
+  exit 2
+fi
+
+MSG="$1"
+ROOT="${2:-$PWD}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DETECT="$SCRIPT_DIR/detect-stack.sh"
+PARSE="$SCRIPT_DIR/parse-claudemd.sh"
+
+lc="$(printf '%s' "$MSG" | tr '[:upper:]' '[:lower:]')"
+length="${#MSG}"
+
+# --- Discovery / size keyword tables --------------------------------------
+
+discovery_keywords=(
+  "design" "architecture" "system" "flow" "feature" "epic" "refactor"
+  "migrate" "migrate to" "replace with" "replace" "rewrite" "redesign"
+  "overhaul"
+)
+
+trivial_keywords=(
+  "fix typo" "typo in" "rename" "rename variable" "update copy"
+  "update text" "change wording" "bump version" "update readme"
+  "comment out" "add comment" "remove unused" "format" "prettify"
+  "lint fix"
+)
+
+tiny_scope_phrases=(
+  "one line" "single line" "one file" "just change" "quick fix"
+  "tiny" "trivial"
+)
+
+small_scope_verbs=(
+  "add" "create" "new " "introduce" "fix"
+)
+
+small_scope_nouns=(
+  "endpoint" "/" "component" "field" "column" "validation"
+  "bug" "error" "test" "migration" "button" "page" "route"
+  "controller" "service"
+)
+
+regulated_keywords=(
+  "compliance" "audit" "regulatory" "pii" "pci" "gdpr" "hipaa"
+)
+
+low_stakes_keywords=(
+  "prototype" "spike" "internal-only" "experiment" "poc"
+)
+
+team_request_keywords=(
+  "team" "agents" "full feature"
+)
+
+contains_any() {
+  # contains_any <text-lc> <array-name>
+  # Compatible with Bash 3.2 (no namerefs).
+  local txt="$1"
+  local arr_name="$2"
+  eval 'local kw; for kw in "${'"$arr_name"'[@]}"; do
+    case "$txt" in *"$kw"*) return 0 ;; esac
+  done'
+  return 1
+}
+
+# Rung 1: trivial / tiny-scope / single named file
+single_file_match=0
+# Detect a single path literal in the message (very rough: looks like x/y or x.y).
+if printf '%s' "$MSG" | grep -qE '(^|[[:space:]])[A-Za-z0-9_./-]+\.[A-Za-z0-9]+([[:space:]]|$)'; then
+  # Count distinct file-ish tokens; if exactly 1, treat as named file.
+  count="$(printf '%s\n' "$MSG" | grep -oE '(^|[[:space:]])[A-Za-z0-9_./-]+\.[A-Za-z0-9]+([[:space:]]|$)' | tr -d '[:space:]' | sort -u | wc -l | tr -d ' ')"
+  if [ "$count" = "1" ]; then single_file_match=1; fi
+fi
+
+solo=0
+solo_why=""
+if contains_any "$lc" trivial_keywords; then solo=1; solo_why="trivial keyword match";
+elif contains_any "$lc" tiny_scope_phrases; then solo=1; solo_why="tiny-scope phrase match";
+elif [ "$single_file_match" = "1" ]; then solo=1; solo_why="single named file in message";
+fi
+
+# Rung 2: small-scope + single-side + no discovery language
+side="none"
+if [ -x "$DETECT" ] || [ -f "$DETECT" ]; then
+  side="$(bash "$DETECT" detect-side "$MSG" 2>/dev/null || echo none)"
+fi
+single_agent=0
+single_agent_why=""
+if [ "$solo" = "0" ]; then
+  if contains_any "$lc" small_scope_verbs \
+     && contains_any "$lc" small_scope_nouns \
+     && { [ "$side" = "be-only" ] || [ "$side" = "fe-only" ]; } \
+     && ! contains_any "$lc" discovery_keywords; then
+    single_agent=1
+    single_agent_why="small-scope verb+noun + single-side ($side) + no discovery language"
+  fi
+fi
+
+# Rung 3: team (default)
+verb_count=0
+# Cheap multi-verb heuristic: count occurrences of " and " between action words.
+verb_count="$(printf '%s' "$lc" | { grep -oE '[[:space:]]and[[:space:]]' || true; } | wc -l | tr -d ' ')"
+long_message=0
+if [ "$length" -gt 200 ]; then long_message=1; fi
+
+team=0
+team_why=""
+if [ "$solo" = "0" ] && [ "$single_agent" = "0" ]; then
+  team=1
+  if [ "$side" = "mixed" ]; then team_why="multi-side signal (BE+FE)";
+  elif contains_any "$lc" discovery_keywords; then team_why="discovery language match";
+  elif [ "$verb_count" -ge 1 ]; then team_why="multi-verb message ($verb_count 'and' joiners)";
+  elif [ "$long_message" = "1" ]; then team_why="long message (>200 chars)";
+  elif contains_any "$lc" team_request_keywords; then team_why="explicit team request";
+  else team_why="rung-1 and rung-2 did not match; defaulting to team";
+  fi
+fi
+
+# Resolve mode
+if [ "$solo" = "1" ]; then mode="solo"; reason="Rung 1 matched: $solo_why."
+elif [ "$single_agent" = "1" ]; then mode="single-agent"; reason="Rung 2 matched: $single_agent_why."
+else mode="team"; reason="Rung 3 matched: $team_why."
+fi
+
+# Size (team only)
+size=""
+size_why=""
+if [ "$mode" = "team" ]; then
+  domain=""
+  if [ -f "$ROOT/CLAUDE.md" ] && [ -f "$PARSE" ]; then
+    domain="$(bash "$PARSE" get security.domain "$ROOT/CLAUDE.md" 2>/dev/null || true)"
+  fi
+  if [ "$domain" = "payments" ] || [ "$domain" = "healthcare" ]; then
+    size="full"; size_why="security.domain=$domain"
+  elif contains_any "$lc" regulated_keywords; then
+    size="full"; size_why="regulated keyword match"
+  elif contains_any "$lc" low_stakes_keywords; then
+    size="minimal"; size_why="low-stakes keyword match"
+  else
+    size="standard"; size_why="default"
+  fi
+fi
+
+# Shape: prefer CLAUDE.md, fall back to mixed.
+shape=""
+if [ -f "$ROOT/CLAUDE.md" ] && [ -f "$PARSE" ]; then
+  shape="$(bash "$PARSE" shape "$ROOT/CLAUDE.md" 2>/dev/null || true)"
+fi
+if [ -z "$shape" ] || [ "$shape" = "none" ]; then
+  # Fall back to side detection: mixed → full-stack; be-only / fe-only as-is.
+  case "$side" in
+    mixed) shape="full-stack" ;;
+    be-only) shape="be-only" ;;
+    fe-only) shape="fe-only" ;;
+    *) shape="full-stack" ;;
+  esac
+fi
+
+# Emit
+printf 'mode: %s\n' "$mode"
+if [ "$mode" = "team" ]; then
+  printf 'size: %s\n' "$size"
+fi
+printf 'shape: %s\n' "$shape"
+printf 'mode_reasoning: |\n'
+printf '  %s\n' "$reason"
+if [ "$mode" = "team" ]; then
+  printf '  Size: %s — %s.\n' "$size" "$size_why"
+fi
+printf '  side_signal: %s; verb_joiners: %d; length: %d chars.\n' "$side" "$verb_count" "$length"
+
+exit 0

package/plugins/team-superpower/scripts/detect-stack.sh

@@ -22,6 +22,45 @@
 
 set -euo pipefail
 
+# ---- subcommand: detect-side ---------------------------------------------
+# Usage:
+#   bash detect-stack.sh detect-side "<launch message>"
+# Outputs one of: be-only | fe-only | mixed | none
+# Used by scripts/assess-complexity.sh for the rung-2 single-side signal.
+if [ "${1:-}" = "detect-side" ]; then
+  shift
+  text="${1:-}"
+  # Normalize to lowercase for case-insensitive matching.
+  lc="$(printf '%s' "$text" | tr '[:upper:]' '[:lower:]')"
+
+  be_keywords=(
+    "endpoint" "api" "/api" "/auth" "/health" "route" "controller" "service"
+    "repository" "schema" "migration" "database" "column" "table"
+    "queue" "worker" "cron" "webhook" "grpc" "rpc"
+  )
+  fe_keywords=(
+    "component" "page" "form" "button" "modal" "input" "field"
+    "ui" "layout" "css" "tailwind" "tsx" "jsx" "react" "vue"
+    "svelte" "stylesheet" "wireframe" "design system" "screen"
+  )
+
+  has_be=0
+  has_fe=0
+  for kw in "${be_keywords[@]}"; do
+    case "$lc" in *"$kw"*) has_be=1; break ;; esac
+  done
+  for kw in "${fe_keywords[@]}"; do
+    case "$lc" in *"$kw"*) has_fe=1; break ;; esac
+  done
+
+  if [ "$has_be" -eq 1 ] && [ "$has_fe" -eq 1 ]; then echo "mixed"
+  elif [ "$has_be" -eq 1 ]; then echo "be-only"
+  elif [ "$has_fe" -eq 1 ]; then echo "fe-only"
+  else echo "none"
+  fi
+  exit 0
+fi
+
 ROOT="${1:-$PWD}"
 cd "$ROOT"
 

package/plugins/team-superpower/scripts/wave-collision-check.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# wave-collision-check.sh — detect file-scope collisions inside a wave.
+#
+# Input (stdin): one task per line, space-separated:
+#   <task-id> <file1> [<file2> ...]
+# Files are normalized (lowercase, leading ./ stripped, slashes preserved).
+#
+# Exit codes:
+#   0 — no collision
+#   1 — at least one pair of tasks share a normalized file
+#
+# Stdout on collision: one line per colliding pair:
+#   COLLISION <task-i> <task-j> <file>
+
+set -euo pipefail
+
+normalize() {
+  # lowercase + strip leading ./
+  printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's|^\./||'
+}
+
+tasks=()
+files_list=()
+
+while IFS= read -r line || [ -n "$line" ]; do
+  [ -z "$line" ] && continue
+  # shellcheck disable=SC2206
+  parts=($line)
+  task="${parts[0]}"
+  files=()
+  for ((i=1; i<${#parts[@]}; i++)); do
+    files+=("$(normalize "${parts[$i]}")")
+  done
+  tasks+=("$task")
+  files_list+=("${files[*]}")
+done
+
+collisions=0
+n=${#tasks[@]}
+for ((i=0; i<n; i++)); do
+  for ((j=i+1; j<n; j++)); do
+    # shellcheck disable=SC2206
+    fi=(${files_list[$i]})
+    # shellcheck disable=SC2206
+    fj=(${files_list[$j]})
+    for f1 in "${fi[@]}"; do
+      [ -z "$f1" ] && continue
+      for f2 in "${fj[@]}"; do
+        [ -z "$f2" ] && continue
+        if [ "$f1" = "$f2" ]; then
+          printf 'COLLISION %s %s %s\n' "${tasks[$i]}" "${tasks[$j]}" "$f1"
+          collisions=$((collisions+1))
+        fi
+      done
+    done
+  done
+done
+
+if [ "$collisions" -gt 0 ]; then exit 1; fi
+exit 0

package/plugins/tech-graph/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tech-graph",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"

package/plugins/html-effectiveness/tests/_tmp.test.js

@@ -1,58 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { getTmpDir, cleanup, withTmp, ROOT } from '../scripts/_tmp.js';
-
-test('getTmpDir creates a fresh dir under .tmp/html-effectiveness/', () => {
-  const dir = getTmpDir('unit-a');
-  assert.ok(dir.endsWith('/.tmp/html-effectiveness/unit-a'));
-  assert.ok(existsSync(dir));
-  cleanup('unit-a');
-});
-
-test('getTmpDir wipes existing dir contents', () => {
-  const dir = getTmpDir('unit-b');
-  writeFileSync(join(dir, 'old.txt'), 'stale');
-  const dir2 = getTmpDir('unit-b');
-  assert.equal(dir, dir2);
-  assert.equal(existsSync(join(dir2, 'old.txt')), false);
-  cleanup('unit-b');
-});
-
-test('cleanup removes dir', () => {
-  const dir = getTmpDir('unit-c');
-  cleanup('unit-c');
-  assert.equal(existsSync(dir), false);
-});
-
-test('cleanup is idempotent on missing dir', () => {
-  cleanup('unit-never-created');
-  assert.ok(true);
-});
-
-test('withTmp runs callback and cleans up on success', () => {
-  let observed;
-  const result = withTmp('unit-d', (dir) => {
-    observed = dir;
-    writeFileSync(join(dir, 'x'), 'y');
-    return 'done';
-  });
-  assert.equal(result, 'done');
-  assert.equal(existsSync(observed), false);
-});
-
-test('withTmp cleans up even when callback throws', () => {
-  let observed;
-  assert.throws(() => {
-    withTmp('unit-e', (dir) => {
-      observed = dir;
-      throw new Error('boom');
-    });
-  }, /boom/);
-  assert.equal(existsSync(observed), false);
-});
-
-test('ROOT is anchored at repo .tmp/html-effectiveness', () => {
-  assert.ok(ROOT.endsWith('/.tmp/html-effectiveness'));
-});

package/plugins/html-effectiveness/tests/fixtures/01-exploration-code-approaches.data.json

@@ -1,3 +0,0 @@
-{
-  "title": "Code-Approaches Exploration"
-}

package/plugins/html-effectiveness/tests/fixtures/02-exploration-visual-designs.data.json

@@ -1,3 +0,0 @@
-{
-  "title": "Visual Design Exploration"
-}

package/plugins/html-effectiveness/tests/fixtures/03-code-review-pr.data.json

@@ -1,3 +0,0 @@
-{
-  "title": "PR Code Review Board"
-}

package/plugins/html-effectiveness/tests/fixtures/04-code-understanding.data.json

@@ -1,3 +0,0 @@
-{
-  "title": "Code Walkthrough"
-}

package/plugins/html-effectiveness/tests/fixtures/05-design-system.data.json

@@ -1,3 +0,0 @@
-{
-  "title": "Design System Sheet"
-}