Atlas Read Locked Plate Plan 🔒

Somewhere upstream in the Atlas evidence pipeline, someone decided which models are allowed to process a photograph, what they may produce, and what counts as proof it happened. That decision is a plan, and once it's agreed it gets "locked." AtlasReadLockedPlatePlan is the gate that checks a locked plan before anything runs - it validates the plan's integrity, binds it to the plate it claims to govern, and passes through a canonical version downstream. Think of it as the bouncer at the door of the evidence lane: no valid lock, no processing.

How it works

A locked plan is a manifest - a signed-ish JSON document carrying the plate identity, the plan's phase (must be lock), the source artifact's content address, the list of artifact ids the plate's ledger currently holds, and a model policy listing exactly which models (id, version, hash, license) may produce attempts against this plate.

This node runs a strict binding check before it lets anything through. From the source, it verifies five things:

• the plan is in lock phase,
• the manifest digest validates,
• the plan's plate_id matches the plate you wired in,
• the plan's source content address matches the plate's source artifact,
• the artifact ledger the plan declares matches what the plate actually holds.

Any mismatch fails loudly - a plan for a different plate, or a ledger that drifted from what the plan was locked against, is rejected rather than silently accepted. That's the whole job. Outputs are locked_plan_json (the canonical, re-serialized plan) and report (status locked, plus the plate id).

The inputs and what they feed

Two required inputs: plan (STRING - the manifest JSON, or a path to it) and plate (an ATLAS_REAL_PLATE). The plate input was appended after the original widget so saved workflows keep working.

The locked_plan_json output is what AtlasRecordPlateAttempt consumes: the record node re-validates the binding itself and then enforces the plan's model policy against the attempt you submit. So the flow is AtlasOpenRealPlate → AtlasReadLockedPlatePlan → AtlasRecordPlateAttempt, with this node as the checkpoint in between.

Installing

Pack install - Manager search "atlas-camera", or:

cd <ComfyUI>/custom_nodes
git clone https://github.com/mikejamesvfx/atlas-camera.git

Restart. And the standing caveat for the whole evidence lane: the plan schema lives in the private atlas-world distribution, separate from the public pack. Without it the node registers but raises a clear install-hint error at runtime (pip install -e path/to/atlas-world). If you don't have plans to lock, you don't need this node yet.

Where people get burned

• "plan must be in lock phase" - you fed an unlocked/draft plan. It's not a contract until it's locked.
• "locked plan is bound to a different plate" / "source content address does not match" - the plan was locked against a different photograph or the plate changed under it. That's the check working; don't work around it.
• "locked plan artifact ledger does not match plate" - the ledger drifted after the plan was locked (e.g. a new artifact was recorded). The plan and the plate disagree about what exists.

One honest note: this is a provenance-and-audit node, not a creative one. It exists for pipelines where who processed what, with which model, under which approval is a deliverable in its own right. If that's not your workflow, you'll likely never miss it - but when it is, a plan that can't be verified is worse than no plan at all.