ComfyUI Higgsfield Opensource Challenge

The event is framed as “Open Source Higgsfield,” which reads as there is something to fork. That had to be settled first, because the entire build depends on it. analysis/10-comfyui-substrate-inventory.md (16:20) and analysis/11-contentstudio-inventory.md (16:23) were written to answer it from source.

The answer is nothing. No Higgsfield model weights, no training code, no platform source. Cinema Studio 4.0 runs on Seedance 2.5 (ByteDance) — a closed, hosted API. There is no repo to fork, nothing to vendor, nothing to patch.

analysis/20-competition-brief.md. The re-aim in one line: Cinema Studio's value is “re-shoot this from any angle and it will still cut together.” We are open-sourcing that guarantee — as a measurable, verifiable property of a ComfyUI graph, not a prompt.

The constraint that shaped every other decision, and the part most likely to be got wrong by other entrants:

“Open weights” is not “open licence.” A pack that ships a MiniMax H3 graph is not an open-source submission in the US — it is a licence violation with a demo attached. The commitment is checked by grep, not asserted.

00-BREAKDOWN.md and 01-SPEC.md written and frozen. The spec is what the differential check is measured against later, so freezing it early is what makes that check meaningful.

The honesty ledger went in at this point rather than being added after the fact: the reference rule set documents 38 rules, of which 14 are machine-evaluated: 9 framing rules are evaluated per frame, plus 3 multi-entity scene rules and 2 sequence-level continuity rules. The other 24 are documented prose, not code. We do not claim 38 rules are implemented.

continuity.py 16:57 · reliability.py 16:58 · autoframe.py 17:02 · geometry.py / framing.py / scene.py 17:03.

Why separate: the engine imports nothing from ComfyUI. It is testable, portable and reviewable without a GPU or a ComfyUI install. It is a faithful port of a Go reference implementation — which is the only reason the differential check in Phase 4 is possible at all.

The solver fix, and the claim we do not make. The Go original runs exactly 24 iterations and returns the 24th iterate's report unconditionally. There is no convergence test and no early exit, so nothing guarantees overall_pass. Our port adds early exit on overall_pass, a converged flag, the iteration count actually used, and a residual naming the rules still failing. We do not claim the solver converges in general. We claim it reports honestly whether it did.

test_autoframe.py 16:59 · conftest.py 16:59 · test_geometry.py 17:00 · test_continuity.py 17:00. test_framing.py follows at 17:35, after a correction (see the 17:34 entry).

The adversary re-derived the expected values from first principles and confirmed they are genuinely hand-computed rather than snapshots — but also confirmed the suite is a value test, not a contract test: 11 of 24 injected defects survive it. That is defect #5, and it is still open.

nodes.py 17:03 · app/cinematographer/__init__.py 17:03. Six nodes under the Cinematographer category. Every structured input and output is a plain JSON string, so the nodes compose with anything in a graph and are trivially testable without ComfyUI installed.

nodes.py is the only file in the package permitted to touch ComfyUI, and even there the dependency is optional — the probe is wrapped, so the module and every node class import cleanly on a machine with no ComfyUI. That is what lets python -c "import cinematographer" work in CI and lets the director's panel reuse the same classes.

differential_check.py 17:03 · the reference dump and its JSON fixture 17:04.

It runs the Go reference dump through the Python port at TOL = 1e-6 and compares value-for-value. That is what turns “we ported it” into “we ported it correctly.”

What the 289 is, exactly. The adversary instrumented the counter and decomposed it: it is 289 heterogeneous rule-slots checked, not 289 assertions. Two of those slots (size_importance) compare pass only — the value is skipped. The headline number is exact; the phrase “value-for-value” in verification/README.md is not, and that is defect #3.

pyproject.toml, requirements.txt and LICENSE (Apache-2.0) written at 17:04. The competition requires an OSI licence; Apache-2.0 is the same licence as the Wan 2.2 stack the graphs load, so the code and the weights agree.

02-DEMO-SCRIPT.md and 03-SUBMISSION.md at 17:05. Target 1:48, hard limit 2:00 — the form rejects longer.

Submission needs: a public repo URL · a demo video under 2 minutes · a social post tagging #OpenSourceHiggsfield · category multi-select · optional live link. The only stated rule is one submission per person. No judges and no rubric have been published — so the plan optimises for a legible two-minute demo rather than for a guessed rubric.

Two beats in this script do not match the running panel. That mismatch is still open.

parity_check.py 17:06 · cinematographer.js 17:06 · parity_fixtures.json 17:07. The panel is a JavaScript mirror of the Python engine, and parity is checked three ways: JS against frozen fixtures, Python against the same fixtures, and Python against JS live.

The third leg is what makes it non-circular — it does not go through the fixtures at all, so a JS-only or Python-only drift cannot hide. The adversary tested this directly and confirmed it: JS mutations are caught.

But the parity check shares the differential check's blindness. Four of ten JS mutations went undetected, all of them threshold moves. Same root cause: no fixture sits near a boundary. Defect #5.

reshoot_ltx_crossview.json 17:10 — LTX 2.3 + CrossView-Warp IC-LoRA + MoGe-2, 35 nodes / 49 links. reshoot_wan22_fun_control.json 17:11 — Wan 2.2 Fun-Control (Apache-2.0), 25 nodes / 33 links.

Naming correction recorded: the Wan graph was originally named reshoot_wan22_vace.json. The checkpoint is Fun-Control, not VACE. Renamed, and the _README naming note plus both cross-references updated.

A structurally valid graph is not a working graph. Neither has been executed. The _README node inside each graph says so in its first line: STATUS: NOT VERIFIED. This graph has never been executed. and MEASURED: nothing. No timing, no VRAM figure, no output.

app.js and browser_check.mjs 17:14 · app/web/README.md 17:16. A three.js panel that renders the camera, the subject and the rule results live. It is what makes the demo video legible in under two minutes.

Honest note carried forward: the panel opens on a failing frame (rule_of_thirds, headroom) so the demo has something to fix. After Auto-Frame the overall badge reads PASS while lead_room (weight 0.4) may stay red — that is the spec, and the panel shows it rather than hiding it.

The adversary called this the best-verified surface in the entry: the browser check really does drive headless Chrome, click Auto-Frame, and sample WebGL pixels.

verification/ADVERSARIAL-REVIEW.md — 740 lines. Stance: falsify, not confirm. A review that finds nothing is a failed review. 17-item defect register, 24-attempt falsification log.

Verdicts: A PARTIAL · B PARTIAL · C CONFIRMED · D CONFIRMED (not circular) · E PARTIAL · F CONFIRMED · G REFUTED · H PARTIAL.

Bottom line, in the adversary's own words: “Not safe to submit as-is.”

What survived attack — and this is the part worth keeping: the solver convergence claim survived 1,800 adversarial calls with zero violations (converged == report.overall_pass always; no zero-iteration convergence; no lying residual). The parity check is not circular. The workflow validator caught all 6 injected structural defects. Licence and trademark clean.

What did not survive: the pack root had no __init__.py. That is CRITICAL, and it is the next entry.

This is the single most valuable document in the build, and it is the reason this log can be blunt.

The defect. ComfyUI's loader does not recurse. init_external_custom_nodes uses os.listdir with no recursion, then loads <pack_root>/__init__.py by path. A pack root must have an __init__.py. Ours did not — the pack would have failed to load with FileNotFoundError: 'ComfyUI-Cinematographer/__init__.py'. A judge following the README would have got an empty category, not six nodes.

The fix. app/__init__.py written as a pack-root shim that inserts its own directory into sys.path and re-exports the mappings.

The proof, re-run first-hand by buildlog at 17:58 PT — not quoted from PLAN.md:

And the limit of that proof, stated plainly. The same replay against the repository root as pack root still fails with FileNotFoundError, because the repo root has no __init__.py. The fix is real but conditional on the pack root being app/. That gap was raised by buildlog at 17:58 and fixed by the Lead at 17:59 — see the pack-root fix above.

Three of the seventeen register items are closed. The three MAJOR items that remain open — 12 unconstrained constants, eyeline never differentially verified, and the “value-for-value” claim — are IN FLIGHT and are still open.

PLAN.md written to be read alongside the build. Where the plan and the build disagree, the build wins and the file is corrected — and the correction is recorded in the changelog rather than quietly overwritten.

Status vocabulary fixed and used consistently: DONE (built, and a named check passes) · BUILT (code exists and imports, no end-to-end run) · IN FLIGHT · PLANNED · BLOCKED · CUT · NOT VERIFIED.

This log uses the same vocabulary, deliberately, so the two can be read together.

The Magieva wordmark was decoded to PNG — 2000×572, bright-on-pure-black — and placed in the panel's upper-left nav at 17:49. It is rendered with mix-blend-mode: screen so the black plate drops out on a dark bar. That is the verified-working treatment, and it is the same treatment used in this log's own nav.

The panel header then reads Magieva · Cinematographer — Director's Panel, which is the challenge surface the user asked for: a customised ComfyUI Higgsfield Opensource Challenge panel with the Magieva mark in the upper-left.

comfyui-higgsfield-cinema-oss.html and .pdf at 17:51 — the narrative dossier built on the analysis layer. app/README.md at 17:52, including the corrected install path (the pack root is app/, not the repo root) and an “Honest limitations” section that names the size_importance approximation and the unverified graphs.

The ask: record the build historically, while doing it — on screen, with screenshots, video, code, everything except secret keys — and put every open item that needs a human judgement on screen with a description of the choice, rather than asking in chat.

So this log is written from the artefacts and the file mtimes, not from memory, and the open items are tracked in the operator's own call sheet, which is not published. Nothing in this log is a reconstruction.

buildlog/tools/capture_clip.mjs launches headless Chrome, speaks the DevTools Protocol, drives the real sliders and buttons, and captures real paints. No screenshot in this log is synthetic.

• 131 frames at 1600×1000 → assets/panel-clip.mp4 — 10.9 s, H.264, 362 KB, silent, no voice-over, unscripted.
• Five stills: default FAIL, headroom FAIL, CONVERGED, NOT CONVERGED, plus region crops of the continuity strip, the Node I/O accordion and the rule panel.

The NOT CONVERGED state was found for real. The adversary reported it reachable in only 3 of 54 button-only states and noted the demo script never says how to get there. We searched the 9 button-only combinations and found it: subject height 1.20 m + closeup + high angle → NOT converged · 24 iter, overall FAIL, reliability RED. That is now a captured screenshot and a reproducible recipe, not a claim. (The residual line this entry first carried was wrong — see the 18:34 entry below.)

The continuity strip contradicts the demo script. The panel's default strip reads 30_degree FAIL (18 deg) on cut 1→2 and PASS (55 deg) on cut 2→3. 02-DEMO-SCRIPT.md:95 says “changed 53°” and omits the failing cut. That mismatch is still open.

What this clip is not: it is not the submission demo video. It is silent, unscripted and 10.9 seconds. The submission video (02-DEMO-SCRIPT.md, target 1:48) is a separate artifact: RECORDED at 88.66 s, 1920×1080, with audio, and published as the v0.1.1-demo release asset.

These were run by buildlog at 17:58 PT, not quoted from PLAN.md or from the Lead. That distinction is the whole point of the honesty ledger — a number that has been independently reproduced is a different kind of claim from a number that has been copied.

All four reproduce exactly. The loader replay is the fifth, and it is the one that produced a new finding during the loader replay.

The Lead added tests/test_boundaries.py (31 tests, suite 69 → 100) and verification/mutate_boundaries.py, which reports 9/9 mutations caught, exit 0. That is a real gate and it is a real improvement. But it exercises 9 mutations of its own choosing, and the adversary named 12 constants. A gate that picks its own exam is not a proof about the exam it didn't sit.

So I replayed the adversary's exact 12 against the current full suite, from a clean copy, one mutation at a time. 7 caught. 5 missed. All five leave 100 passed.

These are not hypothetical. shot_size_ok(0.405, "medium") returns True under both the original and the mutated bound. ang_delta(0, 179.5) is 179.5 originally and 180.5 mutated — the latter violating the function's own documented [0,180] contract. A global axis_side sign flip leaves every same-side/crossed assertion green.

The honest number is 7 of 12, not “closed.” To its credit, BOUNDARY-EVIDENCE.md predicted this exact failure mode and already concedes these are assertion-pinned, not mutation-proven. This replay is the number that caveat was missing. That gap is still open.

While re-verifying the NOT CONVERGED recipe first-hand I read the panel's own text and compared it to 02-DEMO-SCRIPT.md:90. They disagree.

Both are real, and they are different lists. The engine emits only failures with weight ≥ 0.8 (autoframe.py:184-186, OVERALL_PASS_WEIGHT = 0.8). For closeup, rule_of_thirds and lead_room do fail at -0.335 — but they carry weight 0.4 and are therefore excluded, while headroom (weight 1.0) is included. The script lists three rules; the screen lists two, and they are not the same two. The 0.280 vs 0.28 difference is :g dropping the trailing zero.

This is a small defect with a large blast radius: it is the one line in the demo script a judge could check against the screen in the same shot. Reported to the Lead — the file is not mine to edit. Suggested replacement: residual `headroom=0.612 shot_size=0.28` (weight ≥ 0.8 only; `rule_of_thirds` and `lead_room` also fail at -0.335 but sit below the threshold).

The first version of the feedback panel recorded a click to localStorage and offered a copy-to-clipboard summary. It looked like a feedback channel. It was not one. Nothing was listening, and the page had no way to know that — which is the worst kind of broken: it reports success.

So the wire is now real, and it is proven end to end:

• buildlog/tools/decision_listener.mjs — a zero-dependency HTTP listener bound to 127.0.0.1 only. POST /decision validates the payload, appends it to decisions.jsonl, then delivers it into a live DSH session and returns the real exit code and the agent's real reply. 200 on success, 502 on failure. Deliveries are serialised through a promise chain, one at a time.
• The page polls GET /health and renders a live listening / not listening pill. It cannot claim to be sending when nothing is there. That was the original sin, and this is the fix for it.
• Proven with a marker: BUILDLOG-DELIVERY-PROOF-1793324063 was delivered into a session, the agent replied DELIVERED and referenced its own prior turn, and the marker is present in the session's persisted transcript as a real user turn. Through the HTTP path: {"ok":true,"recorded":true,"delivered":true,"exitCode":0}.

Two gotchas worth writing down, both found the hard way. The --session-id value must match the session directory name exactly — the store holds both session-<uuid> and bare <uuid> forms, and the bare form fails with session "<uuid>" does not exist. And sessions are scoped to a project directory: running from the wrong cwd fails with was recorded in "<A>", not "<B>", exit 1. The listener decodes the project directory out of the store path and spawns with the right cwd.

What is still open: which session id the queue should target. It defaults to the operator's session and was tested against a throwaway scratch session. That is an open item, not a bug.

D1 is decided and executed. github.com/nathaniel-magieva/ComfyUI-Cinematographer is public, Apache-2.0 (GitHub detects the SPDX id from LICENSE), 36 files, 11,881 lines, commit ccecf38.

The layout choice is the interesting part. The contents of app/ were published as the repo root, so the pack root is the repo root and the standard install works unchanged:

git clone https://github.com/nathaniel-magieva/ComfyUI-Cinematographer \
    ComfyUI/custom_nodes/ComfyUI-Cinematographer

That is not cosmetic. It is the direct consequence of the __init__.py defect recorded earlier in this log: ComfyUI's init_external_custom_nodes does a non-recursive os.listdir over custom_nodes/ and then loads <pack_root>/__init__.py. If the checkout keeps the pack one level down, the loader fails with FileNotFoundError and no useful message. Publishing app/'s contents as the root removes that failure mode for every user, rather than documenting around it.

It required rewriting the layout docs: __init__.py's docstring, the README.md install blockquote, and 19 app/web/… path references now read web/…. The docstring no longer says “the pack root is app/”; it says “this repository is the pack root” and keeps the non-recursive-os.listdir explanation intact.

Acceptance test, re-run first-hand against a fresh anonymous clone — no auth header, replicating the loader's non-recursive os.listdir:

LOADED ComfyUI-Cinematographer: 6 nodes, __version__=0.1.0
   - CameraReliabilityZone
   - ChorosContinuity
   - CinematographerAutoFrame
   - CinematographerCorrection
   - CinematographerEvaluate
   - SceneFramingExtras

Repo page, raw README.md and raw LICENSE all return 200 anonymously. What stayed private: 00-BREAKDOWN.md, 01-SPEC.md, analysis/* and verification/go-reference-dump.json. The known gaps are disclosed in the public README rather than by publishing the internal review.

D4 is decided and the numbers are now settled. The recipe Reset → subject height 1.20 m → closeup → high → Auto-Frame gives NOT converged · 24 iter, overall FAIL, reliability RED, residual headroom=0.612, shot_size=0.28.

A full sweep of the panel's real slider range — 1.20–2.10 m step 0.01 × 3 shot types × 3 angles = 819 states — gives 8 non-converged, all closeup + high, heights 1.20 → 1.27. Python and the panel's own JS agree on all 8 states, residual for residual.

Two wrong numbers were published during this build and are retracted here.

Both retractions are written into 02-DEMO-SCRIPT.md. The number to quote is 8 of 819.

The structural point survived all three drafts, which is why it is worth keeping: the residual line is shorter than the rule panel because the engine emits only failures whose weight clears OVERALL_PASS_WEIGHT (if s.weight >= 0.8, autoframe.py:184). For closeup, rule_of_thirds and lead_room do fail but carry weight 0.4 and are excluded; headroom carries weight 1.0 and is included. The panel shows 9 rules; the residual shows 2. By design — and exactly why a presenter reading the rule panel aloud will misquote the residual.