@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/lib/figma-screenshot.sh

@@ -0,0 +1,536 @@
+#!/usr/bin/env bash
+#
+# figma-screenshot.sh
+#
+# Download Figma frame PNGs for /multi-agent:analysis Phase 2b.
+#
+# Modes:
+#   Single frame:
+#     figma-screenshot.sh --file-key <fileKey> --node-id <nodeId> \
+#                        [--output-dir <dir>] [--scale 2] [--format png]
+#
+#   Section drill:
+#     figma-screenshot.sh --section <sectionUrl> \
+#                        [--output-dir <dir>] [--scale 2]
+#
+# Section drill: parse the section URL, fetch metadata, walk
+# document.children, keep nodes whose type is FRAME, render them in
+# a single batched image call, then download each signed URL in
+# parallel. Manifest is emitted alongside the PNGs.
+#
+# Tier chain (per ~/.claude/rules/figma-pipeline.md):
+#   Tier 1 (Figma MCP)            -> N/A inside a bash script; noted on stderr
+#   Tier 2 (Figma REST + PAT)     -> primary path here
+#   Tier 3 (user screenshot)      -> not handled; exit 3 with guidance
+#
+# Token source: credential-store.sh get <logical-key>, where <logical-key>
+# is read from prefs.global.keychainMapping.figma_pat. Falls back to the
+# FIGMA_PAT environment variable. No literal keychain service name is
+# embedded in this script.
+#
+# Exit codes:
+#   0  success
+#   1  usage error
+#   2  auth failure (missing or rejected PAT)
+#   3  Tier 3 required (REST exhausted)
+#   4  frame not found (HTTP 404)
+#   5  rate limited (HTTP 429 after retry)
+#   6  network timeout or other fatal failure
+
+set -euo pipefail
+
+# --- Globals ----------------------------------------------------------------
+
+PREFS="$HOME/.claude/multi-agent-preferences.json"
+CRED_STORE="$HOME/.claude/lib/credential-store.sh"
+FIGMA_API="https://api.figma.com/v1"
+PARALLEL_DL=4
+HTTP_TIMEOUT=60
+MAX_IDS_PER_CALL=50
+
+FILE_KEY=""
+NODE_ID=""
+SECTION_URL=""
+OUTPUT_DIR=""
+SCALE="2"
+FORMAT="png"
+TIER="rest"
+
+# --- Helpers ----------------------------------------------------------------
+
+log() { printf '%s\n' "$*" >&2; }
+
+die() {
+  local code="$1"; shift
+  log "ERR: $*"
+  exit "$code"
+}
+
+print_help() {
+  cat <<'HELP'
+figma-screenshot.sh - download Figma frames as PNG
+
+Usage:
+  figma-screenshot.sh --file-key <fileKey> --node-id <nodeId> \
+                     [--output-dir <dir>] [--scale 2] [--format png]
+
+  figma-screenshot.sh --section <sectionUrl> \
+                     [--output-dir <dir>] [--scale 2]
+
+Options:
+  --file-key       Figma file key (or branchKey for branch URLs).
+  --node-id        Node id; may use either "-" or ":" separator.
+  --section        Section URL; child FRAMEs are auto-discovered.
+  --output-dir     Output directory. Default: /tmp/figma-screenshots-<ts>.
+  --scale          Render scale (1-4). Default: 2.
+  --format         Image format. Default: png.
+  --help           Show this help text and exit.
+
+Token resolution:
+  Read via credential-store.sh using
+  prefs.global.keychainMapping.figma_pat. Falls back to FIGMA_PAT env.
+
+Output:
+  PNG files plus manifest.json in the output directory.
+HELP
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1 || die 6 "missing dependency: $1"
+}
+
+normalize_node_id() {
+  # Figma node ids are sometimes carried with dashes (URL form) and sometimes
+  # with colons (API form). The API requires the colon form.
+  printf '%s' "$1" | tr '-' ':'
+}
+
+node_id_filename() {
+  printf '%s' "$1" | tr ':' '-'
+}
+
+# Parse a Figma URL into "fileKey<TAB>nodeId". Handles:
+#   figma.com/design/<fileKey>/<file>?node-id=<id>
+#   figma.com/design/<fileKey>/branch/<branchKey>/<file>?node-id=<id>
+parse_figma_url() {
+  local url="$1"
+  python3 - "$url" <<'PY'
+import sys
+from urllib.parse import urlparse, parse_qs
+
+url = sys.argv[1]
+u = urlparse(url)
+parts = [p for p in u.path.split('/') if p]
+file_key = ''
+if len(parts) >= 2 and parts[0] in ('design', 'file', 'proto', 'board'):
+    file_key = parts[1]
+# branch URLs override the file key with the branch key
+if len(parts) >= 4 and parts[2] == 'branch':
+    file_key = parts[3]
+q = parse_qs(u.query)
+node = q.get('node-id', [''])[0]
+print(f"{file_key}\t{node}")
+PY
+}
+
+resolve_token() {
+  # 1) Try the keychain via credential-store.sh, keyed by prefs mapping.
+  local token_key=""
+  if [ -f "$PREFS" ] && command -v python3 >/dev/null 2>&1; then
+    token_key=$(python3 -c "
+import json, sys
+try:
+    p = json.load(open('$PREFS'))
+    print(p.get('global', {}).get('keychainMapping', {}).get('figma_pat') or '')
+except Exception:
+    print('')
+" 2>/dev/null || true)
+  fi
+  if [ -n "$token_key" ] && [ -x "$CRED_STORE" ]; then
+    local tok
+    tok=$("$CRED_STORE" get "$token_key" 2>/dev/null || true)
+    if [ -n "$tok" ]; then
+      printf '%s' "$tok"
+      return 0
+    fi
+  fi
+  # 2) Env fallback so CI / one-shot use still works.
+  if [ -n "${FIGMA_PAT:-}" ]; then
+    printf '%s' "$FIGMA_PAT"
+    return 0
+  fi
+  return 1
+}
+
+# curl_figma <output> <url>
+# Honours retries: 429 retries once after a 5s pause; 5xx uses exponential
+# backoff (1s, 2s, 4s). Writes the body to <output>, returns the HTTP code on
+# stdout.
+curl_figma() {
+  local out="$1" url="$2"
+  local code attempt sleep_s
+  for attempt in 1 2 3; do
+    code=$(curl -sS -o "$out" -w '%{http_code}' \
+              --max-time "$HTTP_TIMEOUT" \
+              -H "X-Figma-Token: $FIGMA_TOKEN" \
+              "$url" || echo "000")
+    case "$code" in
+      2*) printf '%s' "$code"; return 0 ;;
+      401|403) printf '%s' "$code"; return 0 ;;
+      404)     printf '%s' "$code"; return 0 ;;
+      429)
+        if [ "$attempt" -eq 1 ]; then
+          log "WARN: 429 from Figma, retrying after 5s"
+          sleep 5
+          continue
+        fi
+        printf '%s' "$code"; return 0 ;;
+      5*)
+        sleep_s=$((2 ** (attempt - 1)))
+        log "WARN: HTTP $code from Figma, retry in ${sleep_s}s"
+        sleep "$sleep_s"
+        ;;
+      000)
+        log "WARN: network failure on Figma call (attempt $attempt)"
+        sleep_s=$((2 ** (attempt - 1)))
+        sleep "$sleep_s"
+        ;;
+      *) printf '%s' "$code"; return 0 ;;
+    esac
+  done
+  printf '%s' "${code:-000}"
+}
+
+handle_http_code() {
+  local code="$1" context="$2"
+  case "$code" in
+    2*) return 0 ;;
+    401|403) die 2 "auth failed ($context), check FIGMA_PAT" ;;
+    404)     die 4 "frame not found ($context)" ;;
+    429)     die 5 "rate limited ($context), retry exhausted" ;;
+    000)     die 6 "network timeout ($context)" ;;
+    *)       die 6 "HTTP $code ($context)" ;;
+  esac
+}
+
+# Fetch node metadata for a comma-joined list of node ids. Result written to
+# the given path.
+fetch_nodes_metadata() {
+  local ids="$1" out="$2"
+  local url="$FIGMA_API/files/$FILE_KEY/nodes?ids=$ids"
+  local code
+  code=$(curl_figma "$out" "$url")
+  handle_http_code "$code" "metadata for $ids"
+}
+
+# Render images for a comma-joined list of node ids. Returns a JSON object on
+# stdout: { "nodeId": "signed-url", ... }.
+fetch_image_urls() {
+  local ids="$1"
+  local tmp
+  tmp=$(mktemp)
+  local url="$FIGMA_API/images/$FILE_KEY?ids=$ids&format=$FORMAT&scale=$SCALE"
+  local code
+  code=$(curl_figma "$tmp" "$url")
+  handle_http_code "$code" "image render for $ids"
+  # Surface Figma-level errors (the API can return 200 with { "err": "..." }).
+  local err
+  err=$(jq -r '.err // empty' "$tmp" 2>/dev/null || true)
+  if [ -n "$err" ]; then
+    rm -f "$tmp"
+    die 6 "Figma image API error: $err"
+  fi
+  jq -c '.images' "$tmp"
+  rm -f "$tmp"
+}
+
+# Render + download a batch of node ids in one shot. Caller passes the comma-
+# joined id list and a TSV "nodeId<TAB>name<TAB>width<TAB>height" lookup file.
+render_and_download() {
+  local ids="$1" lookup="$2"
+  local urls_json
+  urls_json=$(fetch_image_urls "$ids")
+
+  # Emit a job list (nodeId<TAB>url<TAB>outPath) for parallel download.
+  local jobs
+  jobs=$(mktemp)
+  local key_prefix="${FILE_KEY:0:4}"
+  printf '%s' "$urls_json" | jq -r 'to_entries[] | "\(.key)\t\(.value)"' \
+    | while IFS=$'\t' read -r nid url; do
+        local fname
+        fname="frame-${key_prefix}-$(node_id_filename "$nid").$FORMAT"
+        printf '%s\t%s\t%s/%s\n' "$nid" "$url" "$OUTPUT_DIR" "$fname"
+      done > "$jobs"
+
+  # Parallel download. xargs -P keeps the channel count bounded.
+  local results
+  results=$(mktemp)
+  # shellcheck disable=SC2016
+  awk -F'\t' '{printf "%s\037%s\037%s\n", $1,$2,$3}' "$jobs" \
+    | xargs -P "$PARALLEL_DL" -I{} bash -c '
+        IFS=$'"'"'\037'"'"' read -r nid url out <<<"$1"
+        if [ -z "$url" ] || [ "$url" = "null" ]; then
+          printf "%s\tFAIL\t0\n" "$nid"
+          exit 0
+        fi
+        if curl -sS --max-time "$2" -o "$out" "$url"; then
+          size=$(wc -c < "$out" | tr -d " ")
+          printf "%s\t%s\t%s\n" "$nid" "$out" "$size"
+        else
+          printf "%s\tFAIL\t0\n" "$nid"
+        fi
+      ' _ {} "$HTTP_TIMEOUT" >> "$results"
+
+  # Merge download results with the metadata lookup to build manifest rows.
+  python3 - "$results" "$lookup" <<'PY'
+import json, sys
+
+results_path, lookup_path = sys.argv[1], sys.argv[2]
+
+lookup = {}
+with open(lookup_path) as f:
+    for line in f:
+        line = line.rstrip("\n")
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) < 4:
+            continue
+        nid, name, w, h = parts[0], parts[1], parts[2], parts[3]
+        lookup[nid] = {"name": name, "width": w, "height": h}
+
+with open(results_path) as f:
+    for line in f:
+        line = line.rstrip("\n")
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) < 3:
+            continue
+        nid, fpath, size = parts[0], parts[1], parts[2]
+        meta = lookup.get(nid, {"name": "", "width": "", "height": ""})
+        print(json.dumps({
+            "nodeId": nid,
+            "name": meta["name"],
+            "width": meta["width"],
+            "height": meta["height"],
+            "file": fpath.split("/")[-1] if fpath != "FAIL" else "",
+            "fileSize": int(size) if size.isdigit() else 0,
+            "ok": fpath != "FAIL"
+        }))
+PY
+
+  rm -f "$jobs" "$results"
+}
+
+write_manifest() {
+  local manifest_path="$1" section_id="$2" rows_file="$3"
+  python3 - "$manifest_path" "$FILE_KEY" "$section_id" "$SCALE" "$TIER" "$rows_file" <<'PY'
+import json, sys
+from datetime import datetime, timezone
+
+manifest_path, file_key, section_id, scale, tier, rows_file = sys.argv[1:]
+rows = []
+with open(rows_file) as f:
+    for line in f:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            rows.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+
+doc = {
+    "fileKey": file_key,
+    "section": section_id or None,
+    "scale": int(scale),
+    "tier": tier,
+    "generated": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    "frames": rows,
+}
+with open(manifest_path, "w") as f:
+    json.dump(doc, f, indent=2)
+PY
+}
+
+# --- Argument parsing -------------------------------------------------------
+
+if [ "$#" -eq 0 ]; then
+  print_help
+  exit 1
+fi
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --help|-h) print_help; exit 0 ;;
+    --file-key) FILE_KEY="${2:-}"; shift 2 ;;
+    --node-id)  NODE_ID="${2:-}"; shift 2 ;;
+    --section)  SECTION_URL="${2:-}"; shift 2 ;;
+    --output-dir) OUTPUT_DIR="${2:-}"; shift 2 ;;
+    --scale)    SCALE="${2:-2}"; shift 2 ;;
+    --format)   FORMAT="${2:-png}"; shift 2 ;;
+    *) die 1 "unknown argument: $1" ;;
+  esac
+done
+
+if [ -n "$SECTION_URL" ] && { [ -n "$FILE_KEY" ] || [ -n "$NODE_ID" ]; }; then
+  die 1 "--section is mutually exclusive with --file-key/--node-id"
+fi
+
+if [ -z "$SECTION_URL" ] && { [ -z "$FILE_KEY" ] || [ -z "$NODE_ID" ]; }; then
+  die 1 "either --section <url> or both --file-key and --node-id are required"
+fi
+
+require_cmd curl
+require_cmd jq
+require_cmd python3
+
+# Tier 1 (Figma MCP) is not reachable from a bash script. Stay on Tier 2 (REST).
+log "INFO: Tier 1 (Figma MCP) not available from shell; using Tier 2 (REST)."
+
+FIGMA_TOKEN=$(resolve_token || true)
+if [ -z "${FIGMA_TOKEN:-}" ]; then
+  log "Tier 3 (user-provided screenshot required): no PAT resolved."
+  log "Hint: store the token via credential-store.sh, mapped through"
+  log "      prefs.global.keychainMapping.figma_pat, or export FIGMA_PAT."
+  exit 3
+fi
+
+if [ -z "$OUTPUT_DIR" ]; then
+  OUTPUT_DIR="/tmp/figma-screenshots-$(date +%Y%m%d-%H%M%S)"
+fi
+mkdir -p "$OUTPUT_DIR"
+
+# --- Section mode -----------------------------------------------------------
+
+run_section_mode() {
+  local parsed file_key node_id
+  parsed=$(parse_figma_url "$SECTION_URL")
+  file_key=$(printf '%s' "$parsed" | cut -f1)
+  node_id=$(printf '%s' "$parsed" | cut -f2)
+  if [ -z "$file_key" ] || [ -z "$node_id" ]; then
+    die 1 "could not parse --section URL: $SECTION_URL"
+  fi
+  FILE_KEY="$file_key"
+  local section_id
+  section_id=$(normalize_node_id "$node_id")
+
+  local meta_path
+  meta_path="$OUTPUT_DIR/_section-metadata.json"
+  fetch_nodes_metadata "$section_id" "$meta_path"
+
+  # Build the lookup: nodeId<TAB>name<TAB>width<TAB>height for every FRAME
+  # child of the section.
+  local lookup
+  lookup="$OUTPUT_DIR/_lookup.tsv"
+  python3 - "$meta_path" "$section_id" > "$lookup" <<'PY'
+import json, sys
+meta_path, section_id = sys.argv[1], sys.argv[2]
+data = json.load(open(meta_path))
+node = data.get("nodes", {}).get(section_id)
+if not node:
+    sys.exit(0)
+doc = node.get("document", {})
+for child in doc.get("children", []):
+    if child.get("type") != "FRAME":
+        continue
+    box = child.get("absoluteBoundingBox") or {}
+    print("\t".join([
+        child.get("id", ""),
+        (child.get("name") or "").replace("\t", " "),
+        str(int(box.get("width", 0))),
+        str(int(box.get("height", 0))),
+    ]))
+PY
+
+  if [ ! -s "$lookup" ]; then
+    write_manifest "$OUTPUT_DIR/manifest.json" "$section_id" "$lookup"
+    log "WARN: no FRAME children found under section $section_id"
+    log "OK: empty manifest at $OUTPUT_DIR/manifest.json"
+    return 0
+  fi
+
+  # Collect ids and chunk to MAX_IDS_PER_CALL.
+  local ids_file
+  ids_file=$(mktemp)
+  awk -F'\t' '{print $1}' "$lookup" > "$ids_file"
+
+  local rows
+  rows="$OUTPUT_DIR/_rows.ndjson"
+  : > "$rows"
+
+  local chunk=""
+  local count=0
+  while IFS= read -r nid; do
+    if [ -z "$chunk" ]; then
+      chunk="$nid"
+    else
+      chunk="$chunk,$nid"
+    fi
+    count=$((count + 1))
+    if [ "$count" -ge "$MAX_IDS_PER_CALL" ]; then
+      render_and_download "$chunk" "$lookup" >> "$rows"
+      chunk=""
+      count=0
+    fi
+  done < "$ids_file"
+  if [ -n "$chunk" ]; then
+    render_and_download "$chunk" "$lookup" >> "$rows"
+  fi
+  rm -f "$ids_file"
+
+  write_manifest "$OUTPUT_DIR/manifest.json" "$section_id" "$rows"
+  rm -f "$rows" "$lookup" "$meta_path"
+  log "OK: manifest at $OUTPUT_DIR/manifest.json"
+  printf '%s\n' "$OUTPUT_DIR/manifest.json"
+}
+
+# --- Single-frame mode ------------------------------------------------------
+
+run_single_mode() {
+  local node_id
+  node_id=$(normalize_node_id "$NODE_ID")
+
+  local meta_path lookup
+  meta_path="$OUTPUT_DIR/_frame-metadata.json"
+  lookup="$OUTPUT_DIR/_lookup.tsv"
+  fetch_nodes_metadata "$node_id" "$meta_path"
+  python3 - "$meta_path" "$node_id" > "$lookup" <<'PY'
+import json, sys
+meta_path, node_id = sys.argv[1], sys.argv[2]
+data = json.load(open(meta_path))
+node = data.get("nodes", {}).get(node_id)
+if not node:
+    sys.exit(0)
+doc = node.get("document", {})
+box = doc.get("absoluteBoundingBox") or {}
+print("\t".join([
+    doc.get("id", node_id),
+    (doc.get("name") or "").replace("\t", " "),
+    str(int(box.get("width", 0))),
+    str(int(box.get("height", 0))),
+]))
+PY
+
+  if [ ! -s "$lookup" ]; then
+    die 4 "frame not found in metadata: $node_id"
+  fi
+
+  local rows
+  rows="$OUTPUT_DIR/_rows.ndjson"
+  render_and_download "$node_id" "$lookup" > "$rows"
+
+  write_manifest "$OUTPUT_DIR/manifest.json" "" "$rows"
+  rm -f "$rows" "$lookup" "$meta_path"
+  log "OK: manifest at $OUTPUT_DIR/manifest.json"
+  printf '%s\n' "$OUTPUT_DIR/manifest.json"
+}
+
+# --- Dispatch ---------------------------------------------------------------
+
+if [ -n "$SECTION_URL" ]; then
+  run_section_mode
+else
+  run_single_mode
+fi

package/pipeline/lib/issue-fetcher.sh

@@ -2,7 +2,7 @@
 #
 # issue-fetcher.sh
 # Resolve any user input (Jira ID, Jira URL, GitHub URL, gh #N, repo#N, free-text)
-# into a normalized issue descriptor — and emit a maturity score so the picker
+# into a normalized issue descriptor  -  and emit a maturity score so the picker
 # can warn/block on incomplete issues.
 #
 # Output JSON schema:
@@ -22,7 +22,7 @@
 #        "score":     0..100,
 #        "blockers":  ["status_closed", "description_empty"],
 #        "warnings":  ["short_description", "no_repro_steps"],
-#        "summary":   "Description boş — pipeline başlatılamaz." (human-readable, tr|en)
+#        "summary":   "Description boş  -  pipeline başlatılamaz." (human-readable, tr|en)
 #     }
 #   }
 #
@@ -32,7 +32,7 @@
 #   ACCOUNT_GH_TOKEN_KEY      keychain service name (optional)
 #   ACCOUNT_DEFAULT_OWNER     fallback GitHub owner (optional)
 #   ACCOUNT_DEFAULT_REPO      fallback GitHub repo  (optional)
-#   PROMPT_LANG               tr|en — controls maturity.summary language (default: tr)
+#   PROMPT_LANG               tr|en  -  controls maturity.summary language (default: tr)
 
 set -eu
 
@@ -130,7 +130,7 @@ fields = dict(arg.split("=",1) for arg in sys.argv[2:])
 # Truncate description to keep payload reasonable.
 desc = fields.get("description","") or ""
 if len(desc) > 4000:
-    desc = desc[:4000] + "…"
+    desc = desc[:4000] + "..."
 
 priority = fields.get("priority","").strip()
 resolution = fields.get("resolution","").strip()
@@ -197,7 +197,7 @@ score = max(0, min(100, 100 - 40*len(blockers) - 10*len(warnings)))
 
 labels_tr = {
     "status_closed":         "Issue kapalı veya iptal edilmiş",
-    "already_resolved":      "Issue zaten resolved/merged ({})".format(resolution or "—"),
+    "already_resolved":      "Issue zaten resolved/merged ({})".format(resolution or " - "),
     "description_empty":     "Açıklama boş",
     "short_description":     "Açıklama çok kısa (<80 karakter)",
     "short_title":           "Başlık çok kısa (<10 karakter)",
@@ -206,7 +206,7 @@ labels_tr = {
 }
 labels_en = {
     "status_closed":         "Issue is closed/cancelled",
-    "already_resolved":      "Issue already resolved/merged ({})".format(resolution or "—"),
+    "already_resolved":      "Issue already resolved/merged ({})".format(resolution or " - "),
     "description_empty":     "Description is empty",
     "short_description":     "Description too short (<80 chars)",
     "short_title":           "Title too short (<10 chars)",
@@ -230,15 +230,15 @@ descriptor["maturity"] = {
     "summary":  summary,
 }
 
-# For freetext, no description fetched — score the title instead.
+# For freetext, no description fetched  -  score the title instead.
 if descriptor.get("kind") == "freetext":
     # No real issue, no maturity to assess. Mark as N/A.
     descriptor["maturity"] = {
         "score":    None,
         "blockers": [],
         "warnings": [],
-        "summary":  "Free-text input — maturity check skipped." if lang == "en"
-                    else "Free-text girdi — maturity kontrolü atlandı.",
+        "summary":  "Free-text input  -  maturity check skipped." if lang == "en"
+                    else "Free-text girdi  -  maturity kontrolü atlandı.",
     }
 
 print(json.dumps(descriptor, ensure_ascii=False))
@@ -251,13 +251,29 @@ case "$KIND" in
     KEY="$INPUT"
     raw=$(fetch_jira "$KEY") || raw=""
     if [ -n "$raw" ]; then
-      title=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["fields"]["summary"])')
-      itype=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["fields"]["issuetype"]["name"])')
-      status=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["fields"]["status"]["name"])')
-      description=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["fields"].get("description") or "")')
-      priority=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); p=d["fields"].get("priority") or {}; print(p.get("name") or "")')
-      resolution=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); r=d["fields"].get("resolution") or {}; print(r.get("name") if r else "")')
-      fixversions=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); fv=d["fields"].get("fixVersions") or []; print(",".join(v.get("name","") for v in fv))')
+      # Single python3 pass  -  emit all fields joined by U+001F (Unit Separator)
+      # so we avoid spawning 7 interpreter startups per Jira fetch
+      # (~200-300ms each). The separator is non-whitespace, so empty fields
+      # (e.g. unresolved issues) are preserved by `read` instead of collapsed.
+      # `read -d ''` lets descriptions with embedded newlines pass through.
+      parsed=$(printf '%s' "$raw" | python3 -c '
+import json, sys
+d = json.load(sys.stdin)
+f = d.get("fields", {}) or {}
+def _name(x):
+    return (x or {}).get("name", "") or ""
+title       = f.get("summary", "") or ""
+itype       = _name(f.get("issuetype"))
+status      = _name(f.get("status"))
+description = (f.get("description") or "")
+priority    = _name(f.get("priority"))
+resolution  = _name(f.get("resolution"))
+fixversions = ",".join((v or {}).get("name", "") for v in (f.get("fixVersions") or []))
+parts = [title, itype, status, description, priority, resolution, fixversions]
+parts = [v.replace("\x1f", " ") for v in parts]
+sys.stdout.write("\x1f".join(parts))
+')
+      IFS=$'\x1f' read -r -d '' title itype status description priority resolution fixversions <<< "$parsed" || true
     else
       title="(unfetched)"; itype="Task"; status="Unknown"; description=""
       priority=""; resolution=""; fixversions=""
@@ -282,10 +298,20 @@ case "$KIND" in
     NUM=$(printf '%s' "$INPUT" | sed -E 's#.*/issues/##; s#[/?].*##')
     raw=$(fetch_github "$OWNER" "$REPO" "$NUM") || raw=""
     if [ -n "$raw" ]; then
-      title=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["title"])')
-      labels=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(",".join(l["name"] for l in d.get("labels",[])))')
-      status=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d.get("state","open"))')
-      description=$(printf '%s' "$raw" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d.get("body") or "")')
+      # Single python3 pass  -  see jira-id branch for rationale on the
+      # U+001F separator + `read -d ''` combo.
+      parsed=$(printf '%s' "$raw" | python3 -c '
+import json, sys
+d = json.load(sys.stdin)
+title       = d.get("title", "") or ""
+labels      = ",".join((l or {}).get("name", "") for l in (d.get("labels") or []))
+status      = d.get("state", "open") or "open"
+description = d.get("body", "") or ""
+parts = [title, labels, status, description]
+parts = [v.replace("\x1f", " ") for v in parts]
+sys.stdout.write("\x1f".join(parts))
+')
+      IFS=$'\x1f' read -r -d '' title labels status description <<< "$parsed" || true
     else
       title="(unfetched)"; labels=""; status="open"; description=""
     fi