@mmerterden/multi-agent-pipeline 20.12.0 → 20.13.0

package/pipeline/commands/multi-agent/prune-prompts/SKILL.md

@@ -1,5 +1,6 @@
 ---
 description: "Zero-base prompt review: measure the always-on instruction footprint, classify every rule block, propose keep/trial-removal/delete; applies only approved rows. Use when a new model ships or instructions have accumulated."
+disable-model-invocation: true
 description-tr: "Sıfır-tabanlı prompt incelemesi: sürekli yüklü talimat yükünü ölçer, her kural bloğunu sınıflar, tut/dene/sil önerir; yalnızca onaylananı uygular."
 argument-hint: "[--report-only]"
 parameters: [{"name":"--report-only","kind":"flag"}]

package/pipeline/commands/multi-agent/review/SKILL.md

@@ -26,6 +26,11 @@ Skip Phase 0-3 and review a diff only. Five input shapes, two providers:
 
 Branch-mode runs print to chat only. PR-mode runs print to chat AND post the verdict to the PR per `$HOME/.claude/multi-agent-refs/channels/pr-review-actions.md`: per-finding inline comments + an explicit approve / needs-work state. **No monolithic advisory comment** is ever posted.
 
+## Gotchas
+
+- The counterpart-repo comparison needs exactly one resolved candidate. With several, an unattended run skips it silently, so an autopilot review can have no cross-platform section.
+- The counterpart's stack comes from marker files, never from the repo name.
+
 ## Steps
 
 ### 0. Session bootstrap  -  TASK_ID + tmp cleanup

package/pipeline/commands/multi-agent/review-analysis/SKILL.md

@@ -1,6 +1,6 @@
 ---
-description: "Review a written analysis document instead of a diff: resolve it from a path, a Confluence page or a Jira issue, run the deterministic gates first, then a parallel model review. Findings cite the Locked rule they break. Never edits the document."
-description-tr: "Diff yerine yazılmış analiz dokümanını review eder: yol, Confluence sayfası veya Jira issue'sundan getirir, önce deterministik geçitleri koşar, sonra paralel model review. Bulgular ihlal edilen Locked kuralını gösterir. Dokümanı düzenlemez."
+description: "Review a written analysis document instead of a diff: resolve it from a path, a Confluence page or a Jira issue, run the deterministic gates first, then a parallel model review. Findings cite the Locked rule they break. Never edits the document. Use when an analysis needs judging before development starts."
+description-tr: "Diff yerine yazılmış analiz dokümanını review eder: yol, Confluence sayfası veya Jira issue'sundan getirir, önce deterministik geçitleri koşar, sonra paralel model review. Bulgular ihlal edilen Locked kuralını gösterir. Dokümanı düzenlemez. Bir analizin geliştirme başlamadan önce değerlendirilmesi gerektiğinde kullanılır."
 argument-hint: "[path | Confluence URL | pageId | JIRA-KEY] [--state <state.json>]  -  optional; with no argument, pick from recent analyses"
 parameters: [{"name":"target","kind":"text"},{"name":"--state","kind":"path"}]
 gui: form
@@ -14,6 +14,11 @@ confirm: none
 
 `/multi-agent:review` judges a diff. This judges the document that diff was supposed to come from, before anyone writes the code it describes. No worktree, no branch, no commit, and the reviewed document is never edited in place.
 
+## Gotchas
+
+- Validator ERRORs are Blockers and WARNs are Important, unless the document states why the warned-about item is acceptable.
+- Every rubric class is printed, with `none` when empty. A class missing from the verdict did not run; it is not a clean result.
+
 ## Flow
 
 Read `$HOME/.claude/multi-agent-refs/analysis/review.md` and execute it:

package/pipeline/lib/analysis-jira-write.sh

@@ -10,8 +10,8 @@
 # decides WHAT to write can be tested without a network.
 #
 # `jira-publish.sh` cannot do this: it writes a comment or a description on an
-# issue that already exists. The only creation path in this repo was a curl
-# hand-written inside a markdown instruction, which is the thing this replaces.
+# issue that already exists. This file is the one place that creates issues, so
+# the gate, the ledger and the label search apply to every creation.
 #
 # THE WRITE IS LEDGERED, AND THE LEDGER IS THE POINT
 #
@@ -32,11 +32,10 @@
 # AN EXISTING NODE IS SKIPPED, NEVER UPDATED
 #
 # Jira has no backup path for fields other than description. Rewriting a body an
-# engineer has since edited would repeat, at tree scale, the defect that made
-# jira-publish.sh take backups in the first place.
+# engineer has since edited would lose that edit with no way back.
 #
 # Usage:
-#   analysis-jira-write.sh --plan plan.json --project KEY [--dry-run] [--ledger FILE]
+#   analysis-jira-write.sh --plan plan.json --project KEY [--dry-run] [--ledger FILE] [--epic KEY]
 #
 # Exit: 0 written (or previewed), 3 the plan does not parse, 4 auth, 5 a Jira
 #       call failed, 64 usage.
@@ -47,14 +46,15 @@ SELF_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=/dev/null
 . "$SELF_DIR/_jira-auth.sh"
 
-PLAN=""; PROJECT=""; DRY=0; LEDGER=""
+PLAN=""; PROJECT=""; DRY=0; LEDGER=""; EPIC=""
 while [ $# -gt 0 ]; do
   case "$1" in
     --plan) PLAN="${2:-}"; shift 2 ;;
     --project) PROJECT="${2:-}"; shift 2 ;;
     --ledger) LEDGER="${2:-}"; shift 2 ;;
     --dry-run) DRY=1; shift ;;
-    *) echo "usage: analysis-jira-write.sh --plan FILE --project KEY [--dry-run] [--ledger FILE]" >&2; exit 64 ;;
+    --epic) EPIC="${2:-}"; shift 2 ;;
+    *) echo "usage: analysis-jira-write.sh --plan FILE --project KEY [--dry-run] [--ledger FILE] [--epic KEY]" >&2; exit 64 ;;
   esac
 done
 [ -n "$PLAN" ] && [ -f "$PLAN" ] || { echo "ERR: --plan FILE is required and must exist" >&2; exit 64; }
@@ -90,7 +90,7 @@ fi
 ORPHANS=0
 if [ -f "$LEDGER" ]; then
   ORPHANS=$(jq -rs '[.[] | select(.event=="intent")] as $i
-                  | [.[] | select(.event=="created") | .label] as $c
+                  | [.[] | select(.event=="created" or .event=="exists") | .label] as $c
                   | [$i[] | select(.label as $l | ($c | index($l)) | not)] | length' \
              "$LEDGER" 2>/dev/null || echo 0)
   if [ "${ORPHANS:-0}" -gt 0 ]; then
@@ -109,7 +109,7 @@ existing_for() {  # existing_for <label> -> prints the key, or empty
   printf ''
 }
 
-LABELS="$(jq -r '[.nodes[] | .label, (.subtasks[]?.label)] | join(",")' "$PLAN")"
+LABELS="$(jq -r '[.nodes[] | .label, (.clones[]?.label), (.subtasks[]?.label)] | join(",")' "$PLAN")"
 if [ "$DRY" -eq 0 ] && [ -n "$LABELS" ]; then
   JQL="project=${PROJECT} AND labels in (${LABELS})"
   ENC="$(printf '%s' "$JQL" | jq -sRr @uri)"
@@ -122,13 +122,11 @@ if [ "$DRY" -eq 0 ] && [ -n "$LABELS" ]; then
 fi
 
 # Two channels on purpose. The human line goes to stdout; the created key comes
-# back in CREATED_KEY. Returning the key on stdout too meant a caller using
-# command substitution swallowed the report - the first dry run printed a header
-# and nothing else, and the tree looked empty.
+# back in CREATED_KEY. Keeping the key off stdout lets a caller capture the
+# report with command substitution without losing any of it.
 # Same gate, same five candidate paths, same refusal as jira-publish.sh and
-# post-pr-review.sh. This file is the only ISSUE-CREATION path in the tree, and
-# a summary plus a description is outbound text like any other - it was the one
-# writer the gate did not cover.
+# post-pr-review.sh. A summary plus a description is outbound text like any
+# other, so every issue this file creates passes the gate first.
 ma_outbound_gate_text() {
   local text="$1" og="" tmp rc
   for c in "$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)/outbound-gate.mjs" \
@@ -149,25 +147,52 @@ ma_outbound_gate_text() {
   return $rc
 }
 
+link_issues() {  # link_issues <type> <fromKey> <toKey> <cloneLabel>
+  local ltype="$1" from="$2" to="$3" label="$4" linked
+  if [ "$DRY" -eq 1 ]; then
+    echo "  link    $ltype  ${from:-<story>} <-> ${to:-<clone>}"
+    return 0
+  fi
+  # A link already there is left alone, so a re-run never doubles it.
+  linked="$(jira_api GET "/rest/api/2/issue/${from}?fields=issuelinks" 2>/dev/null \
+    | jq -r --arg t "$to" '[.fields.issuelinks[]? | (.outwardIssue.key // .inwardIssue.key)] | index($t) != null' 2>/dev/null || echo false)"
+  if [ "$linked" = "true" ]; then
+    echo "  linked  $from <-> $to"
+    return 0
+  fi
+  if ! printf '%s' "$(jq -cn --arg t "$ltype" --arg a "$from" --arg b "$to" \
+      '{type: {name: $t}, inwardIssue: {key: $a}, outwardIssue: {key: $b}}')" \
+      | jira_api POST "/rest/api/2/issueLink" --data @- >/dev/null; then
+    echo "ERR: could not link $from to $to" >&2
+    return 5
+  fi
+  ledger link "$label" "$to"
+  echo "  linked  $from <-> $to"
+}
+
 CREATED_KEY=""
-create_issue() {  # create_issue <label> <summary> <issuetype> <parentKey|""> <description>
-  local label="$1" summary="$2" itype="$3" parent="$4" desc="$5" body key existing
+create_issue() {  # create_issue <label> <summary> <issuetype> <parentKey|""> <description> [extraFieldsJson]
+  local label="$1" summary="$2" itype="$3" parent="$4" desc="$5" extra="${6:-}" body key existing
+  [ -n "$extra" ] || extra="{}"
   CREATED_KEY=""
   existing="$(existing_for "$label")"
   if [ -n "$existing" ]; then
     # Skipped, never updated: Jira has no backup path for fields other than
     # description, and an engineer may have edited this body since.
     echo "  exists  $existing  $summary"
+    ledger exists "$label" "$existing"
     CREATED_KEY="$existing"
     return 0
   fi
   body="$(jq -n --arg p "$PROJECT" --arg s "$summary" --arg t "$itype" \
-                --arg l "$label" --arg d "$desc" --arg par "$parent" '
+                --arg l "$label" --arg d "$desc" --arg par "$parent" --argjson x "$extra" '
     {fields: ({project: {key: $p}, summary: $s, issuetype: {name: $t},
                labels: [$l], description: $d}
-              + (if $par == "" then {} else {parent: {key: $par}} end))}')"
+              + (if $par == "" then {} else {parent: {key: $par}} end)
+              + $x)}')"
   if [ "$DRY" -eq 1 ]; then
     echo "  create  $itype  $summary   [$label]"
+    [ "$parent" = "" ] && printf '%s\n' "$desc" | sed 's/^/          /'
     return 0
   fi
   # After the dry-run branch, because a dry run publishes nothing, and before
@@ -196,6 +221,24 @@ echo "analysis-jira-write: ${PROJECT}, coverage ${VERDICT}$([ "$DRY" -eq 1 ] &&
 [ "$VERDICT" = "unverifiable" ] && \
   echo "  NOTE: coverage could not be checked for this document; the tree is unverified."
 
+# The epic the stories join, if one was named. The link field depends on the
+# deployment, so it is resolved once, against the live site, before any write.
+STORY_EXTRA="{}"
+if [ -n "${EPIC:-}" ]; then
+  echo "  epic  $EPIC"
+  if [ "$DRY" -eq 0 ]; then
+    . "$(dirname "${BASH_SOURCE[0]}")/jira-epic-link.sh"
+    E_MODE="$(jq -r '.prefsUsed.epicLinkMode // "auto"' "$PLAN")"
+    E_FIELD="$(jq -r '.prefsUsed.epicLinkFieldId // empty' "$PLAN")"
+    E_SERVER="" E_FIELDS=""
+    if [ "$E_MODE" = "auto" ]; then
+      E_SERVER="$(jira_api GET "/rest/api/2/serverInfo" 2>/dev/null || echo "")"
+      [ -n "$E_FIELD" ] || E_FIELDS="$(jira_api GET "/rest/api/2/field" 2>/dev/null || echo "")"
+    fi
+    STORY_EXTRA="$(epic_link_fields "$E_MODE" "$EPIC" "$E_FIELD" "$E_SERVER" "$E_FIELDS")"
+  fi
+fi
+
 RC=0
 NODES="$(jq -c '.nodes[]' "$PLAN")"
 while IFS= read -r node; do
@@ -204,18 +247,27 @@ while IFS= read -r node; do
   s_title="$(printf '%s' "$node" | jq -r '.title')"
   s_src="$(printf '%s' "$node" | jq -r '.sourceIds | join(", ")')"
   s_type="$(jq -r '.prefsUsed.storyIssueType // "Story"' "$PLAN")"
-  s_desc="Sources: ${s_src:-none (derived from the section heading)}"
-  if ! create_issue "$s_label" "$s_title" "$s_type" "" "$s_desc"; then
-    # A failed story does not get its sub-tasks written anyway. `create_issue`
-    # omits the parent field when the parent key is empty, so without this the
-    # sub-tasks of a story Jira refused were still POSTed - and landed as live,
-    # parentless issues nobody asked for, from a run that had already reported
-    # an error.
+  s_desc="$(printf '%s' "$node" | jq -r '.description // empty')"
+  [ -n "$s_desc" ] || s_desc="Sources: ${s_src:-none (derived from the section heading)}"
+  if ! create_issue "$s_label" "$s_title" "$s_type" "" "$s_desc" "$STORY_EXTRA"; then
+    # A failed story does not get its sub-tasks or clones written. `create_issue`
+    # omits the parent field when the parent key is empty, so they would land as
+    # live, parentless issues from a run that has already reported an error.
     RC=5
     echo "  skipped   this story's sub-tasks: the story itself was not created" >&2
     continue
   fi
   skey="$CREATED_KEY"
+  LINK_TYPE="$(jq -r '.prefsUsed.cloneLinkType // "Relates"' "$PLAN")"
+  while IFS= read -r clone; do
+    [ -n "$clone" ] || continue
+    c_label="$(printf '%s' "$clone" | jq -r '.label')"
+    c_title="$(printf '%s' "$clone" | jq -r '.title')"
+    c_extra="$(printf '%s' "$clone" | jq -c --argjson e "$STORY_EXTRA" \
+      '$e + {components: [.components[] | {name: .}]}')"
+    create_issue "$c_label" "$c_title" "$s_type" "" "$s_desc" "$c_extra" || { RC=5; continue; }
+    link_issues "$LINK_TYPE" "$skey" "$CREATED_KEY" "$c_label" || RC=5
+  done < <(printf '%s' "$node" | jq -c '.clones[]?')
   while IFS= read -r sub; do
     [ -n "$sub" ] || continue
     t_label="$(printf '%s' "$sub" | jq -r '.label')"
@@ -228,7 +280,9 @@ while IFS= read -r node; do
         | jq -r '[.projects[]?.issuetypes[]? | select(.subtask==true) | .name] | first // empty' 2>/dev/null || echo "")"
     fi
     [ -n "$t_type" ] || t_type="Sub-task"
-    create_issue "$t_label" "${s_title} - ${t_role}" "$t_type" "$skey" "$s_desc" || RC=5
+    t_desc="$(printf '%s' "$sub" | jq -r '.description // empty')"
+    [ -n "$t_desc" ] || t_desc="Sources: ${s_src:-none (derived from the section heading)}"
+    create_issue "$t_label" "${s_title} - ${t_role}" "$t_type" "$skey" "$t_desc" || RC=5
   done < <(printf '%s' "$node" | jq -c '.subtasks[]?')
 done <<< "$NODES"
 

package/pipeline/lib/analysis-quality.mjs

@@ -0,0 +1,261 @@
+/**
+ * analysis-quality.mjs  -  document-quality checks on a rendered analysis
+ * document: every use case says how it fails, the document does not contradict
+ * itself, each layer carries only its own kind of content, and a design frame
+ * belongs to a use case.
+ *
+ * Each check takes the document's lines and returns `{errors, warns}` so the
+ * validator stays the only place that prints and decides the exit code.
+ *
+ * @module pipeline/lib/analysis-quality
+ */
+
+import { sectionBody, tableDataRows } from "./analysis-sections.mjs";
+
+const cellsOf = (row) =>
+  row
+    .trim()
+    .replace(/^\||\|$/g, "")
+    .split("|")
+    .map((c) => c.trim());
+const unbold = (s) => s.replace(/\*\*/g, "").trim();
+const isHeading = (l) => /^#{1,6}\s/.test(l);
+const isNumberedHeading = (l) => /^#{2,4}\s+\d+(\.\d+)*\.?\s/.test(l);
+const UC_HEADING = /\bUC-\d{2,3}\b/;
+
+const MAIN_FLOW = ["Ana Akış", "Ana Akis", "Main Flow"];
+const EXCEPTION_FLOW = ["İstisna Akışı", "Istisna Akisi", "Exception Flow"];
+const EXPLICIT_NONE = /^(yok|none)\s*:\s*\S/i;
+
+/** Use-case sections: from a heading naming `UC-NNN` up to the next numbered heading. */
+function useCaseBlocks(lines) {
+  const blocks = [];
+  let current = null;
+  for (const l of lines) {
+    if (isHeading(l)) {
+      const uc = l.match(UC_HEADING);
+      if (uc && isNumberedHeading(l)) {
+        current = { id: uc[0], lines: [] };
+        blocks.push(current);
+        continue;
+      }
+      if (isNumberedHeading(l) || /^#\s/.test(l)) current = null;
+    }
+    if (current) current.lines.push(l);
+  }
+  return blocks;
+}
+
+function fieldRow(lines, names) {
+  for (const l of lines) {
+    if (!l.trim().startsWith("|")) continue;
+    const c = cellsOf(l);
+    if (c.length >= 2 && names.some((n) => unbold(c[0]).toLowerCase() === n.toLowerCase())) {
+      return c[1];
+    }
+  }
+  return undefined;
+}
+
+/**
+ * A use case with a main flow states its exception flow. Missing is an error on
+ * a final document and a warning on a draft; "-" or empty is a warning;
+ * "Yok: <reason>" / "None: <reason>" is an explicit answer.
+ */
+export function exceptionFlow(lines, { final = false } = {}) {
+  const errors = [];
+  const warns = [];
+  for (const uc of useCaseBlocks(lines)) {
+    if (fieldRow(uc.lines, MAIN_FLOW) === undefined) continue;
+    const v = fieldRow(uc.lines, EXCEPTION_FLOW);
+    if (v === undefined) {
+      const msg = `${uc.id} has a main flow but no exception flow row (İstisna Akışı / Exception Flow)`;
+      (final ? errors : warns).push(msg);
+    } else if (!v || /^\p{Pd}$/u.test(v)) {
+      warns.push(
+        `${uc.id} exception flow is empty; write the failure path, or "Yok: <reason>" when there is none`,
+      );
+    } else if (/^(yok|none)\.?$/i.test(v) && !EXPLICIT_NONE.test(v)) {
+      warns.push(`${uc.id} exception flow says none without a reason ("Yok: <reason>")`);
+    }
+  }
+  return { errors, warns };
+}
+
+const normalize = (s) =>
+  s
+    .toLocaleLowerCase("tr")
+    .replace(/[.,;:!?"'`*_]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+
+const GOALS_KEYWORDS = [
+  "Hedefler ve Karşı Hedefler",
+  "Hedefler ve Karsi Hedefler",
+  "Goals and Non-Goals",
+  "Goals",
+];
+
+/** The same item on both sides of the goals table. */
+export function scopeOverlap(lines) {
+  const errors = [];
+  const body = sectionBody(lines, GOALS_KEYWORDS);
+  if (!body) return { errors, warns: [] };
+  const goals = new Map();
+  const nonGoals = new Set();
+  for (const row of tableDataRows(body)) {
+    const c = cellsOf(row);
+    if (c.length < 2) continue;
+    if (c[0] && c[0] !== "-") goals.set(normalize(c[0]), c[0]);
+    if (c[1] && c[1] !== "-") nonGoals.add(normalize(c[1]));
+  }
+  for (const [key] of goals) {
+    if (key && nonGoals.has(key)) {
+      errors.push(`"${key}" is both in scope and out of scope in the goals table (Locked 14)`);
+    }
+  }
+  return { errors, warns: [] };
+}
+
+const CITABLE = [
+  /\bBR-[a-z0-9]+(?:-[a-z0-9]+)*-\d+\b/gi,
+  /\bCB-[a-z0-9]+(?:-[a-z0-9]+)*-\d+\b/gi,
+  /\b(?:IG|FG)-\d{2,3}\b/g,
+  /\bUC-\d{2,3}\b/g,
+];
+
+/**
+ * Ids the text cites but never defines. An id is defined by the first cell of a
+ * table row or by a heading. Section 20 `AS-NN` ids have their own pairing check.
+ */
+export function citedUndefined(lines) {
+  const defined = new Set();
+  const cited = new Set();
+  for (const l of lines) {
+    const t = l.trim();
+    const sources = [];
+    if (isHeading(t)) {
+      sources.push([t, defined]);
+    } else if (t.startsWith("|")) {
+      const c = cellsOf(t);
+      sources.push([unbold(c[0] || ""), defined], [c.slice(1).join(" | "), cited]);
+    } else {
+      sources.push([t, cited]);
+    }
+    for (const [chunk, set] of sources) {
+      for (const re of CITABLE) {
+        for (const m of chunk.matchAll(re)) set.add(m[0].toUpperCase());
+      }
+    }
+  }
+  const errors = [...cited]
+    .filter((id) => !defined.has(id))
+    .sort()
+    .map((id) => `${id} is cited but never defined (no table row or heading names it)`);
+  return { errors, warns: [] };
+}
+
+const FIGMA_FRAME = /https:\/\/(?:www\.)?figma\.com\/[^\s)|\]]*node-id=([0-9]+[-:][0-9]+)/g;
+const REFERENCES = /Referans|References/i;
+
+/** A Figma frame linked outside every use case and outside the references (corporate). */
+export function designFrameUnmapped(lines) {
+  const warns = [];
+  let inUc = false;
+  let inRefs = false;
+  for (const l of lines) {
+    if (isHeading(l)) {
+      if (isNumberedHeading(l) || /^#\s/.test(l)) {
+        inUc = UC_HEADING.test(l) && isNumberedHeading(l);
+        inRefs = REFERENCES.test(l) && /^##\s/.test(l);
+      } else if (/^##\s/.test(l)) {
+        inUc = false;
+        inRefs = false;
+      }
+      continue;
+    }
+    if (inUc || inRefs) continue;
+    for (const m of l.matchAll(FIGMA_FRAME)) {
+      warns.push(
+        `design frame ${m[1]} is linked outside every use case; list it under the use case it serves`,
+      );
+    }
+  }
+  return { errors: [], warns };
+}
+
+const PART_A = new Set(["1", "2", "3", "4", "18", "19", "20"]);
+const REDESIGN_EVIDENCE = [
+  "Mevcut Davranış",
+  "Mevcut Davranis",
+  "Current Behaviour",
+  "Current Behavior",
+  "Endpoint Eşlemesi",
+  "Endpoint Eslemesi",
+  "Endpoint Mapping",
+];
+const CODE_PATH =
+  /[\w.-]+(?:\/[\w.-]+)+\.(?:swift|kt|kts|java|tsx?|jsx?|mjs|py|mm?|go|rb|cs|dart)\b/g;
+const ENDPOINT = /\b(?:GET|POST|PUT|PATCH|DELETE)\s+\/[\w{}/.-]*/g;
+
+/**
+ * File paths and endpoints in the business layer (Part A: sections 1-4, 18-20) of
+ * the global profile. Collapsible `<details>` blocks and the redesign evidence
+ * tables are where such evidence belongs, so they are not read.
+ */
+export function businessLayerTechnical(lines) {
+  const warns = [];
+  let section = null;
+  let skip = false;
+  let details = 0;
+  for (const l of lines) {
+    const top = l.match(/^##\s+(\d+)\.?\s/);
+    if (top) {
+      section = top[1];
+      skip = false;
+      continue;
+    }
+    if (/^#\s/.test(l)) {
+      section = null;
+      continue;
+    }
+    if (/^#{3,4}\s/.test(l)) {
+      skip = REDESIGN_EVIDENCE.some((k) => l.includes(k));
+      continue;
+    }
+    details += (l.match(/<details\b/gi) || []).length;
+    const closes = (l.match(/<\/details>/gi) || []).length;
+    const inDetails = details > 0;
+    details = Math.max(0, details - closes);
+    if (!section || !PART_A.has(section) || skip || inDetails) continue;
+    for (const re of [CODE_PATH, ENDPOINT]) {
+      for (const m of l.matchAll(re)) {
+        warns.push(
+          `Section ${section} (business layer) names "${m[0].trim()}"; move it to Part B/C or into a <details> evidence block`,
+        );
+      }
+    }
+  }
+  return { errors: [], warns };
+}
+
+const PANEL = /^>\s*\*\*(Missing inputs|Eksik girdiler)\s*:?\s*\*\*/i;
+
+/** A final document that still lists missing inputs. */
+export function missingInputsFinal(lines, { final = false } = {}) {
+  if (!final) return { errors: [], warns: [] };
+  const start = lines.findIndex((l) => PANEL.test(l.trim()));
+  if (start < 0) return { errors: [], warns: [] };
+  let items = 0;
+  for (const l of lines.slice(start + 1)) {
+    const t = l.trim();
+    if (!t.startsWith(">")) break;
+    if (/^>\s*[-*]\s+\S/.test(t)) items++;
+  }
+  return {
+    errors: [],
+    warns: items
+      ? [`the document is final but its missing inputs panel lists ${items} input(s)`]
+      : [],
+  };
+}

package/pipeline/lib/analysis-sections.mjs

@@ -0,0 +1,105 @@
+/**
+ * analysis-sections.mjs  -  locate sections and table rows in a rendered
+ * analysis document.
+ *
+ * Shared by the document validator and the story-tree planner, so both read a
+ * section the same way. Sections are found by heading keyword, not by number:
+ * the global and corporate profiles number the same content differently, and a
+ * rendered document keeps canonical numbers with gaps.
+ *
+ * @module pipeline/lib/analysis-sections
+ */
+
+/**
+ * Body lines of the first numbered heading at one of `levels` whose text holds
+ * one of `keywords`. Closed by the next heading at the same level or shallower,
+ * so the last sub-section of a parent does not run into the following section.
+ *
+ * @param {string[]} lines
+ * @param {string[]} keywords
+ * @param {number|number[]} levels
+ * @returns {string[]|null}
+ */
+export function sectionBody(lines, keywords, levels = 2) {
+  for (const level of [].concat(levels)) {
+    const open = new RegExp(`^#{${level}}\\s+\\d+(\\.\\d+)*\\.?\\s`);
+    const close = new RegExp(`^#{1,${level}}\\s`);
+    const start = lines.findIndex((l) => open.test(l) && keywords.some((k) => l.includes(k)));
+    if (start < 0) continue;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+      if (close.test(lines[i])) {
+        end = i;
+        break;
+      }
+    }
+    return lines.slice(start + 1, end);
+  }
+  return null;
+}
+
+/**
+ * Data rows of the tables in `bodyLines`: the pipe-rows after a separator row,
+ * which is the only shape that tells them from the header without reading cells.
+ *
+ * @param {string[]} bodyLines
+ * @returns {string[]}
+ */
+export function tableDataRows(bodyLines) {
+  const rows = [];
+  let afterSeparator = false;
+  for (const line of bodyLines) {
+    const t = line.trim();
+    if (!t.startsWith("|")) {
+      afterSeparator = false;
+      continue;
+    }
+    if (/^\|[\s\-:|]+\|$/.test(t)) {
+      afterSeparator = true;
+      continue;
+    }
+    if (afterSeparator) rows.push(t);
+  }
+  return rows;
+}
+
+const CB_KEYWORDS = ["Mevcut Davranış", "Mevcut Davranis", "Current Behaviour", "Current Behavior"];
+const EP_KEYWORDS = ["Endpoint Eşlemesi", "Endpoint Eslemesi", "Endpoint Mapping"];
+const DL_KEYWORDS = ["Fark Listesi", "Difference List"];
+
+/**
+ * Where each redesign artefact lives per profile. The global profile has them as
+ * sub-sections 4.5, 4.6 and 9.5; the corporate profile nests them under its own
+ * spine (2.1.1, 2.3.1 and the endpoint mapping under Section 5 service details).
+ */
+export const REDESIGN_SECTIONS = {
+  global: {
+    cb: { keywords: CB_KEYWORDS, levels: [3], label: "4.5 Current Behaviour" },
+    ep: { keywords: EP_KEYWORDS, levels: [3], label: "4.6 Endpoint Mapping" },
+    dl: { keywords: DL_KEYWORDS, levels: [3], label: "9.5 Difference List" },
+  },
+  corporate: {
+    cb: { keywords: CB_KEYWORDS, levels: [4], label: "2.1.1 Mevcut Davranış / Current Behaviour" },
+    ep: {
+      keywords: EP_KEYWORDS,
+      levels: [4],
+      label: "5.(N+4).1 Endpoint Eşlemesi / Endpoint Mapping",
+    },
+    dl: { keywords: DL_KEYWORDS, levels: [4], label: "2.3.1 Fark Listesi / Difference List" },
+  },
+};
+
+/**
+ * The three redesign artefact bodies for a profile, plus their labels.
+ *
+ * @param {string[]} lines
+ * @param {string} profile
+ */
+export function redesignSections(lines, profile) {
+  const spec = REDESIGN_SECTIONS[profile] || REDESIGN_SECTIONS.global;
+  const out = {};
+  for (const [key, s] of Object.entries(spec)) {
+    out[key] = { body: sectionBody(lines, s.keywords, s.levels), label: s.label };
+  }
+  return out;
+}

package/pipeline/lib/jira-epic-link.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# jira-epic-link.sh  -  which fields link a new story to an existing epic.
+#
+# Jira links a story to its epic in two different ways. Cloud uses the standard
+# `parent` field; Server and Data Center use an "Epic Link" custom field whose id
+# differs per site. The id is discovered from the field list by its schema type,
+# never assumed. When no way is found the story is created without a link and a
+# warning says so, rather than writing a guessed field.
+#
+# Pure: the caller fetches /rest/api/2/serverInfo and /rest/api/2/field and
+# passes the JSON in, so the decision is testable offline.
+#
+#   epic_link_fields <mode> <epicKey> <fieldId> <serverInfoJson> <fieldsJson>
+#     mode: auto | parent | epicLinkField | none
+#   Prints a JSON object to merge into the create body's `fields`.
+
+EPIC_LINK_SCHEMA="com.pyxis.greenhopper.jira:gh-epic-link"
+
+epic_link_fields() {
+  local mode="${1:-auto}" epic="$2" field_id="$3" server="$4" fields="$5" deployment found
+  command -v jq >/dev/null 2>&1 || { echo "ERR: jq is required to link an epic" >&2; return 3; }
+  if [ -z "$epic" ] || [ "$mode" = "none" ]; then
+    printf '{}\n'
+    return 0
+  fi
+  case "$mode" in
+    parent)
+      jq -cn --arg e "$epic" '{parent: {key: $e}}'
+      return 0
+      ;;
+    epicLinkField)
+      if [ -z "$field_id" ]; then
+        echo "WARN: epicLinkField mode needs issueTree.epicLinkFieldId; the epic is not linked" >&2
+        printf '{}\n'
+        return 0
+      fi
+      jq -cn --arg f "$field_id" --arg e "$epic" '{($f): $e}'
+      return 0
+      ;;
+  esac
+  deployment="$(printf '%s' "$server" | jq -r '.deploymentType // empty' 2>/dev/null || true)"
+  if [ "$deployment" = "Cloud" ]; then
+    jq -cn --arg e "$epic" '{parent: {key: $e}}'
+    return 0
+  fi
+  found="${field_id:-$(printf '%s' "$fields" | jq -r --arg s "$EPIC_LINK_SCHEMA" \
+    '[.[]? | select(.schema.custom == $s) | .id] | first // empty' 2>/dev/null || true)}"
+  if [ -z "$found" ]; then
+    echo "WARN: no epic-link field on this site; the stories are created without an epic" >&2
+    printf '{}\n'
+    return 0
+  fi
+  jq -cn --arg f "$found" --arg e "$epic" '{($f): $e}'
+}