@mmerterden/multi-agent-pipeline 10.9.0 → 11.0.0

package/pipeline/commands/multi-agent.md

@@ -77,6 +77,7 @@ Lib scripts (`~/.claude/lib/`):
 | `analysis ["<feature>"]` | Standalone feature-spec analizi: Figma / Swagger / Confluence / Jira / repo girdileri sabit 7-bölümlük şablona dökülür, humanizer'dan geçer, Local/Confluence/Jira hedef(ler)ine post edilir. Worktree veya commit yok. Dev'e zincirleme yok. |
 | `build-optimize` | iOS-only Xcode build performance wrapper. Vendored `xcode-build-orchestrator`'a dispatch eder; benchmark + compilation / project / SPM analyzer'lar + recommend-first plan `.build-benchmark/optimization-plan.md`. Non-iOS stack'lerde fail-fast. |
 | `channels [PR-url\|#N\|Jira-url\|Jira-id] [--channels pr,jira,confluence,wiki] [--content normal,test,auto-diff,note] [--message "..."]` | Post task report to multi-select channels (PR description, Jira comment, Confluence page, Wiki pages) with multi-select content sources. Humanizer pass per-channel. Bitbucket PR updates use reviewer-preserving PUT. Phase 7 delegates to this command; also invocable post-hoc for fixes made outside the pipeline. No worktree. |
+| `generate ["desc"] [figma-url] [swagger-url]` | Create a standards-compliant Jira issue: asks the type (**Task** / **Bug** / **Story**), mines the project's recent same-type issues for conventions (summary format, labels, priority, test-scenario style), detects the active sprint, drafts from a standard template with auto-sizing sections (Design Reference / API Contract / Screenshots appear only when their source is given), asks about unknown fields, then full draft preview + explicit approval before create. No worktree, no commits. |
 | `test` or `test [args]` | UI Bug Hunter  -  screenshot + tap + analyze on booted simulator via MCP (read `$HOME/.claude/commands/sim-test.md`). `/multi-agent:test` also resolves here via the `commands/multi-agent/test.md` delegate. |
 | `manual-test [#id]` | Phase 5 standalone Manual Test  -  checks out the task branch, prints Xcode / SourceTree hints, waits for user verdict (`ok` / `fix: ...`). |
 | `stack [ios\|android\|backend\|mobile\|all]` | Swap skills for next conversation. No arg = show current stack. |
@@ -116,6 +117,7 @@ This command uses lazy loading for token efficiency. Read the relevant sub-file
 | `local-autopilot` | `$HOME/.claude/commands/multi-agent/local-autopilot.md` |
 | `dev-local` | `$HOME/.claude/commands/multi-agent/dev-local.md` |
 | `dev-local-autopilot` | `$HOME/.claude/commands/multi-agent/dev-local-autopilot.md` |
+| `generate` | `$HOME/.claude/commands/multi-agent/generate.md` (loads `refs/generate-issue.md`) |
 | `stack` | `$HOME/.claude/commands/multi-agent/stack.md` |
 | `language` | Handled inline  -  set/show prompt language in preferences |
 | SwiftUI component task (iOS) | `$HOME/.claude/commands/multi-agent/refs/swiftui-guide.md` |

package/pipeline/lib/figma-mcp-refresh.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# figma-mcp-refresh.sh  -  silent Figma MCP (figu_) token renewal via OAuth refresh grant.
+#
+# Used by the Phase 0 token pre-flight (refs/phases/phase-0-init.md Step 0.7) and the
+# expired-token decision (refs/keychain.md). Never prints token values  -  status lines only.
+#
+# Flow:
+#   1. Resolve the access-token Keychain name from prefs.global.keychainMapping.figma_mcp.
+#   2. Read the refresh token from "<name>_Refresh" (written by the user's generation script).
+#   3. Read client credentials from .figma-oauth.json next to prefs.global.tokenScripts.figma_mcp.
+#   4. POST grant_type=refresh_token to the Figma token endpoint.
+#   5. On success save the new access token (and rotated refresh token) back to the Keychain.
+#
+# Exit codes:
+#   0  renewed (access token replaced in Keychain)
+#   1  refresh grant rejected by Figma (refresh token dead  -  run the generation script)
+#   2  prerequisites missing (no mapping / no refresh entry / no oauth config)
+
+set -euo pipefail
+
+PREFS_FILE="${PREFS_FILE:-$HOME/.claude/multi-agent-preferences.json}"
+TOKEN_ENDPOINT="https://api.figma.com/v1/oauth/token"
+ACCOUNT="${USER:-$(whoami)}"
+
+say() { printf '%s\n' "$*"; }
+
+[ -f "$PREFS_FILE" ] || { say "figma-mcp-refresh: prefs file missing ($PREFS_FILE)"; exit 2; }
+
+KEY_NAME=$(jq -r '.global.keychainMapping.figma_mcp // empty' "$PREFS_FILE")
+[ -n "$KEY_NAME" ] || { say "figma-mcp-refresh: keychainMapping.figma_mcp not set"; exit 2; }
+
+REFRESH_KEY="${KEY_NAME}_Refresh"
+REFRESH_TOKEN=$(security find-generic-password -s "$REFRESH_KEY" -w 2>/dev/null || true)
+[ -n "$REFRESH_TOKEN" ] || { say "figma-mcp-refresh: no refresh token at '$REFRESH_KEY'"; exit 2; }
+
+SCRIPT_PATH=$(jq -r '.global.tokenScripts.figma_mcp // empty' "$PREFS_FILE")
+OAUTH_CONFIG=""
+if [ -n "$SCRIPT_PATH" ]; then
+  OAUTH_CONFIG="$(dirname "$SCRIPT_PATH")/.figma-oauth.json"
+fi
+[ -n "$OAUTH_CONFIG" ] && [ -f "$OAUTH_CONFIG" ] || { say "figma-mcp-refresh: .figma-oauth.json not found (tokenScripts.figma_mcp unset or sibling config missing)"; exit 2; }
+
+CLIENT_ID=$(jq -r '.client_id // empty' "$OAUTH_CONFIG")
+CLIENT_SECRET=$(jq -r '.client_secret // empty' "$OAUTH_CONFIG")
+[ -n "$CLIENT_ID" ] || { say "figma-mcp-refresh: client_id missing in .figma-oauth.json"; exit 2; }
+
+CURL_ARGS=(
+  --data-urlencode "grant_type=refresh_token"
+  --data-urlencode "refresh_token=${REFRESH_TOKEN}"
+  --data-urlencode "client_id=${CLIENT_ID}"
+)
+[ -n "$CLIENT_SECRET" ] && CURL_ARGS+=( --data-urlencode "client_secret=${CLIENT_SECRET}" )
+
+RESPONSE=$(curl -s --max-time 20 -X POST "$TOKEN_ENDPOINT" \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  "${CURL_ARGS[@]}")
+
+NEW_ACCESS=$(printf '%s' "$RESPONSE" | jq -r '.access_token // empty' 2>/dev/null || true)
+NEW_REFRESH=$(printf '%s' "$RESPONSE" | jq -r '.refresh_token // empty' 2>/dev/null || true)
+EXPIRES_IN=$(printf '%s' "$RESPONSE" | jq -r '.expires_in // "?"' 2>/dev/null || true)
+
+if [ -z "$NEW_ACCESS" ]; then
+  ERR=$(printf '%s' "$RESPONSE" | jq -r '.error // .message // "unknown"' 2>/dev/null || echo "unknown")
+  say "figma-mcp-refresh: refresh grant rejected ($ERR)  -  regenerate via tokenScripts.figma_mcp"
+  exit 1
+fi
+
+# Save new access token first, then the rotated refresh token  -  order matters so a
+# mid-write failure never leaves us with a lost refresh token AND a stale access token.
+security delete-generic-password -s "$KEY_NAME" -a "$ACCOUNT" >/dev/null 2>&1 || true
+security add-generic-password -s "$KEY_NAME" -a "$ACCOUNT" -w "$NEW_ACCESS" -T "" -U
+
+if [ -n "$NEW_REFRESH" ]; then
+  security delete-generic-password -s "$REFRESH_KEY" -a "$ACCOUNT" >/dev/null 2>&1 || true
+  security add-generic-password -s "$REFRESH_KEY" -a "$ACCOUNT" -w "$NEW_REFRESH" -T "" -U
+fi
+
+say "figma-mcp-refresh: renewed '$KEY_NAME' (expires_in=${EXPIRES_IN}s, refresh $( [ -n "$NEW_REFRESH" ] && echo rotated || echo unchanged ))"
+exit 0

package/pipeline/preferences-template.json

@@ -14,6 +14,7 @@
       "firebase": null,
       "jenkins": null
     },
+    "tokenScripts": {},
     "platformIdentityRouting": {},
     "recentProjects": [],
     "recentBranches": {},
@@ -153,4 +154,4 @@
       "overrides": {}
     }
   }
-}
+}

package/pipeline/schemas/prefs.schema.json

@@ -179,6 +179,17 @@
             }
           }
         },
+        "tokenScripts": {
+          "type": "object",
+          "additionalProperties": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "default": {},
+          "description": "Maps service ids to user-owned token generation scripts (absolute paths, personal - never synced). Used by the Phase 0 token pre-flight: figma_mcp silent renewal reads the .figma-oauth.json next to tokenScripts.figma_mcp; the 'Regenerate now (script)' option runs the script itself."
+        },
         "platformIdentityRouting": {
           "type": "object",
           "description": "v2.1.0+. Maps repo URL glob patterns to identity names. Used in Phase 0 to auto-select git identity + PAT based on repo origin. Prevents corporate identity leaking into personal repos and vice versa.",

package/pipeline/scripts/fixtures/install-layout.tsv

@@ -1,16 +1,16 @@
 .claude/CLAUDE.md	1
 .claude/agents	8
-.claude/commands	89
-.claude/lib	23
+.claude/commands	92
+.claude/lib	24
 .claude/multi-agent-preferences.json	1
 .claude/rules	12
 .claude/schemas	23
-.claude/scripts	171
+.claude/scripts	174
 .claude/settings.json	1
 .claude/skills	560
 .copilot/agents	8
 .copilot/copilot-instructions.md	1
-.copilot/lib	23
+.copilot/lib	24
 .copilot/schemas	23
-.copilot/scripts	171
-.copilot/skills	596
+.copilot/scripts	174
+.copilot/skills	598

package/pipeline/scripts/phase-tracker.sh

@@ -14,12 +14,14 @@
 #
 # Commands:
 #   init   <task_id>                                  Reset tracker for this task
-#   add    <phase_id> "<name>"                        Register a phase (status=pending)
+#   add    <phase_id> "<name>"                        Register a phase (status=pending); idempotent - existing id is a no-op
 #   update <phase_id> <status>                        Change status + re-render
 #   sub    <phase_id> <sub_id> "<name>" [status]      Add or update a sub-phase
-#   tokens <phase_id> <in> <out>                      Add to phase's token totals (v5.5.0)
+#   tokens <phase_id> <in> <out> [cached]             Add to phase's token totals (in = fresh input, cache-exclusive)
 #   model  <phase_id> <model_name>                    Tag phase with the LLM that produced its tokens (v8.3.0)
 #   meta   <phase_id> <key> <value>                   Set phase context (account, repos, files, now, ...)
+#   now    <phase_id> "<text>"                        Set the phase's live current-action line (quiet, 60-char cap)
+#   cost   <phase_id>|total                           Print est. USD for one phase or the whole run ("-" when unpriceable)
 #   render                                            Print current snapshot, no change
 #
 # Status enum: pending | in_progress | completed | failed | skipped
@@ -57,8 +59,11 @@ usage:
   phase-tracker.sh add    <phase_id> "<name>"
   phase-tracker.sh update <phase_id> <pending|in_progress|completed|failed|skipped>
   phase-tracker.sh sub    <phase_id> <sub_id> "<name>" [status]
-  phase-tracker.sh tokens <phase_id> <in> <out>
+  phase-tracker.sh tokens <phase_id> <in> <out> [cached]
+  phase-tracker.sh model  <phase_id> <model_name>
   phase-tracker.sh meta   <phase_id> <key> <value>
+  phase-tracker.sh now    <phase_id> "<text>"
+  phase-tracker.sh cost   <phase_id>|total
   phase-tracker.sh render
 USAGE
   exit 64
@@ -239,6 +244,37 @@ format_elapsed() {
   fi
 }
 
+# Cost table ships next to this script in every install tree (repo,
+# ~/.claude/scripts, ~/.copilot/scripts). Pricing math matches
+# render-agent-log-cost.sh exactly: tokens_in is FRESH input (cache-exclusive,
+# per the disjoint token-count contract), tokens_cached is priced at the
+# discounted cacheReadPerMtok rate, floored to cents. A missing/unparseable
+# table never fails a caller - USD simply renders empty / "-".
+COST_TABLE="$(cd "$(dirname "$0")" && pwd)/cost-table.json"
+
+# Print est. USD ("0.21") for one phase index or, with "total", the sum across
+# priceable phases. Prints "-" when nothing is priceable. Never non-zero exit.
+phase_usd() {
+  local selector="$1"  # integer phase index into .phases[], or "total"
+  [ -f "$COST_TABLE" ] || { echo "-"; return 0; }
+  local state; state="$(load_state)"
+  echo "$state" | jq -r --slurpfile prices "$COST_TABLE" --arg sel "$selector" '
+    def usd_of(p): ($prices[0].prices[p.model // ""] // null) as $rate |
+      if $rate == null then null
+      else ( ((p.tokens_in // 0) / 1000000) * $rate.inPerMtok
+           + ((p.tokens_cached // 0) / 1000000) * ($rate.cacheReadPerMtok // $rate.inPerMtok)
+           + ((p.tokens_out // 0) / 1000000) * $rate.outPerMtok )
+      end;
+    def floor_cents(u): if u == null then null else ((u * 100) | floor) / 100 end;
+    if $sel == "total" then
+      ([.phases[] | usd_of(.) | select(. != null)] | if length == 0 then "-" else (add | floor_cents(.) | tostring) end)
+    else
+      (.phases[($sel | tonumber)] // null) as $p |
+      if $p == null then "-" else (usd_of($p) | floor_cents(.) | if . == null then "-" else tostring end) end
+    end
+  ' 2>/dev/null || echo "-"
+}
+
 # Read state, atomically write it back. Atomic = write to .tmp, rename.
 load_state() {
   if [ ! -f "$TRACKER_FILE" ]; then
@@ -272,10 +308,25 @@ render() {
   # consecutive tabs (tab is in the default whitespace IFS class), which
   # silently drops empty middle columns and shifts later fields.
   # Column order:  status, started_at, completed_at, id, name,
-  #                tokens_in, tokens_out, sub_count, meta_keys_csv
+  #                tokens_in, tokens_out, sub_count, meta_keys_csv, usd
+  # The usd column is computed in the same pass with the shared pricing math;
+  # a missing/unparseable cost table yields empty usd cells, never a failure.
+  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 phase_data
-  phase_data=$(echo "$state" | jq -r '
-    .phases // [] | .[] | [
+  phase_data=$(echo "$state" | jq -r --argjson prices "$prices_json" '
+    def usd_of(p): ($prices.prices[p.model // ""] // null) as $rate |
+      if $rate == null then null
+      else ( ((p.tokens_in // 0) / 1000000) * $rate.inPerMtok
+           + ((p.tokens_cached // 0) / 1000000) * ($rate.cacheReadPerMtok // $rate.inPerMtok)
+           + ((p.tokens_out // 0) / 1000000) * $rate.outPerMtok )
+      end;
+    .phases // []
+    | sort_by(.id | (tonumber? // 9999))
+    | .[] | [
       (.status // ""),
       (.started_at // ""),
       (.completed_at // ""),
@@ -284,20 +335,21 @@ render() {
       ((.tokens_in // 0) | tostring),
       ((.tokens_out // 0) | tostring),
       ((.subs // []) | length | tostring),
-      ((.meta // {}) | keys_unsorted | join(","))
+      ((.meta // {}) | keys_unsorted | join(",")),
+      (usd_of(.) | if . == null then "" else (((. * 100) | floor) / 100 | tostring) end)
     ] | join("")
   ')
 
   local phase_count=0
   local -a row_status=() row_started=() row_completed=() row_id=() row_name=()
-  local -a row_tin=() row_tout=() row_subcount=() row_metakeys=()
+  local -a row_tin=() row_tout=() row_subcount=() row_metakeys=() row_usd=()
   if [ -n "$phase_data" ]; then
-    local _s _st _ed _id _nm _ti _to _sc _mk
-    while IFS=$'\x1f' read -r _s _st _ed _id _nm _ti _to _sc _mk; do
+    local _s _st _ed _id _nm _ti _to _sc _mk _us
+    while IFS=$'\x1f' read -r _s _st _ed _id _nm _ti _to _sc _mk _us; do
       row_status+=("$_s"); row_started+=("$_st"); row_completed+=("$_ed")
       row_id+=("$_id");    row_name+=("$_nm")
       row_tin+=("$_ti");   row_tout+=("$_to")
-      row_subcount+=("$_sc"); row_metakeys+=("$_mk")
+      row_subcount+=("$_sc"); row_metakeys+=("$_mk"); row_usd+=("$_us")
       phase_count=$((phase_count + 1))
     done <<< "$phase_data"
   fi
@@ -367,6 +419,16 @@ render() {
       local tok_label=""
       [ "$p_ttotal" -gt 0 ] && tok_label="$(format_tokens $p_ttotal) tok"
 
+      # Est. USD suffix - only when the phase has a priced model AND tokens.
+      # "0" (floored below one cent) still renders as ~$0.00 so a priced phase
+      # is visibly priced; an unpriceable phase shows no USD at all.
+      local p_usd="${row_usd[$i]}"
+      local usd_label=""
+      if [ -n "$p_usd" ] && [ "$p_ttotal" -gt 0 ]; then
+        usd_label=$(printf '~$%.2f' "$p_usd" 2>/dev/null) || usd_label=""
+      fi
+      [ -n "$usd_label" ] && [ -n "$tok_label" ] && tok_label="${tok_label} · ${usd_label}"
+
       local right_block=""
       if [ -n "$el_label" ] && [ -n "$tok_label" ]; then
         right_block=$(printf "%b%s%b ${C_DIM}·${C_RESET} %b%s%b" "$el_color" "$el_label" "$C_RESET" "$C_DIM" "$tok_label" "$C_RESET")
@@ -385,8 +447,8 @@ render() {
       # Same Unit Separator rationale as the phase batch above.
       if [ "$pstatus" = "in_progress" ] && [ -n "${row_metakeys[$i]}" ]; then
         local meta_data key val
-        meta_data=$(echo "$state" | jq -r --argjson idx "$i" '
-          .phases[$idx].meta // {} | to_entries[] | [.key, (.value | tostring)] | join("")
+        meta_data=$(echo "$state" | jq -r --arg pid "$pid" '
+          ([.phases[] | select(.id == $pid)][0].meta) // {} | to_entries[] | [.key, (.value | tostring)] | join("")
         ')
         while IFS=$'\x1f' read -r key val; do
           [ -z "$key" ] && continue
@@ -399,8 +461,8 @@ render() {
       local sub_count="${row_subcount[$i]}"
       if [ "$sub_count" != "0" ] && [ "$sub_count" -gt 0 ] 2>/dev/null; then
         local sub_data
-        sub_data=$(echo "$state" | jq -r --argjson idx "$i" '
-          .phases[$idx].subs // [] | .[] | [(.id // ""), (.name // ""), (.status // "")] | join("")
+        sub_data=$(echo "$state" | jq -r --arg pid "$pid" '
+          ([.phases[] | select(.id == $pid)][0].subs) // [] | .[] | [(.id // ""), (.name // ""), (.status // "")] | join("")
         ')
         local j=0
         local sid sname sstatus sg connector
@@ -417,14 +479,22 @@ render() {
     done
   fi
 
-  # Total-tokens footer (v5.5.0)  -  sum phases[].tokens_in + tokens_out.
-  local total_tokens
+  # Total footer  -  tokens + est. USD (priceable phases) + cached tokens.
+  local total_tokens total_cached
   total_tokens=$(echo "$state" | jq '[.phases[] | ((.tokens_in // 0) + (.tokens_out // 0))] | add // 0')
+  total_cached=$(echo "$state" | jq '[.phases[] | (.tokens_cached // 0)] | add // 0')
   if [ "$total_tokens" -gt 0 ]; then
-    local total_label
+    local total_label total_usd total_suffix=""
     total_label=$(format_tokens "$total_tokens")
+    total_usd=$(phase_usd total)
+    if [ -n "$total_usd" ] && [ "$total_usd" != "-" ]; then
+      total_suffix=$(printf ' · ~$%.2f' "$total_usd" 2>/dev/null) || total_suffix=""
+    fi
+    if [ "$total_cached" -gt 0 ] 2>/dev/null; then
+      total_suffix="${total_suffix}  ($(format_tokens "$total_cached") cached)"
+    fi
     printf "${C_BOLD}${C_BLUE}│${C_RESET}  ${C_DIM}%s${C_RESET}\n" "$(printf '%*s' 56 '' | tr ' ' '─')"
-    printf "${C_BOLD}${C_BLUE}│${C_RESET}  ${C_BOLD}Total${C_RESET}                         ${C_BOLD}${C_CYAN}%s tok${C_RESET}\n" "$total_label"
+    printf "${C_BOLD}${C_BLUE}│${C_RESET}  ${C_BOLD}Total${C_RESET}                         ${C_BOLD}${C_CYAN}%s tok%s${C_RESET}\n" "$total_label" "$total_suffix"
   fi
 
   printf "${C_BOLD}${C_BLUE}╰────────────────────────────────────────────────────────────╯${C_RESET}\n"
@@ -459,8 +529,14 @@ case "$ACTION" in
     [ "$#" -ge 2 ] || { echo "add needs <phase_id> <name>" >&2; exit 64; }
     PID="$1"; PNAME="$2"
     state=$(load_state)
-    new=$(echo "$state" | jq --arg id "$PID" --arg name "$PNAME" \
-      '.phases += [{"id":$id,"name":$name,"status":"pending","subs":[]}]')
+    # Idempotent: a phase id that already exists is a no-op (name, status, and
+    # token history are preserved). This is what lets continuation commands
+    # (/multi-agent:finish, resume) re-declare their phase set against a
+    # pre-existing tracker without duplicating or resetting tiles.
+    new=$(echo "$state" | jq --arg id "$PID" --arg name "$PNAME" '
+      if any(.phases[]?; .id == $id) then .
+      else .phases += [{"id":$id,"name":$name,"status":"pending","subs":[]}]
+      end')
     save_state "$new"
     render
     ;;
@@ -581,12 +657,48 @@ case "$ACTION" in
     fi
     ;;
 
+  now)
+    need_jq
+    [ "$#" -ge 2 ] || { echo "now needs <phase_id> <text>" >&2; exit 64; }
+    PID="$1"; TEXT="$2"
+    # Live current-action line for the active phase. Quiet by construction:
+    # progress lines are frequent, so `now` never renders - the card picks the
+    # value up at the next boundary render/update. Truncated to 60 chars.
+    if [ "${#TEXT}" -gt 60 ]; then
+      TEXT="${TEXT:0:59}…"
+    fi
+    state=$(load_state)
+    new=$(echo "$state" | jq --arg id "$PID" --arg v "$TEXT" '
+      .phases |= map(
+        if .id == $id then .meta = ((.meta // {}) + {"Now": $v}) else . end
+      )')
+    save_state "$new"
+    emit_otel_span "phase.now" "$PID" "$TEXT" "{}"
+    ;;
+
+  cost)
+    need_jq
+    [ "$#" -ge 1 ] || { echo "cost needs <phase_id>|total" >&2; exit 64; }
+    SEL="$1"
+    if [ "$SEL" = "total" ]; then
+      phase_usd total
+    else
+      # Resolve phase id -> array index (ids are strings like "3").
+      IDX=$(load_state | jq -r --arg id "$SEL" '[.phases[]?.id] | index($id) // "-"')
+      if [ "$IDX" = "-" ] || [ -z "$IDX" ]; then
+        echo "-"
+      else
+        phase_usd "$IDX"
+      fi
+    fi
+    ;;
+
   render)
     render
     ;;
 
   *)
-    echo "phase-tracker: unknown action '$ACTION' (use init|add|update|sub|tokens|model|meta|render)" >&2
+    echo "phase-tracker: unknown action '$ACTION' (use init|add|update|sub|tokens|model|meta|now|cost|render)" >&2
     exit 64
     ;;
 esac

package/pipeline/scripts/smoke-channels-approval-gate.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# smoke-channels-approval-gate.sh  -  contract for the channels Step 6 body preview + approval gate.
+#
+# Verifies:
+#   1. channels.md has the Step 6 gate section with the four decision options.
+#   2. The two (and only two) bypass cases are documented: autopilot + --dry-run.
+#   3. Step 7 dispatch is gated on the Step 6 approval.
+#   4. Byte-identical post rule + re-approval-on-regeneration rule present.
+#   5. Phase 7 Step 1.5 (GitHub issue comment) references the same gate.
+#   6. Required rules include the approval-before-post bullet.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+CHANNELS="$ROOT/pipeline/commands/multi-agent/channels.md"
+PHASE7="$ROOT/pipeline/commands/multi-agent/refs/phases/phase-7-report.md"
+
+PASS=0
+FAIL=0
+pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
+fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
+
+for f in "$CHANNELS" "$PHASE7"; do
+  [ -f "$f" ] || { echo "error: missing $f" >&2; exit 1; }
+done
+
+echo "→ 1. Step 6 gate section + decision options"
+grep -Fq "Step 6  -  Body preview + approval gate" "$CHANNELS" && pass "gate section present" || fail "gate section missing"
+for opt in "Approve & post" "Edit" "Skip channels" "Cancel"; do
+  grep -Fq "$opt" "$CHANNELS" && pass "option: $opt" || fail "option missing: $opt"
+done
+
+echo ""
+echo "→ 2. bypass cases are exactly autopilot + --dry-run"
+grep -Fq "Skipped in exactly two cases" "$CHANNELS" && pass "two-case rule stated" || fail "two-case rule missing"
+grep -Fq "MULTI_AGENT_AUTOPILOT=1" "$CHANNELS" && pass "autopilot bypass documented" || fail "autopilot bypass missing"
+grep -Eq 'dry-run.*(redundant|without posting)' "$CHANNELS" && pass "dry-run bypass documented" || fail "dry-run bypass missing"
+
+echo ""
+echo "→ 3. dispatch gated on approval"
+grep -Fq "NEVER starts before the Step 6 gate resolves" "$CHANNELS" && pass "Step 6 gated" || fail "Step 6 gate wiring missing"
+
+echo ""
+echo "→ 4. byte-identical + re-approval rules"
+grep -Fq "byte-identical to the approved preview" "$CHANNELS" && pass "byte-identical rule" || fail "byte-identical rule missing"
+grep -Fq "invalidates the approval" "$CHANNELS" && pass "re-approval on regeneration" || fail "re-approval rule missing"
+
+echo ""
+echo "→ 5. Phase 7 issue-comment path uses the same gate"
+grep -Fq "same preview + approval gate as channels Step 6" "$PHASE7" && pass "Phase 7 Step 1.5 gated" || fail "Phase 7 Step 1.5 gate reference missing"
+grep -Fq "Autopilot posts directly" "$PHASE7" && pass "Phase 7 autopilot bypass" || fail "Phase 7 autopilot bypass missing"
+
+echo ""
+echo "→ 6. required-rules bullet"
+grep -Fq "**Approval before post**" "$CHANNELS" && pass "required-rules bullet present" || fail "required-rules bullet missing"
+
+echo ""
+echo "══ channels-approval-gate smoke: $PASS passed, $FAIL failed ══"
+[ "$FAIL" -eq 0 ]

package/pipeline/scripts/smoke-generate-issue.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# smoke-generate-issue.sh  -  contract for /multi-agent:generate.
+#
+# Verifies:
+#   1. All 3 files exist (1 command, shared ref, 1 Copilot/plugin SKILL.md).
+#   2. Frontmatter keys present on both surfaces.
+#   3. Command delegates to refs/generate-issue.md and asks the issue type.
+#   4. Approval gate documented and marked unskippable in the ref.
+#   5. Convention mining + createmeta + Agile sprint endpoints present.
+#   6. UTF-8 verbatim POST path (--rawfile + --data-binary) present.
+#   7. Standard template vocab: Task/Story (Scope/Acceptance/Test Scenarios), Bug (Steps/Expected/Actual/Environment), Swagger.
+#   8. Registration: dispatcher rows, inventory lists, count consistency (36).
+#   9. Forbidden strings absent (em-dash, section sign, the M-word, unicode_escape).
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+CMD="$ROOT/pipeline/commands/multi-agent/generate.md"
+REF="$ROOT/pipeline/commands/multi-agent/refs/generate-issue.md"
+SKILL="$ROOT/pipeline/skills/shared/core/multi-agent-generate/SKILL.md"
+DISPATCHER="$ROOT/pipeline/commands/multi-agent.md"
+CONTRACT="$ROOT/pipeline/commands/multi-agent/refs/cross-cli-contract.md"
+SYNC="$ROOT/pipeline/commands/multi-agent/sync.md"
+HELP="$ROOT/pipeline/commands/multi-agent/help.md"
+
+PASS=0
+FAIL=0
+pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
+fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
+
+echo "→ 1. files exist"
+for f in "$CMD" "$REF" "$SKILL"; do
+  if [ -f "$f" ]; then pass "exists: ${f#$ROOT/}"; else fail "missing: ${f#$ROOT/}"; fi
+done
+# old split commands must be gone
+for f in "$ROOT/pipeline/commands/multi-agent/generate-task.md" "$ROOT/pipeline/commands/multi-agent/generate-bug.md"; do
+  if [ -f "$f" ]; then fail "stale file present: ${f#$ROOT/}"; else pass "removed: ${f##*/}"; fi
+done
+[ "$FAIL" -eq 0 ] || { echo "══ generate-issue smoke: $PASS passed, $FAIL failed ══"; exit 1; }
+
+echo ""
+echo "→ 2. frontmatter keys"
+head -5 "$CMD" | grep -q '^description:' && pass "description: ${CMD##*/}" || fail "description missing: ${CMD##*/}"
+head -5 "$CMD" | grep -q '^argument-hint:' && pass "argument-hint: ${CMD##*/}" || fail "argument-hint missing: ${CMD##*/}"
+head -8 "$SKILL" | grep -q '^name: multi-agent-generate$' && pass "name: multi-agent-generate" || fail "name wrong: $SKILL"
+head -8 "$SKILL" | grep -q '^language: en' && pass "language en" || fail "language missing: $SKILL"
+head -8 "$SKILL" | grep -q '^user-invocable: true' && pass "user-invocable" || fail "user-invocable missing: $SKILL"
+
+echo ""
+echo "→ 3. command delegates to the shared ref and asks the type"
+grep -Fq "refs/generate-issue.md" "$CMD" && pass "ref link present" || fail "ref link missing"
+for t in "Task" "Bug" "Story"; do
+  grep -Fq "$t" "$CMD" && pass "type offered: $t" || fail "type missing: $t"
+done
+grep -Fqi "Pick issue type" "$REF" && pass "type-selection step present" || fail "type-selection step missing"
+
+echo ""
+echo "→ 4. approval gate documented and unskippable"
+grep -Fq "Full preview + approval gate (never skipped)" "$REF" && pass "gate section present" || fail "gate section missing"
+for marker in "Approve" "Edit" "Cancel" "no bypass" "Nothing was created"; do
+  grep -Fqi "$marker" "$REF" && pass "gate marker: $marker" || fail "gate marker missing: $marker"
+done
+grep -Fq "no autopilot variant" "$REF" && pass "no-autopilot rule" || fail "no-autopilot rule missing"
+
+echo ""
+echo "→ 5. mining + createmeta + agile endpoints"
+for marker in "rest/api/2/search" "rest/api/2/issue/createmeta" "rest/agile/1.0/board" "sprint?state=active" 'sprint/${SPRINT_ID}/issue' "remotelink" "attachments"; do
+  grep -Fq "$marker" "$REF" && pass "endpoint marker: $marker" || fail "endpoint marker missing: $marker"
+done
+grep -Fq "gh-sprint" "$REF" && pass "generic sprint-field detection" || fail "generic sprint-field detection missing"
+
+echo ""
+echo "→ 6. UTF-8 verbatim POST path"
+grep -Fq -- "--rawfile" "$REF" && pass "--rawfile present" || fail "--rawfile missing"
+grep -Fq -- "--data-binary" "$REF" && pass "--data-binary present" || fail "--data-binary missing"
+grep -Fqi "humanizer" "$REF" && pass "humanizer pass referenced" || fail "humanizer missing"
+
+echo ""
+echo "→ 7. standard template vocabulary + auto-sizing + swagger"
+for s in "Scope" "Acceptance Criteria" "Test Scenarios"; do
+  grep -Fq "$s" "$REF" && pass "task/story section: $s" || fail "task/story section missing: $s"
+done
+for s in "Steps to Reproduce" "Expected Result" "Actual Result" "Environment"; do
+  grep -Fq "$s" "$REF" && pass "bug section: $s" || fail "bug section missing: $s"
+done
+grep -Fqi "auto-sizing" "$REF" && pass "auto-sizing rule present" || fail "auto-sizing rule missing"
+grep -Fqi "swagger" "$REF" && pass "swagger context present" || fail "swagger context missing"
+
+echo ""
+echo "→ 8. registration + count consistency (36)"
+grep -Fq '| `generate ' "$DISPATCHER" && pass "dispatcher routing: generate" || fail "dispatcher routing missing: generate"
+grep -Fq "generate.md" "$DISPATCHER" && pass "dispatcher loading row" || fail "dispatcher loading row missing"
+grep -Fq "## 1. Command Inventory (36 commands)" "$CONTRACT" && pass "contract count = 36" || fail "contract count wrong"
+grep -Eq '(^|[ ,])generate, help([ ,]|$)' "$CONTRACT" && pass "contract list has generate" || fail "contract list missing generate"
+grep -Fq "**36 commands are synced**" "$SYNC" && pass "sync count = 36" || fail "sync count wrong"
+SYNC_SKILL="$ROOT/pipeline/skills/shared/core/multi-agent-sync/SKILL.md"
+grep -Fq "**36 commands are synced**" "$SYNC_SKILL" && pass "sync SKILL count = 36" || fail "sync SKILL count wrong (Copilot parity)"
+grep -Fq "generate" "$ROOT/pipeline/skills/shared/core/multi-agent-help/SKILL.md" && pass "help SKILL lists generate" || fail "help SKILL missing generate (Copilot parity)"
+grep -c "multi-agent:generate" "$HELP" | awk '{exit !($1>=2)}' && pass "help.md has EN + TR entries" || fail "help.md entries incomplete"
+# no stale split-command references anywhere in the synced surfaces
+if grep -rqE "generate-task|generate-bug" "$DISPATCHER" "$CONTRACT" "$SYNC" "$HELP" "$CMD" "$REF" "$SKILL"; then
+  fail "stale generate-task/generate-bug reference found"
+else
+  pass "no stale split-command references"
+fi
+
+echo ""
+echo "→ 9. forbidden strings absent"
+MWORD="MAN""DATORY"
+for f in "$CMD" "$REF" "$SKILL"; do
+  if grep -q $'—\|§\|…' "$f"; then fail "forbidden unicode punctuation in ${f##*/}"; else pass "punctuation clean: ${f##*/}"; fi
+  if grep -q "$MWORD" "$f"; then fail "forbidden word in ${f##*/}"; else pass "vocabulary clean: ${f##*/}"; fi
+  if grep -q "unicode_escape" "$f" && ! grep -q "Never round-trip" "$f"; then fail "unicode_escape misuse in ${f##*/}"; else pass "encoding rule clean: ${f##*/}"; fi
+done
+
+echo ""
+echo "══ generate-issue smoke: $PASS passed, $FAIL failed ══"
+[ "$FAIL" -eq 0 ]