@mmerterden/multi-agent-pipeline 16.11.0 → 16.12.0

package/pipeline/lib/md2confluence-v3.py

@@ -134,6 +134,16 @@ def parse_front_matter(text: str) -> tuple[dict[str, str], str]:
 MERMAID_FENCE_OPEN_RE = re.compile(r"^```mermaid\s*$")
 
 
+def code_macro(lang: str, body: str) -> str:
+    """A plain code macro, used to carry mermaid source next to a lossy fallback."""
+    return (
+        '<ac:structured-macro ac:name="code">'
+        f'<ac:parameter ac:name="language">{html.escape(lang, quote=True)}</ac:parameter>'
+        f'<ac:plain-text-body><![CDATA[\n{cdata_escape(body)}\n]]></ac:plain-text-body>'
+        '</ac:structured-macro>'
+    )
+
+
 def mermaid_macro(body: str) -> str:
     return (
         '<ac:structured-macro ac:name="mermaid">'
@@ -145,18 +155,32 @@ def mermaid_macro(body: str) -> str:
 def mermaid_to_numbered_list(body: str) -> str:
     """Best-effort flowchart node extraction for fallback rendering."""
     nodes: list[str] = []
-    edges: list[tuple[str, str]] = []
+    edges: list[tuple[str, str, str]] = []
     node_label: dict[str, str] = {}
     node_pattern = re.compile(r"([A-Za-z0-9_]+)\s*(?:\[([^\]]+)\]|\(([^)]+)\)|\{([^}]+)\})")
-    edge_pattern = re.compile(r"([A-Za-z0-9_]+)\s*-->\s*([A-Za-z0-9_]+)")
+    # `A --> B` was the only shape matched, so every labelled branch
+    # (`B -- Evet --> C`, `B -->|Hayir| D`) lost both its edge and its label, which
+    # is the part of a flow chart that carries the decision. Both label syntaxes are
+    # captured now and the label is kept.
+    # A node id is usually followed by its shape and label - A[Basla], B{Karar} -
+    # so the id is not adjacent to the arrow. The old pattern required adjacency and
+    # therefore matched no edge at all in any diagram whose nodes carry labels, which
+    # is every real one. Skip an optional [..] (..) {..} on both sides.
+    _SHAPE = r"(?:\[[^\]]*\]|\([^)]*\)|\{[^}]*\})?"
+    edge_pattern = re.compile(
+        r"([A-Za-z0-9_]+)" + _SHAPE + r"\s*"
+        r"(?:--\s*(?P<lbl_dash>[^->|]+?)\s*-->|-->\s*\|(?P<lbl_pipe>[^|]*)\||-->)"
+        r"\s*([A-Za-z0-9_]+)" + _SHAPE
+    )
 
     for raw in body.splitlines():
         line = raw.strip()
         if not line or line.startswith("%%"):
             continue
         for em in edge_pattern.finditer(line):
-            a, b = em.group(1), em.group(2)
-            edges.append((a, b))
+            a, b = em.group(1), em.group(4)
+            label = (em.group("lbl_dash") or em.group("lbl_pipe") or "").strip()
+            edges.append((a, b, label))
             for nm in (a, b):
                 if nm not in node_label:
                     node_label[nm] = nm
@@ -174,9 +198,9 @@ def mermaid_to_numbered_list(body: str) -> str:
         # Could not parse; emit as plain pre block
         return f"<pre>{html.escape(body)}</pre>"
 
-    next_map: dict[str, list[str]] = {}
-    for a, b in edges:
-        next_map.setdefault(a, []).append(b)
+    next_map: dict[str, list[tuple[str, str]]] = {}
+    for a, b, lbl in edges:
+        next_map.setdefault(a, []).append((b, lbl))
 
     items: list[str] = []
     for idx, key in enumerate(nodes, start=1):
@@ -184,7 +208,13 @@ def mermaid_to_numbered_list(body: str) -> str:
         nxt = next_map.get(key, [])
         suffix = ""
         if nxt:
-            suffix = " next: " + ", ".join(node_label.get(n, n) for n in nxt)
+            # "next: Evet -> Odeme, Hayir -> Hata" keeps the branch condition, which
+            # is the only reason a reader looks at a decision node.
+            parts = [
+                (f"{lbl} -> {node_label.get(n, n)}" if lbl else node_label.get(n, n))
+                for n, lbl in nxt
+            ]
+            suffix = " next: " + ", ".join(parts)
         items.append(f"<li>{html.escape(label)}{html.escape(suffix)}</li>")
     return "<ol>" + "".join(items) + "</ol>"
 
@@ -223,12 +253,33 @@ def cdata_escape(s: str) -> str:
 class InlineContext:
     attachments_available: set[str]
     tooltip_macro_supported: bool
+    image_width: int = 0
     warnings: list[str] = field(default_factory=list)
     tooltip_fallback_used: bool = False
     images_referenced: list[str] = field(default_factory=list)
 
 
+# A 2x export is 750x1624 for a phone frame and 2880x2048 for a desktop one, and
+# Confluence renders an <ac:image> at its natural size, so one screenshot took two
+# screen heights on the page. Width is a display attribute only: the attachment
+# stays full resolution and a click still opens the original.
+# 720 is a desktop frame at half of a 2x export and a diagram at readable size;
+# a phone frame overrides itself down to 320 through the title syntax, which the
+# frame-gallery row writes because it is the only place that knows the frame width.
+DEFAULT_IMAGE_WIDTH = 720
+
+IMAGE_WIDTH_RE = re.compile(r"\bwidth\s*=\s*(\d{2,4})\b")
+
+
 def render_image(alt: str, src: str, ctx: InlineContext) -> str:
+    # Markdown title syntax carries the per-image override: ![alt](f.png "width=320")
+    width = None
+    m = re.match(r'^(?P<path>\S+)\s+"(?P<title>[^"]*)"$', src.strip())
+    if m:
+        src = m.group("path")
+        w = IMAGE_WIDTH_RE.search(m.group("title"))
+        if w:
+            width = int(w.group(1))
     filename = os.path.basename(src)
     # If src is an http(s) URL, render as external image link.
     if re.match(r"^https?://", src):
@@ -237,9 +288,12 @@ def render_image(alt: str, src: str, ctx: InlineContext) -> str:
     if ctx.attachments_available and filename not in ctx.attachments_available:
         ctx.warnings.append(f"image reference has no matching attachment: {filename}")
         return f'<a href="{html.escape(src, quote=True)}">{esc(alt) or esc(filename)}</a>'
+    if width is None:
+        width = ctx.image_width
     alt_attr = f' ac:alt="{html.escape(alt, quote=True)}"' if alt else ""
+    width_attr = f' ac:width="{width}"' if width else ""
     return (
-        f"<ac:image{alt_attr}>"
+        f"<ac:image{alt_attr}{width_attr}>"
         f'<ri:attachment ri:filename="{html.escape(filename, quote=True)}" />'
         "</ac:image>"
     )
@@ -339,10 +393,12 @@ def markdown_to_storage(
     attachments_available: set[str],
     mermaid_fallback: bool,
     tooltip_macro_supported: bool,
+    image_width: int = 0,
 ) -> ConvertResult:
     ctx = InlineContext(
         attachments_available=attachments_available,
         tooltip_macro_supported=tooltip_macro_supported,
+        image_width=image_width,
     )
     lines = markdown.split("\n")
     out: list[str] = []
@@ -379,7 +435,11 @@ def markdown_to_storage(
                 body = "\n".join(mermaid_buf)
                 if mermaid_fallback:
                     mermaid_fallback_used = True
+                    # The list is lossy however carefully it is built, so the source
+                    # goes with it. A reader who needs the real diagram can paste it
+                    # anywhere that renders mermaid; without it the diagram is gone.
                     out.append(mermaid_to_numbered_list(body))
+                    out.append(code_macro("text", body))
                 else:
                     out.append(mermaid_macro(body))
                 in_mermaid = False
@@ -643,6 +703,17 @@ def upload_attachment(
     """Attach file to page. Uses POST .../child/attachment, which overwrites if
     Confluence is configured to accept the same filename. Wrapped in retry so
     transient 5xx/429/network errors recover before the call site sees them."""
+    # Look before creating. Re-attaching a filename that is already on the page is
+    # a duplicate, and which status a Confluence tells you that with is not a
+    # constant: Cloud answers 400, this Server answers 500. Keying the
+    # already-exists path off a status code meant the update path was unreachable
+    # on Server, so every re-run logged one warning per attachment while the files
+    # were in fact fine. Asking first removes the guess, and leaves the error path
+    # as what it should have been all along: a race, not the normal case.
+    existing = find_existing_attachment(auth, page_id, file_path.name)
+    if existing:
+        return update_attachment_data(auth, page_id, existing, file_path)
+
     data = file_path.read_bytes()
     body, content_type = build_multipart([("file", data, file_path.name)])
     url = f"{auth.base_url}/rest/api/content/{page_id}/child/attachment"
@@ -661,23 +732,23 @@ def upload_attachment(
     def _do() -> tuple[bool, str]:
         with urllib.request.urlopen(req) as resp:
             resp.read()
-            return True, "ok"
+            return True, "created"
 
     try:
         return _retry_http(_do)
     except urllib.error.HTTPError as e:
-        # If attachment already exists, retry against the existing attachment id.
-        if e.code == 400:
+        # Race: something attached the same filename between the check and here.
+        # Both codes are treated the same because both mean the same thing.
+        if e.code in (400, 409, 500):
+            existing = find_existing_attachment(auth, page_id, file_path.name)
+            if existing:
+                return update_attachment_data(auth, page_id, existing, file_path)
             err_body = ""
             try:
                 err_body = e.read().decode("utf-8", errors="replace")
             except Exception:
                 pass
-            existing = find_existing_attachment(auth, page_id, file_path.name)
-            if existing:
-                ok, msg = update_attachment_data(auth, page_id, existing, file_path)
-                return ok, msg
-            return False, f"HTTP 400: {err_body[:300]}"
+            return False, f"HTTP {e.code}: {err_body[:300]}"
         return False, f"HTTP {e.code}"
     except urllib.error.URLError as e:
         return False, f"URLError: {e.reason}"
@@ -688,19 +759,24 @@ def upload_attachments_parallel(
     page_id: str,
     attachments: dict[str, Path],
     max_workers: int = 4,
-) -> tuple[int, list[str]]:
+) -> tuple[int, int, list[str]]:
     """Upload many attachments concurrently via a small thread pool.
 
-    Returns (success_count, warning_messages). Sequential ordering is not
+    Returns (created_count, updated_count, warning_messages). Created and updated
+    are counted apart because they are not the same event: a re-run of the same
+    document updates every attachment and creates none, and reporting that as
+    "0 uploaded, 12 warnings" reads as data loss when nothing was lost.
+    Sequential ordering is not
     preserved (the prior implementation processed `sorted(referenced)`), but
     that ordering had no semantic meaning - it was just deterministic for
     debugging. The thread pool keeps per-task retry semantics intact via
     upload_attachment().
     """
     if not attachments:
-        return 0, []
+        return 0, 0, []
     warnings: list[str] = []
-    uploaded = 0
+    created = 0
+    updated = 0
     workers = max(1, min(max_workers, len(attachments)))
     with ThreadPoolExecutor(max_workers=workers) as executor:
         future_to_name = {
@@ -712,12 +788,15 @@ def upload_attachments_parallel(
             try:
                 ok, msg = future.result()
                 if ok:
-                    uploaded += 1
+                    if msg == "updated":
+                        updated += 1
+                    else:
+                        created += 1
                 else:
                     warnings.append(f"attachment upload failed for {name}: {msg}")
             except Exception as e:
                 warnings.append(f"attachment upload exception for {name}: {e}")
-    return uploaded, warnings
+    return created, updated, warnings
 
 
 def find_existing_attachment(
@@ -829,6 +908,7 @@ def build_storage(
     attachments_dir: Path | None,
     mermaid_fallback: bool,
     tooltip_macro_supported: bool = True,
+    image_width: int = DEFAULT_IMAGE_WIDTH,
 ) -> tuple[ConvertResult, dict[str, str], dict[str, Path], list[str]]:
     front_matter, body = parse_front_matter(markdown_text)
     language = detect_language(body, front_matter.get("language"))
@@ -839,6 +919,7 @@ def build_storage(
         attachments_available=set(attachments.keys()),
         mermaid_fallback=mermaid_fallback,
         tooltip_macro_supported=tooltip_macro_supported,
+        image_width=image_width,
     )
     result.warnings = punct_warnings + result.warnings
     return result, front_matter, attachments, []
@@ -855,6 +936,7 @@ def cmd_create(args: argparse.Namespace) -> int:
         md_text,
         attachments_dir=attachments_dir,
         mermaid_fallback=args.mermaid_fallback,
+        image_width=getattr(args, "image_width", DEFAULT_IMAGE_WIDTH),
     )
 
     if args.dry_run:
@@ -864,6 +946,7 @@ def cmd_create(args: argparse.Namespace) -> int:
             "page_id": None,
             "page_url": None,
             "attachments_uploaded": 0,
+            "attachments_updated": 0,
             "attachments_available": len(attachments),
             "mermaid_macro_fallback_used": result.mermaid_fallback_used,
             "tooltip_macro_fallback_used": result.tooltip_fallback_used,
@@ -893,6 +976,7 @@ def cmd_create(args: argparse.Namespace) -> int:
             md_text,
             attachments_dir=attachments_dir,
             mermaid_fallback=True,
+            image_width=getattr(args, "image_width", DEFAULT_IMAGE_WIDTH),
         )
         create_payload["body"]["storage"]["value"] = result.storage_xml
         status, body, raw = http_json(auth, "POST", "/rest/api/content", create_payload)
@@ -905,6 +989,7 @@ def cmd_create(args: argparse.Namespace) -> int:
 
     # 2. Upload attachments referenced by markdown - parallel thread pool.
     uploaded = 0
+    updated = 0
     if attachments and result.images_referenced:
         to_upload = {
             name: attachments[name]
@@ -912,7 +997,9 @@ def cmd_create(args: argparse.Namespace) -> int:
             if name in attachments
         }
         if to_upload:
-            uploaded, upload_warnings = upload_attachments_parallel(auth, page_id, to_upload)
+            uploaded, updated, upload_warnings = upload_attachments_parallel(
+                auth, page_id, to_upload
+            )
             warnings.extend(upload_warnings)
 
     # 3. Apply labels from front matter.
@@ -925,6 +1012,7 @@ def cmd_create(args: argparse.Namespace) -> int:
         "page_id": page_id,
         "page_url": page_url,
         "attachments_uploaded": uploaded,
+        "attachments_updated": updated,
         "attachments_available": len(attachments),
         "mermaid_macro_fallback_used": result.mermaid_fallback_used,
         "tooltip_macro_fallback_used": result.tooltip_fallback_used,
@@ -941,6 +1029,7 @@ def cmd_update(args: argparse.Namespace) -> int:
         md_text,
         attachments_dir=attachments_dir,
         mermaid_fallback=args.mermaid_fallback,
+        image_width=getattr(args, "image_width", DEFAULT_IMAGE_WIDTH),
     )
 
     if args.dry_run:
@@ -950,6 +1039,7 @@ def cmd_update(args: argparse.Namespace) -> int:
             "page_id": args.page_id,
             "page_url": None,
             "attachments_uploaded": 0,
+            "attachments_updated": 0,
             "attachments_available": len(attachments),
             "mermaid_macro_fallback_used": result.mermaid_fallback_used,
             "tooltip_macro_fallback_used": result.tooltip_fallback_used,
@@ -989,6 +1079,7 @@ def cmd_update(args: argparse.Namespace) -> int:
             md_text,
             attachments_dir=attachments_dir,
             mermaid_fallback=True,
+            image_width=getattr(args, "image_width", DEFAULT_IMAGE_WIDTH),
         )
         update_payload["body"]["storage"]["value"] = result.storage_xml
         status, body, raw = http_json(
@@ -1003,6 +1094,7 @@ def cmd_update(args: argparse.Namespace) -> int:
     page_url = page_web_url(auth, body, page_id)
 
     uploaded = 0
+    updated = 0
     if attachments and result.images_referenced:
         to_upload = {
             name: attachments[name]
@@ -1010,7 +1102,9 @@ def cmd_update(args: argparse.Namespace) -> int:
             if name in attachments
         }
         if to_upload:
-            uploaded, upload_warnings = upload_attachments_parallel(auth, page_id, to_upload)
+            uploaded, updated, upload_warnings = upload_attachments_parallel(
+                auth, page_id, to_upload
+            )
             warnings.extend(upload_warnings)
 
     labels = build_labels(front_matter)
@@ -1022,6 +1116,7 @@ def cmd_update(args: argparse.Namespace) -> int:
         "page_id": page_id,
         "page_url": page_url,
         "attachments_uploaded": uploaded,
+        "attachments_updated": updated,
         "attachments_available": len(attachments),
         "mermaid_macro_fallback_used": result.mermaid_fallback_used,
         "tooltip_macro_fallback_used": result.tooltip_fallback_used,
@@ -1065,6 +1160,13 @@ def build_parser() -> argparse.ArgumentParser:
     create.add_argument("--markdown", required=True)
     create.add_argument("--attachments-dir")
     create.add_argument("--mermaid-fallback", action="store_true")
+    create.add_argument(
+        "--image-width",
+        type=int,
+        default=DEFAULT_IMAGE_WIDTH,
+        help="Display width in px for embedded attachment images (0 = natural size). "
+        "Per-image override: ![alt](f.png \"width=320\").",
+    )
     create.add_argument("--dry-run", action="store_true")
     create.set_defaults(func=cmd_create)
 
@@ -1073,6 +1175,12 @@ def build_parser() -> argparse.ArgumentParser:
     update.add_argument("--title", required=True)
     update.add_argument("--markdown", required=True)
     update.add_argument("--attachments-dir")
+    update.add_argument(
+        "--image-width",
+        type=int,
+        default=DEFAULT_IMAGE_WIDTH,
+        help="Display width in px for embedded attachment images (0 = natural size).",
+    )
     update.add_argument("--mermaid-fallback", action="store_true")
     update.add_argument("--dry-run", action="store_true")
     update.set_defaults(func=cmd_update)

package/pipeline/multi-agent-refs/analysis/locked.md

@@ -29,14 +29,14 @@ When citing a Locked decision in code or docs, prefer `Locked <n> (<short label>
 9. **Per-platform output split.** One markdown file is produced per selected platform under `analysis/<feature>-<platform>.md`. There is no merged single file. Section duplication follows the A3 hybrid table in `$HOME/.claude/multi-agent-refs/analysis-template.md` (Sections 1 + 4 duplicated verbatim; Sections 2, 3, 5, 6, 7 projected per platform). Each file carries a YAML front-matter header naming the feature, platform, generated-at timestamp, sibling file list, and binding standards source.
 10. **Output destination is asked after drafts exist.** Phase 3 renders each per-platform markdown to `/tmp/analysis-<feature-slug>-<timestamp>/` first. Only then does Phase 3.5 surface the output-destination picker (Local / Confluence / Jira). Drafts in `/tmp/` are the source of truth on resume; `/multi-agent:resume` re-uses them when `phase == awaiting_output_decision`.
 11. **Repo-evidence reuse-first.** Phase 1b runs a repo-evidence collector against each selected repo, producing 13 buckets (services, dtos, useCases, validationRules, domainEntities, routes, coordinators, diConfigurators, uiComponents, tokens, localizationKeys, testingIdentifiers, analyticsEvents) with each row tagged `direct-match | same-domain | cross-cutting`. Section 7 emits `Reuse existing X (file:line)` rows for `direct-match` items and advisory rows for `cross-cutting` items. New-write tasks for items that have a `direct-match` are downgraded to Risks ("existing X candidate found; reuse or document why a new one is needed").
-12. **MUST: Figma access - 3-tier fallback chain, pipeline-wide.** When any Figma URL or node ID is supplied (Phase 0 Step 5), Phase 1 establishes a Figma ground-truth artefact via the 3-tier chain before any UI synthesis runs: (1) Figma MCP `get_design_context` / `get_screenshot` / `get_metadata` for every referenced frame, with one re-auth retry on auth failure; (2) Figma REST API (`GET /v1/files/{fileKey}/nodes`, `GET /v1/images/{fileKey}`) using the PAT resolved through `~/.claude/lib/credential-store.sh get <logical-key>` where `<logical-key>` = `prefs.global.keychainMapping.figma`; (3) a user-attached screenshot as last resort. The tier in use is persisted as `state.figmaAccess.tier`. On Tier 1 the `CodeConnectSnippet` blocks name the exact target component consumed verbatim in Section 2 and Section 7. On Tier 2 the canonical-component decision falls back to the repo's `*.figma.swift` / `*.figma.kt` mappings keyed by `fileKey` + `nodeId`. On Tier 3 the canonical-component decision becomes "tier-3 best-fit pending design review" and produces a forced Open Question in Section 7 plus a Phase 4 `review_blocking` flag. Sound-alike alternatives, "more flexible" wrappers, and extrapolating from Confluence text-only "Component Kompozisyonu" / "Component Inventory" tables are forbidden in every tier. If all three tiers fail, halt the run and ask the user for access; never proceed with text-derived guesses. Section 7 architecture decisions must cite the node ID (Tier 1 or Tier 2) or the user-screenshot reference (Tier 3) for every UI atom row. Violations cost rebuild rounds (raw-primitive substitution; sound-alike-component swap). Generic rule rationale and checklist: see `$HOME/.claude/rules/figma-pipeline.md` "MUST: Figma access - 3-tier fallback chain (BLOCKING, pipeline-wide)". Memory: `[[figma-no-guesswork]]`.
+12. **MUST: Figma access - 3-tier fallback chain, pipeline-wide.** When any Figma URL or node ID is supplied (Phase 0 Step 5), Phase 1 establishes a Figma ground-truth artefact via the 3-tier chain before any UI synthesis runs: (1) Figma MCP `get_design_context` / `get_screenshot` / `get_metadata` for every referenced frame, with one re-auth retry on auth failure; (2) Figma REST API (`GET /v1/files/{fileKey}/nodes`, `GET /v1/images/{fileKey}`) using the PAT resolved through `~/.claude/lib/credential-store.sh get <logical-key>` where `<logical-key>` = `prefs.global.keychainMapping.figma`; (3) a user-attached screenshot as last resort. The tier in use is persisted as `state.figmaAccess.tier`. On Tier 1 the `CodeConnectSnippet` blocks name the exact target component consumed verbatim in Section 2 and Section 7. On Tier 2 the canonical-component decision falls back to the repo's `*.figma.swift` / `*.figma.kt` mappings keyed by `fileKey` + `nodeId`. On Tier 3 the canonical-component decision becomes "tier-3 best-fit pending design review" and produces a forced Open Question in Section 7 plus a Phase 4 `review_blocking` flag. Sound-alike alternatives, "more flexible" wrappers, and extrapolating from Confluence text-only "Component Kompozisyonu" / "Component Inventory" tables are forbidden in every tier. If all three tiers fail, halt the run and ask the user for access; never proceed with text-derived guesses. Section 7 architecture decisions must cite the node ID (Tier 1 or Tier 2) or the user-screenshot reference (Tier 3) for every UI atom row. Violations cost rebuild rounds (raw-primitive substitution; sound-alike-component swap). Generic rule rationale and checklist: see `$HOME/.claude/rules/figma-pipeline.md` "MUST: Figma access - 3-tier fallback chain (BLOCKING, pipeline-wide)". Memory: `[[figma-no-guesswork]]`. **A channel's design may not be called missing until the file tree has been scanned.** Run `figma-screenshot.sh --discover-sections --file-key <k> --feature-slug <s>`; sibling sections it returns join `evidence.figma[]` as their own entries and are never re-asked (Locked 1). Only an empty `candidates` list lets a channel be recorded as having no design, and the record must cite the scan (`fileKey`, `pagesScanned`, `tokensTried`). Declaring a channel missing without scanning fails the dispatch gate: one run did, and the sibling was sitting in the same file with nine frames in it.
 13. **Gherkin user stories.** Section 4 scenarios use Given / When / Then. Plain-prose user stories are rejected at render time.
 14. **Goals and Non-Goals are paired.** Section 2 always carries both columns. A row in only the goal column without an explicit non-goal counterpart is rejected. Vague "out of scope" phrasing does not satisfy the non-goal column; each non-goal names what is excluded.
 15. **New assets default to SVG.** Section 8 entries marked `new` are SVG unless a documented exception is captured in the rationale column (Lottie for motion design, optimized PNG for raster-only icons). PDF, JPG, and unoptimized PNG are rejected.
 16. **Files-to-Add tag mandatory.** Every row in Section 14 carries one tag from `Reuse | Add new | Modify`. Untagged rows fail the dispatch gate.
 17. **API response variants exhaustive.** Section 9 lists every HTTP status code returned by the endpoint with at least one example body and the matching UI outcome. Phrases like "other errors" or "various 4xx" are rejected.
-18. **Screenshots embedded, not linked.** Section 5 frame galleries reference local PNG files. Dispatch uploads them as Confluence multipart attachments and injects `<ac:image><ri:attachment ri:filename="..." /></ac:image>` into the page body. URL-only Figma references in Section 5 are a review finding, not a validator ERROR: the check belongs to the Confluence dispatch step, which is the only place that knows whether an attachment upload succeeded.
-19. **All Figma variants drilled.** When a Figma section URL is supplied, all child frames are drilled, not just the canonical default. The renderer enumerates child frames via `mcp__claude_ai_Figma__get_metadata` (Tier 1) or `figma-screenshot.sh --section` (Tier 2) and produces one Section 5.1 row per child frame.
+18. **Screenshots embedded, not linked, and every inventory row gets one.** Section 5 frame galleries reference local PNG files. Dispatch uploads them as Confluence multipart attachments and injects `<ac:image><ri:attachment ri:filename="..." /></ac:image>` into the page body. The gallery is generated from the inventory, never hand-picked: one row, one embedded image, ordered by node id and titled `<nodeId> <frame name>`. A bare filename in a table cell is text to the reader, not a picture, which is how a run that uploaded 34 attachments and embedded 14 of them was reported as "frames not uploaded" - the files were there and invisible. Narrowing to a canonical subset for page weight is not a call the run makes on its own; the display-width cap (`md2confluence-v3.py --image-width`, phone frames overriding to 320) already solves readability without dropping evidence. Dispatch reports the embedded-over-inventory ratio and warns below 1. URL-only Figma references in Section 5 are a review finding, not a validator ERROR: the check belongs to the Confluence dispatch step, which is the only place that knows whether an attachment upload succeeded.
+19. **All Figma variants drilled, and drilled means read.** When a Figma section URL is supplied, all child frames are drilled, not just the canonical default. The renderer enumerates child frames via `mcp__claude_ai_Figma__get_metadata` (Tier 1) or `figma-screenshot.sh --section` (Tier 2) and produces one Section 5.1 row per child frame. Counting them is not drilling them: extract the visible `TEXT` layers inside each frame's own bounds, dropping hidden layers and component-instance boilerplate that overflows the frame (in one run a frame carried 88 text layers of which 13 were real, the rest default flight-card and currency-widget filler). A frame may be called out of scope only by quoting its own extracted text; "the name looked unrelated" is not a reason. Opening a Section 20 question about a frame requires that its text was extracted first, and asking about a frame nobody read fails the dispatch gate. One run did exactly that: a frame named `08 Payment` was logged as ambiguous and questioned, while its text spelled out the whole payment step, and the use case shipped incomplete.
 20. **Localization mode (ownership-aware).** Section 10's shape is driven by the project `figma-config` `localization.ownership` (default `in-repo`). The locale set comes from `localization.locales` (default `tr, en, ar, de, es, fr, it, ru`); do not hardcode a locale list in the render.
     - **`in-repo`** (default, historical behavior): new keys carry filled cells for every configured locale. Placeholder values `[bekleniyor: çeviri ekibi]` / `[pending: translation team]` are a soft state and the dispatch report flags `i18n_pending: <count>` as a blocker. Empty cells are rejected outright.
     - **`externally-owned`**: per-locale values are owned by the authoring system named in `localization.authoringPipeline` and MUST NOT be hand-filled. Section 10 lists `key | status | copy source | base value | ownership` only; the gate becomes "the `localization.baseLanguage` value is present (sourced from the Figma annotation, Locked 3) AND the ownership reference is cited". A key missing its base-language value is a blocker (it renders the raw key at runtime). Fabricated per-locale values are rejected.
@@ -56,3 +56,4 @@ When citing a Locked decision in code or docs, prefer `Locked <n> (<short label>
 33. **Corporate backbone always renders.** In the `corporate` profile the Locked 2 omission rule is replaced for Part A and the footer: those sections render even with zero evidence, carrying `N/A` when the section is genuinely out of scope for the feature and `EKLENECEK` when evidence is expected but missing. This is the point of a requirements document - a reader has to be able to tell "we considered hardware needs and there are none" from "nobody looked". Every `EKLENECEK` emits a matching Section 20 Risks and Open Questions row naming what is missing and who can answer it; an `EKLENECEK` with no such row fails the dispatch gate, because an unanswered question nobody owns is how a placeholder reaches production. **Missing inputs never block the run**: the corporate source practice of halting until every input arrives is deliberately not adopted - the document is produced with `EKLENECEK` in the gaps and the gaps are raised in Section 20. Part B follows the global omission table unchanged. In the `global` profile Locked 2 applies as written, with no placeholder of any kind.
 34. **References are built from the evidence record, not written.** Section 21 is emitted by `$HOME/.claude/scripts/build-references.mjs` from `state.analysisSpec.evidence.*` in both profiles. Each row carries a precision anchor in its `Sürüm / Ref` column - Figma node id, Confluence `pageId` plus page version, the commit SHA a repo was read at, the Swagger spec version - because a reference with no anchor points at a moving target. Each row carries an `Erişim / Access` cell: a declared source that could not be fetched still gets a row reading `erişilemedi (<reason>)`, since a silently dropped source reads to the next person as a source that never existed. User statements from the conversation that no fetched source contains are recorded as `Serbest metin` rows, quoted verbatim, with the decision they settled. **Coverage gate**: every entry in `evidence.figma[]`, `confluence[]`, `jira[]`, `swagger[]`, `repo[]`, `standards[]`, `firebase[]`, `documents[]`, `outside[]`, `freeText[]` and every entry in `evidence.fetchErrors[]` must appear as a row, and every row must map to an evidence entry. A source that shaped the document but is missing from References fails the dispatch gate; so does an invented row with no evidence behind it.
 35. **Stack-optional render.** Platform and repo selection are optional. When `state.analysisSpec.platforms[]` is empty, the run still completes: the analysis layers that do not need a target repository render in full - Part A and Part B in the corporate profile, Sections 1-12 and 16-17 in the global profile - and only the development layer is dropped (corporate Part C; global Sections 13, 14, 15) along with the Pass B projection, since there are no conventions to project onto. A Section 20 row records that the development analysis awaits a repo selection. **The channel split survives the missing repo.** Channels are derived from the evidence instead of repo stack tags (`intake.md` Step 3 carries the signal table) and one document is emitted per derived channel - `mobile`, `web`, or both. A phone screen and a browser screen carry different requirements before anyone has picked a repository; the split (Locked 9) exists to carry that difference and only its *projection* half needs conventions. `mobile` stays one channel rather than iOS plus Android, since without conventions nothing tells the two apart. Evidence with no interface at all yields a single channel-agnostic `<feature>.md`. Files land under `~/Desktop/multiAgentAnalysis/<feature-name>/`, named `<feature>-<channel>.md` (or `<feature>.md` for the channel-agnostic case): the repo-relative `analysis/` path has nothing to be relative to without a repo, and the current working directory is never used, since for a repo-less run it is arbitrary. Desktop rather than a hidden directory because the document is a deliverable somebody is meant to open and hand over, and `multiAgentAnalysis` rather than a bare `Analysis` because a generic word collides with whatever else is on a desktop while the producer name groups every run this command ever writes. The Phase 3.5 picker shows the resolved path and takes an override through its Other input. A requirements document is useful before anyone has decided which repository will hold the code, and refusing to produce one until that decision exists inverts the order the work actually happens in.
+36. **The document is reviewed before it is published.** An analysis run used to go from draft straight to dispatch behind a deterministic validator, so nothing read what it was about to publish: one run put a channel it never searched for, an open question about a frame it never opened, and twenty-three unowned `EKLENECEK` markers onto a live page. Every one is what a reader catches on the first pass. Phase 3.2 runs `phases/phase-4-review.md` Step 0 (strict validator, the host's three-reviewer set, triage) on the draft before the destination is chosen: a finding is cheap while nothing is written. Reviewers are subagents holding `analysis/review.md`, never the context that wrote the document, which cannot notice a search it never thought to run. A blocking finding returns to Phase 2b with dispatch closed and never becomes an open question, since "the document is wrong" is not something to ask the reader; capped at two returns. Phase 3.3 sorts every remaining gap into searched-and-closed, asked-and-answered, or `AS-NN`; an unstamped gap fails the dispatch gate. Autopilot runs both; only the asking degrades, into rows stamped `autopilot: could not ask`.

package/pipeline/multi-agent-refs/analysis/render.md

@@ -42,6 +42,43 @@
    ```
    User can inspect drafts before choosing output destinations in Phase 3.5.
 
+### Phase 3.2 - Draft review (BLOCKING, runs in every mode)
+
+Locked 36 carries the rule. Operationally:
+
+1. Run `phases/phase-4-review.md` Step 0, the analysis-mode branch. It already defines
+   the strict validator, the host's three-reviewer set with its model routing, and the
+   triage. Do not restate it here; a second definition is the one that rots.
+2. Dispatch reviewers as subagents, each given the draft path, the state JSON and
+   `analysis/review.md`. Never review from this context: it cannot notice a search it
+   never thought to run.
+3. Blocking -> back to Phase 2b, dispatch closed, never an open question. Advisory ->
+   Phase 3.3. Cap at two returns, then stop and surface what blocks.
+
+Autopilot included. State: `phase = "reviewing_draft"`.
+
+### Phase 3.3 - Close the gaps (BLOCKING)
+
+Phase 3.2 produced the list. Sort every entry and act:
+
+| Bucket | Meaning | Action |
+|---|---|---|
+| A. Not searched | The evidence is reachable and this run did not look | Run the search; it closes, and never becomes a question |
+| B. The user knows | Channel scope, which service backs a screen, what is in scope | Ask, `AskUserQuestion`, at most 4 per call |
+| C. External | Final copy, a legal basis, a contract nobody has written | Record as `AS-NN` in Section 20 |
+
+**Bucket A must be empty before Phase 3.5.** A gap reaches C only with a stamp:
+`searched, not found` naming what was searched, or `asked, external`. Unstamped
+`EKLENECEK` fails the dispatch gate. A is where most open questions came from in
+practice, and none were questions - they were searches nobody ran.
+
+B is asked in every interactive mode; autopilot moves B to C stamped `autopilot: could
+not ask`, so an unanswerable gap reads differently from an unasked one. A stays required
+under autopilot: a search needs no human.
+
+Re-render affected sections, then report gaps closed by search, by asking, and entered.
+State: `phase = "reviewing_gaps"`.
+
 ### Phase 3.5 - Output destination picker
 
 AskUserQuestion (multiSelect=true), at least one selection required. `Local file` pre-selected per Locked decision 5.
@@ -169,15 +206,13 @@ Per the `analysis-output-confluence-on-request` memory, Confluence post is NEVER
 2. Use parent page URL from user input. No default parent is hardcoded here; the user picks one at the prompt (LRU recents come from `prefs.projects[<project>].confluenceUrls`).
 
    **Corporate profile exception.** When `state.analysisSpec.profile == "corporate"` and the bindings are configured, the destination is already settled and the prompt is skipped: the space comes from `prefs.global.analysisProfile.corporate.confluenceSpaceKey`, the parent from `prefs.global.analysisProfile.corporate.confluenceParentPageId`, and the page title is built from `prefs.global.analysisProfile.corporate.titleFormat` with `prefs.global.analysisProfile.corporate.titlePrefix` filling its `{prefix}` placeholder. A corporate analysis always lands in the same tree, so asking each time is a question whose answer never changes. Any of the four missing falls back to the prompt above rather than guessing, and a title that would collide with an existing page becomes an update (PUT with version bump), never a second page.
-3. **Publish with `md2confluence-v3.py`, never a hand-rolled conversion + curl.** The
-   script owns the three steps that are easy to get wrong and that a hand-rolled path
-   has already dropped in practice: the storage-XML conversion (the table in
-   `$HOME/.claude/multi-agent-refs/channels/confluence.md`), the multipart upload of
-   every PNG in `--attachments-dir`, and the `![](file.png)` to
-   `<ac:image><ri:attachment ri:filename="file.png"/></ac:image>` injection that makes
-   a frame gallery render as pictures instead of as filenames (Locked 18). It also
-   warns when a body references an image no attachment matched, which is the signal
-   that a screenshot never downloaded.
+3. **Publish with `md2confluence-v3.py`, never a hand-rolled conversion + curl.** It
+   owns the three steps a hand-rolled path has already dropped: storage-XML conversion
+   (`channels/confluence.md`), the multipart upload of every PNG in `--attachments-dir`,
+   and the `![](file.png)` to `<ac:image><ri:attachment/>` injection that makes a frame
+   gallery render as pictures rather than filenames (Locked 18). It also warns when a
+   body references an image no attachment matched, which is how a missing screenshot
+   announces itself.
 
    ```bash
    python3 "$HOME/.claude/lib/md2confluence-v3.py" create \

package/pipeline/multi-agent-refs/analysis/review.md

@@ -31,9 +31,25 @@ node "$HOME/.claude/scripts/build-references.mjs" "<state>" --check "<doc>"
 
 **No state JSON, no references gate.** Say so in the report rather than passing silently: the coverage claim ("every source the run read is listed") is exactly the claim nobody can verify from the document alone, and marking it unchecked is the honest output.
 
+## Phase 1.5 - What did the run skip?
+
+Ask this before rubric quality. A document can be well-formed and still be wrong
+because the run never looked. Every row here is a finding class observed in a real run.
+
+| Skip class | Evidence it happened |
+|---|---|
+| A declared-missing input nothing searched for | `evidence.fetchErrors[]` has no entry for it and the document cites no scan |
+| An open question about evidence never read | a Section 20 row names a node, page or file with no extracted content behind it |
+| A gap with no owner | `EKLENECEK` with no `AS-NN`, or an `AS-NN` naming nobody |
+| A scope call made without asking | the document narrows what the request asked for and no picker answer records it |
+
+A skip is blocking, not advisory: the fix is a search or a question, and both are
+cheaper before publication than a correction after it. Report each with what should
+have been searched, so Phase 3.3 can put it in the right bucket.
+
 ## Phase 2 - Rubric
 
-Parallel model review, same shape as `/multi-agent:review`: 2 models on Claude Code, 3 on Copilot CLI, then triage. Each reviewer answers the rubric below against the resolved profile and returns findings with `Locked <n>` or a rubric id, a quote from the document, and what a reader cannot do because of it.
+Parallel model review, same shape as `/multi-agent:review`: 3 models on Claude Code, 3 on Copilot CLI, then triage. Each reviewer answers the rubric below against the resolved profile and returns findings with `Locked <n>` or a rubric id, a quote from the document, and what a reader cannot do because of it.
 
 **A. Buildability** - could an implementer start from this alone?
 

package/pipeline/multi-agent-refs/analysis-template-corporate.md

@@ -283,11 +283,22 @@ One table per service. Contracts come from the live specification, never from pr
 | **Method** | GET / POST / PUT / DELETE |
 | **Description** | <what it does> |
 | **Success and error codes** | **200** <meaning> **401** <meaning> **403** <meaning> |
-| **Request** | <example body, fenced> |
-| **Response** | <example body, fenced> |
+| **Request** | Asagidaki govde / Govde yok / EKLENECEK (AS-NN) |
+| **Response** | Asagidaki govde / Govde yok / EKLENECEK (AS-NN) |
 ```
 
-A session-bound service states its token requirement in the `Request` cell. A service that does not exist yet is named with an explicit note rather than a guessed path.
+**Payloads live below the table, never inside a cell.** Each is a fenced ```json block,
+beautified, preceded by a label line: `Request:`, `Response:`, or a status code
+(`200:`). Field notes get their own table (`Alan | Tip | Zorunlu | Aciklama`); a note
+pasted after inline JSON in the same cell is what made one document render `Request`
+and `Response` in two different formats in the same table. A `{` or `}` inside a
+service cell is a validator ERROR.
+
+A session-bound service states its token requirement as one sentence under the field
+table, not inside the request payload. When only the name is unknown the table still
+renders; when the whole contract is unknown, write one line instead of six `EKLENECEK`
+cells: `Bu servisin sozlesmesi tanimli degil (AS-NN).` Render the table only once
+`Name` and `Path` are both known.
 
 ### 5.(N+5) Servis - Fonksiyonel Gereksinim Eşleştirmesi
 

package/pipeline/multi-agent-refs/knowledge.md

@@ -80,7 +80,7 @@ Phase 3: Dev
        Context: Phase 2 plan + task dependencies
 
 Phase 4: Review (CLI-aware parallel + triage)
-  Claude Code (2 parallel):
+  Claude Code (3 parallel):
     |-- Reviewer (opus)   -> security + architecture
     +-- Reviewer (sonnet) -> quality + correctness + edge cases
   Copilot CLI (3 parallel):

package/pipeline/multi-agent-refs/phases/phase-4-review.md

@@ -1,6 +1,6 @@
 ### Phase 4: Review (deterministic gates + parallel + triage)
 
-> **TLDR**  -  Three-stage review. Stage 1: deterministic gates (build + lint + test + secret scan) that MUST pass. Stage 2: AI models in parallel  -  reviewer set is **CLI-aware**: Claude Code dispatches 2 reviewers (Fable + Sonnet); Copilot CLI dispatches 3 reviewers (GPT-5.4 + Opus + Sonnet - Fable 5 is not offered on Copilot CLI). Stage 3: Fable triage (Opus on Copilot CLI)  -  evaluates raw findings, filters false-positives/out-of-scope, keeps only actionable items. Only triage-accepted blocking items loop back to Phase 3.
+> **TLDR**  -  Three-stage review. Stage 1: deterministic gates (build + lint + test + secret scan) that MUST pass. Stage 2: AI models in parallel  -  every host dispatches 3 reviewers; only the second slot is **CLI-aware**: Claude Code dispatches Fable + Opus + Sonnet; Copilot CLI dispatches 3 reviewers (GPT-5.4 + Opus + Sonnet - Fable 5 is not offered on Copilot CLI). Stage 3: Fable triage (Opus on Copilot CLI)  -  evaluates raw findings, filters false-positives/out-of-scope, keeps only actionable items. Only triage-accepted blocking items loop back to Phase 3.
 
 <!-- progress-contract: applied -->
 Progress emission per `$HOME/.claude/multi-agent-refs/progress-contract.md`  -  lines for each gate, each reviewer dispatch + finish, triage start, triage verdict, fix dispatch.
@@ -264,18 +264,18 @@ Phase 4 sends the same diff to every reviewer and then to triage, so the diff is
 
 #### Step 2  -  Parallel AI Review (CLI-aware reviewer set)
 
-Launch Agent instances **in parallel** using the shared `code-reviewer` subagent definition (`~/.claude/agents/code-reviewer.md`). The reviewer set is determined by the host CLI  -  GPT-5.4 is only available on Copilot CLI, so Claude Code skips that reviewer and runs a 2-model parallel review; Copilot CLI runs all three.
+Launch Agent instances **in parallel** using the shared `code-reviewer` subagent definition (`~/.claude/agents/code-reviewer.md`). Every host runs three reviewers; only the second slot differs, because GPT-5.4 exists on Copilot and Codex but not on Claude Code, where Opus fills it. Three reviewers on Claude Code cost more than two, and the cost buys the thing a second opinion cannot: a finding two independent readers both miss is what triage has no chance to catch.
 
 **Scope from Step 1.77.** `$REVIEW_SCOPE == "single"` → dispatch **Reviewer 1 only**, and skip Step 2.5 + 3.6 (both no-ops with one reviewer). `"full"` (default + fail-safe) → the whole set below. Either way record the count in `consensus.reviewerCount`.
 
 | Reviewer   | subagent_type   | Claude Code | Copilot CLI | Codex CLI | Focus | Skills Referenced |
 | ---------- | --------------- | --- | --- | --- | --- | --- |
 | Reviewer 1 | `code-reviewer` | `claude-fable-5` | `claude-opus-5` | `gpt-5.6` @ `xhigh` | Deep security + architecture | `api-security-best-practices`, `architecture` |
-| Reviewer 2 | `code-reviewer` | (not dispatched) | `gpt-5.4` | `gpt-5.4` @ `high` | Edge cases, different perspective | cross-model diversity |
+| Reviewer 2 | `code-reviewer` | `claude-opus-5` | `gpt-5.4` | `gpt-5.4` @ `high` | Edge cases, different perspective | cross-model diversity |
 | Reviewer 3 | `code-reviewer` | `claude-sonnet-5` | `claude-sonnet-5` | `gpt-5.6` @ `medium` | Quality + correctness + naming | `ai-backend-toolkit:clean-code`, stack-specific skill |
 | Triage     | triage persona  | `claude-fable-5` | `claude-opus-5` | `gpt-5.6` @ `max` | Filter false positives + out-of-scope | - |
 
-Reviewer count per host: **Claude Code 2, Copilot CLI 3, Codex CLI 3**.
+Reviewer count per host: **Claude Code 3, Copilot CLI 3, Codex CLI 3**.
 
 #### Codex CLI  -  two constraints that fail silently
 
@@ -302,11 +302,11 @@ in the triage note when all three agree on a borderline finding.
 
 Each reviewer inherits the `code-reviewer` agent's focus areas (Security, Architecture, Quality, Performance) and output contract. The orchestrator overrides only the model and the stack-specific skill per-reviewer  -  no prompt duplication.
 
-**Model override wiring:** `code-reviewer.md` declares `preferredModel: fable`, so Reviewer 1 uses the persona default (Fable 5). Reviewer 2 (Copilot-only, `gpt-5.4`) and Reviewer 3 (`claude-sonnet-5`) set `PHASE_MODEL_OVERRIDE=<model>` before dispatch  -  the orchestrator exports `CLAUDE_CODE_SUBAGENT_MODEL` on Claude Code, or passes `--model` on Copilot CLI. Full precedence rule: `skills/shared/core/multi-agent/SKILL.md#agent-dispatch--per-persona-model-routing-v610`. Fable dispatches are subject to the fallback contract (`$HOME/.claude/multi-agent-refs/features/model-fallback.md`): dispatch-error retry walks `fable -> opus -> sonnet` and budget-ceiling downgrade.
+**Model override wiring:** `code-reviewer.md` declares `preferredModel: fable`, so Reviewer 1 uses the persona default (Fable 5). Reviewer 2 (`claude-opus-5` on Claude Code, `gpt-5.4` elsewhere) and Reviewer 3 (`claude-sonnet-5`) set `PHASE_MODEL_OVERRIDE=<model>` before dispatch  -  the orchestrator exports `CLAUDE_CODE_SUBAGENT_MODEL` on Claude Code, or passes `--model` on Copilot CLI. Full precedence rule: `skills/shared/core/multi-agent/SKILL.md#agent-dispatch--per-persona-model-routing-v610`. Fable dispatches are subject to the fallback contract (`$HOME/.claude/multi-agent-refs/features/model-fallback.md`): dispatch-error retry walks `fable -> opus -> sonnet` and budget-ceiling downgrade.
 
-**Stack-specific skills loaded per reviewer** (from Phase 1 `detectedStack`). On Claude Code, Reviewer 2 (GPT-5.4) is not dispatched  -  its skill column is ignored. On Copilot CLI all three columns are used.
+**Stack-specific skills loaded per reviewer** (from Phase 1 `detectedStack`). All three columns are used on every host; Reviewer 2 reads them as Opus on Claude Code and as GPT-5.4 elsewhere.
 
-| Stack | Reviewer 1 (Fable / Opus on Copilot) | Reviewer 2 (GPT-5.4  -  Copilot CLI only) | Reviewer 3 (Sonnet) |
+| Stack | Reviewer 1 (Fable / Opus on Copilot) | Reviewer 2 (Opus on Claude Code, GPT-5.4 elsewhere) | Reviewer 3 (Sonnet) |
 |-------|-------------------|-----------------------------------------|---------------------|
 | iOS/Swift | `ai-ios-toolkit:ios-security`, `ai-ios-toolkit:swiftui-performance`, `ai-ios-toolkit:hig-patterns` | `ai-ios-toolkit:swift-concurrency`, `ai-ios-toolkit:ios-accessibility` | `ai-ios-toolkit:swiftui-pro`, `ai-ios-toolkit:swift-testing` |
 | Android/Kotlin | `ai-android-toolkit:android-security`, `ai-android-toolkit:android-performance` | `ai-android-toolkit:compose-testing`, `ai-android-toolkit:android-architecture` | `ai-android-toolkit:compose-components`, `ai-android-toolkit:kotlin-coroutines-expert` |
@@ -557,7 +557,7 @@ emit() {  # $1=event $2=model $3=duration $4=tokens_in $5=tokens_out
 }
 emit review.reviewer_call fable  "$R1_DURATION"     "$R1_IN"     "$R1_OUT"      # opus on Copilot CLI
 emit review.reviewer_call sonnet "$SONNET_DURATION" "$SONNET_IN" "$SONNET_OUT"
-# Reviewer 2 is GPT-5.4 and exists only on Copilot CLI:
+# Reviewer 2 is Opus on Claude Code and GPT-5.4 elsewhere:
 [ "${CLI_HOST:-claude}" = "copilot" ] && \
   emit review.reviewer_call gpt-5.4 "$GPT_DURATION" "$GPT_IN" "$GPT_OUT"
 emit review.triage_call fable "$TRIAGE_DURATION" "$TRIAGE_IN" "$TRIAGE_OUT"