CMK Diagnostic Concat

Most node packs have no idea what happened during a run. CMK Flow's nodes each emit a CMK_DIAGNOSTIC - a structured payload with a title, the node name, a mode, an ordered list of preview stages, a text summary, warnings and metrics. CMK Diagnostic Concat is the node that gathers thirty-two of those into one readable timeline.

What it is

A pure transport node in CMK/Toolbox/Diagnostics. It takes diagnostic_1 through diagnostic_32 - all optional, all typed CMK_DIAGNOSTIC - and emits a single diagnostic. That's the entire contract, and the source is unusually opinionated about it: "Concat is intentionally non-semantic: every input contributes all of its cards, unchanged and in connection order. Deciding which process is active or visually important belongs to the producer and renderer, never to this transport node."

That's the right design for this job, and it's why it works with a modular pipeline. Each CMK module knows what it did - ControlNet knows the model and the preprocessor and the source image, a face pass knows the detector and the crop - and this node doesn't second-guess any of it. The output goes into a visualizer or preview board, where you get one scrolling report of the run instead of twelve disconnected preview thumbnails.

How it works

Inputs are read in order, and unconnected ones are simply absent - optional inputs in ComfyUI aren't passed to the node at all when you leave them empty, so there's no null-checking theatre involved. Each payload is normalized defensively: the node accepts a direct diagnostic and also unwraps the occasional single-item tuple or dict wrapper the execution engine hands out, then validates the shape.

What comes out the other end preserves the whole structure. Every input keeps its own block, so a renderer can show process boundaries rather than flattening everything into one grid. Stages from all inputs concatenate in connection order. Warnings get prefixed with the originating source's title, so you can tell which module complained. The summary line builds a name chain for you:

Diagnostic Count: 7
Stage Count: 24
Sources: ControlNet Prepare → Smart Detailer → FaceProcess → Final Preview

Two small behaviours keep the timeline honest. An input that isn't a valid diagnostic is skipped rather than thrown, and it's reported by type - "expected CMK_DIAGNOSTIC, received str" - so a mis-wired string socket tells you what it was. And a nested concat with no real stages is dropped outright; the source comment says the point is not to turn a normalizer fallback into a meaningless black card in the middle of your timeline. Someone got annoyed by that once and fixed it.

Install

Ships with the pack. Manager: search CMK Flow, install the CMKFlow entry, restart. Manually, from the folder containing main.py:

git clone https://github.com/CMKFlow/cmk_nodes.git custom_nodes/cmk_nodes
python3 custom_nodes/cmk_nodes/scripts/install_cmk_requirements.py

Wait for CMK dependency check: OK before restarting - the helper installs requirements.txt into the Python environment ComfyUI is actually using, and a manual clone never does that on its own. Be aware that this is a heavy environment: ultralytics, onnxruntime, insightface, segment-anything, imageio-ffmpeg, opencv-python, nudenet==3.4.2. Installing it will do things to your shared environment.

Also switch on ComfyUI's Vue Nodes / Nodes 2.0 setting. CMK's dynamic nodes need it; without it you're on old LiteGraph rendering and the pack warns you at startup.

Issues worth knowing

This is CMK-specific plumbing: it only accepts CMK_DIAGNOSTIC, so it isn't a general-purpose "combine my reports" node. If you plug a STRING or a generic REPORT into it, you'll get a skipped input and a warning rather than a merged timeline.

There's no ordering widget. The order is the order you wired, which is fine - and it's also the reason a tidy source-to-sink wiring habit pays off here. If your timeline reads backwards, it's the wiring, not the node.

And there's no compression or de-duplication. Thirty-two diagnostics means thirty-two blocks and every preview image from each. If the visualizer feels sluggish, feed it fewer modules rather than assuming the concat is broken.