konradre/video-production-skills / skills/video-refs-continuity
video-refs-continuity
VerifiedContinuity through consistency for generated video: builds the DERIVED reference set and start image every shot needs, keeps the continuity ledger between shots, and runs the refs gate in code before any generation call. Use when a shot must match the shot before it (room, cast, seats, wardrobe, held props, door swing, a named state), when a character, product or room reference is built or cut from a keeper, when a plate or start image is generated, or when seeds keep drifting between shots. Triggers — "continuity", "refs gate", "reference set", "start image", "continuity ledger", "backfill from accepted", "the door is on the wrong wall", "not the same guy", "the same shape in all videos". Not for the cost line, the GO and the submit itself — use video-gen-cost-gate. Not for the prompt's wording — use video-prompt-dialects. Not for upscale, film look, grain or the delivery encode — use video-finish.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 31.6 KB |
| references/ASSET-HYGIENE.md | markdown | 6.1 KB |
| references/CONTINUITY-AXES.md | markdown | 6.3 KB |
| references/REFERENCE-CONTRACT.md | markdown | 19.0 KB |
| references/REPAIR-LADDER.md | markdown | 6.0 KB |
| references/SCENE-PROXY.md | markdown | 24.5 KB |
| references/ZOOM-OUT-CHAIN.md | markdown | 4.1 KB |
| references/refs-required.example.json | config | 3.1 KB |
| scripts/air_pieces.pyexecutable | script | 3.9 KB |
| scripts/cast_stress.pyexecutable | script | 17.8 KB |
| scripts/comfy_preflight.py | script | 22.3 KB |
| scripts/comfy_ready.pyexecutable | script | 2.7 KB |
| scripts/comfy_up.shexecutable | script | 2.6 KB |
| scripts/knit_letters.pyexecutable | script | 7.3 KB |
| scripts/plate_pieces.pyexecutable | script | 4.9 KB |
| scripts/ref_dag.pyexecutable | script | 5.2 KB |
| scripts/refs_gate.pyexecutable | script | 41.1 KB |
| scripts/scene_blockout.py | script | 6.4 KB |
| scripts/scene_proxy.py | script | 16.6 KB |
| scripts/split_sheet.pyexecutable | script | 1.4 KB |
| scripts/sprinkle_pieces.pyexecutable | script | 2.8 KB |
scripts/comfy_preflight.py
View on GitHub#!/usr/bin/env python3
"""comfy_preflight.py — will this ComfyUI graph SAVE what the job is for? Checked before it is queued, fail closed.
ComfyUI accepts a graph whose only output is a preview (it writes to temp/, gone at the next restart) or a
VHS_VideoCombine with save_output false, runs it to the end, and reports success. This refuses both, and a graph with
no output of the kind the job needs (a video job that only saves stills), before any GPU time is spent.
structure API format (a UI export with "nodes"/"links" is refused: File > Export (API)); every node has a
class_type and inputs; no link to a node id the graph does not have
outputs at least one PERSISTENT output node: not a preview/display class, not save_output false, fed by at
least one link; of the --expect kind (with no --expect, a MiniMax H3 sampler in the graph means video)
schema with --host (live /object_info, COMFY_HOST by default) or --object-info <snapshot.json>: every class
exists on that server, every required input is set, a combo value outside its list is a WARN; the
server's own output_node flag decides what counts as an output
models every value that names a model file (.safetensors .ckpt .pt .pth .bin .gguf .sft .onnx) must exist on the
server: a loader's combo list decides it, else (with --host) the server's `GET /models/<folder>` listings;
a missing file FAILS here instead of an hour into a queue. Without either, the files are listed unchecked
packs the custom node pack behind each class, read from `/object_info`'s `python_module` — what a fresh server
must install for this graph
template a graph converted from an official template keeps the template's own shape: an editor-only node (Reroute,
Note, MarkdownNote, PrimitiveNode) left in the API graph FAILS; a dynamic input keeps its DOTTED keys
(`values.a` for an autogrow list, `resize_type.width` under a dynamic combo's selected option), so a
required dynamic input is met by its dotted keys and a flattened one (`width`) FAILS as missing
python3 scripts/comfy_preflight.py <graph.json> [--expect video|image|audio|any] [--host [URL] | --object-info FILE] [--json]
python3 scripts/comfy_preflight.py --selftest
Exit 0 PASS, 1 FAIL, 2 unusable (unreadable graph, schema asked for and unreachable). Sentinel PREFLIGHT PASS|FAIL.
A PASS says the graph will write a file. It does not say the file will look right: that is read off the frames.
Pattern: piorunkulaga174/dsh-comfyui scripts/comfyui_probe.py (preflight, output_kind), plus the save_output check;
the model-file and pack checks from MieMieeeee/comfyui-agent-skill scripts/comfyui/preflight.py; the template checks from
NousResearch/hermes-agent optional-skills/creative/comfyui/references/template-integrity.md (purzbeats, v5.1.0), confirmed
against ComfyUI's own comfy_api/latest/_io.py (dynamic inputs expand to `<parent>.<child>` ids).
"""
import argparse, json, os, sys, threading, urllib.error, urllib.parse, urllib.request
PREVIEW = ('preview', 'showtext', 'display', 'show_text')
SAVE = ('save', 'export', 'combine')
H3 = {'MiniMaxH3ImageToVideo', 'MiniMaxH3ReferenceToVideo'}
MODEL_EXT = ('.safetensors', '.ckpt', '.pt', '.pth', '.bin', '.gguf', '.sft', '.onnx')
EDITOR_ONLY = {'Reroute', 'Note', 'MarkdownNote', 'PrimitiveNode'} # frontend nodes: the server has no class for them
AUTOGROW, DYNCOMBO = 'COMFY_AUTOGROW_V3', 'COMFY_DYNAMICCOMBO_V3'
def present(k, inp):
"""A required input is set by its own key or, for a dynamic input, by its dotted children (`values.a`)."""
return k in inp or any(x.startswith(k + '.') for x in inp)
def norm(v):
return v.replace('\\', '/').strip('/')
def kind_of(cls):
low = cls.lower()
if 'video' in low or cls == 'VHS_VideoCombine': return 'video'
if 'audio' in low: return 'audio'
if any(h in low for h in ('image', 'webp', 'gif', 'png', 'jpg')): return 'image'
return 'any'
def is_link(v, ids):
return isinstance(v, list) and len(v) == 2 and isinstance(v[0], (str, int)) and isinstance(v[1], int)
def preflight(graph, expect='any', schema=None, models=None):
errors, warnings, outputs = [], [], []
packs, unchecked = {}, []
if not isinstance(graph, dict) or ('nodes' in graph and 'links' in graph):
return {'ok': False, 'errors': [('', 'ui-format', 'a UI export, not the API format: File > Export (API)')], 'warnings': [], 'outputs': [], 'expect': expect, 'packs': {}, 'unchecked': []}
ids = {str(k) for k in graph}
has_h3 = False
for nid, node in graph.items():
if not isinstance(node, dict) or not isinstance(node.get('class_type'), str) or not isinstance(node.get('inputs'), dict):
errors.append((nid, 'bad-node', 'needs class_type and an inputs object')); continue
cls, inp = node['class_type'], node['inputs']; has_h3 |= cls in H3
if cls in EDITOR_ONLY:
errors.append((nid, 'editor-only', f'{cls} is an editor-only node the server has no class for: point each input that '
f'reads it at its source [node id, output slot] (a Reroute), or drop it (a note)')); continue
for k, v in inp.items():
if is_link(v, ids) and str(v[0]) not in ids: errors.append((nid, 'dangling-link', f'{k} → node {v[0]}, which the graph does not have'))
sch = schema.get(cls) if schema is not None else None
if schema is not None and not isinstance(sch, dict):
errors.append((nid, 'unknown-class', f'{cls} is not on this server')); continue
combo_keys = set()
if sch:
pm = sch.get('python_module') or ''
if pm.startswith('custom_nodes.'): packs.setdefault(pm.split('.')[1], set()).add(cls)
spec_in = sch.get('input', {}) or {}
for k, spec in (spec_in.get('required') or {}).items():
dyn = spec[0] if isinstance(spec, list) and spec and isinstance(spec[0], str) else None
if dyn == DYNCOMBO:
errors += dyncombo(nid, cls, k, spec, inp, warnings)
elif not present(k, inp):
errors.append((nid, 'missing-input', f'{cls}.{k} is required' + (f' (an autogrow list: keys {k}.<name>)' if dyn == AUTOGROW else '')))
for k, spec in list((spec_in.get('required') or {}).items()) + list((spec_in.get('optional') or {}).items()):
if k not in inp or not (isinstance(spec, list) and spec and isinstance(spec[0], list)): continue
combo_keys.add(k)
if isinstance(inp[k], str) and inp[k] not in spec[0]:
if inp[k].lower().endswith(MODEL_EXT): errors.append((nid, 'missing-model', f'{cls}.{k}={inp[k]!r} is not among the {len(spec[0])} files this server lists for it'))
else: warnings.append((nid, 'combo-value', f'{cls}.{k}={inp[k]!r} is not in the server list'))
for k, v in inp.items():
if k in combo_keys or not isinstance(v, str) or not v.lower().endswith(MODEL_EXT): continue
if models is None: unchecked.append((nid, f'{cls}.{k}', v)); continue
if norm(v) not in models and os.path.basename(norm(v)) not in {os.path.basename(m) for m in models}:
errors.append((nid, 'missing-model', f'{cls}.{k}={v!r} is in none of the server\'s /models folders'))
low = cls.lower()
if any(h in low for h in PREVIEW): continue
flagged = sch.get('output_node') is True if sch else any(h in low for h in SAVE)
if not flagged: continue
if inp.get('save_output') is False:
warnings.append((nid, 'not-persistent', f'{cls} has save_output false: it writes to temp/, not output/')); continue
if not any(is_link(v, ids) for v in inp.values()):
errors.append((nid, 'unfed-output', f'{cls} has no input link: it saves nothing')); continue
outputs.append((nid, cls, kind_of(cls)))
need = expect if expect != 'any' else ('video' if has_h3 else 'any') # an explicit --expect wins; an H3 sampler sets the default
if not outputs: errors.append(('', 'no-persistent-output', 'no save/export node that writes to output/ — the job would finish and leave nothing'))
elif need != 'any' and not any(k == need for _, _, k in outputs):
errors.append(('', 'wrong-output-kind', f'the job needs a {need} output; the graph saves only {sorted({k for _, _, k in outputs})}'))
return {'ok': not errors, 'errors': errors, 'warnings': warnings, 'outputs': outputs, 'expect': need,
'packs': {k: sorted(v) for k, v in packs.items()}, 'unchecked': unchecked}
def dyncombo(nid, cls, k, spec, inp, warnings):
"""A dynamic combo: the parent key names the option, and that option's own inputs ride as `<k>.<input>`."""
if k not in inp:
return [(nid, 'missing-input', f'{cls}.{k} is required (a dynamic combo: its value selects the option whose inputs ride as {k}.<input>)')]
opts = (spec[1] or {}).get('options') if len(spec) > 1 and isinstance(spec[1], dict) else None
if not isinstance(opts, list):
return []
sel = next((o for o in opts if isinstance(o, dict) and o.get('key') == inp[k]), None)
if sel is None:
warnings.append((nid, 'combo-value', f'{cls}.{k}={inp[k]!r} is not one of its options {[o.get("key") for o in opts if isinstance(o, dict)]}'))
return []
out = []
for sub in ((sel.get('inputs') or {}).get('required') or {}):
if not present(f'{k}.{sub}', inp):
flat = ' — the key is flattened: keep the dotted form the template writes' if sub in inp else ''
out.append((nid, 'missing-input', f'{cls}.{k}.{sub} is required by option {inp[k]!r}{flat}'))
return out
def fetch_schema(host):
with urllib.request.urlopen(host.rstrip('/') + '/object_info', timeout=30) as r:
return json.load(r)
def fetch_models(host):
"""Every file the server lists under /models/<folder>, as '<folder>/<file>' plus the bare '<file>'; None when the
server has no /models listing (an older ComfyUI) — the model check then falls back to the combo lists alone."""
base = host.rstrip('/')
try:
with urllib.request.urlopen(base + '/models', timeout=15) as r: folders = json.load(r)
except (OSError, ValueError, urllib.error.URLError): return None
out = set()
for f in folders if isinstance(folders, list) else []:
try:
with urllib.request.urlopen(f'{base}/models/{urllib.parse.quote(str(f))}', timeout=15) as r: files = json.load(r)
except (OSError, ValueError, urllib.error.URLError): continue
for x in files if isinstance(files, list) else []:
out.add(norm(str(x))); out.add(f'{f}/{norm(str(x))}')
return out
def report(path, res):
outs = ', '.join(f'node {n} {c} ({k})' for n, c, k in res['outputs']) or 'none'
print(f'{path}: expects {res["expect"]} · persistent outputs: {outs}')
for n, code, msg in res['errors']: print(f' FAIL {code}{" node " + str(n) if n else ""}: {msg}')
for n, code, msg in res['warnings']: print(f' WARN {code} node {n}: {msg}')
for pack, classes in sorted(res.get('packs', {}).items()): print(f' pack {pack}: {", ".join(classes)}')
if res.get('unchecked'): print(f" {len(res['unchecked'])} model file(s) not checked (no combo list, no /models listing): " + ', '.join(v for _, _, v in res['unchecked'][:6]))
print(f"PREFLIGHT {'PASS' if res['ok'] else 'FAIL'} — {'the graph will write a file; whether it looks right is read off the frames' if res['ok'] else 'nothing queued'}")
def selftest():
S = {'LoadImage': {'input': {'required': {'image': [['a.png', 'b.png']]}}, 'output_node': False},
'KSampler': {'input': {'required': {'seed': ['INT'], 'sampler_name': [['euler', 'dpmpp_2m']], 'model': ['MODEL']}}, 'output_node': False},
'VAEDecode': {'input': {'required': {'samples': ['LATENT']}}, 'output_node': False},
'SaveImage': {'input': {'required': {'images': ['IMAGE'], 'filename_prefix': ['STRING']}}, 'output_node': True},
'PreviewImage': {'input': {'required': {'images': ['IMAGE']}}, 'output_node': True},
'VHS_VideoCombine': {'input': {'required': {'images': ['IMAGE'], 'save_output': ['BOOLEAN']}}, 'output_node': True}}
base = lambda: {'1': {'class_type': 'LoadImage', 'inputs': {'image': 'a.png'}}, '2': {'class_type': 'KSampler', 'inputs': {'seed': 1, 'sampler_name': 'euler', 'model': ['1', 0]}},
'3': {'class_type': 'VAEDecode', 'inputs': {'samples': ['2', 0]}}}
def g(**extra):
x = base(); x.update(extra); return x
save = {'9': {'class_type': 'SaveImage', 'inputs': {'images': ['3', 0], 'filename_prefix': 'x'}}}
cases = [
('a SaveImage graph, image job', g(**save), 'image', S, True, None),
('the same with no schema (class-name rules)', g(**save), 'image', None, True, None),
('only a PreviewImage → FAIL no-persistent-output', g(**{'9': {'class_type': 'PreviewImage', 'inputs': {'images': ['3', 0]}}}), 'any', S, False, 'no-persistent-output'),
('VHS_VideoCombine save_output false → FAIL', g(**{'9': {'class_type': 'VHS_VideoCombine', 'inputs': {'images': ['3', 0], 'save_output': False}}}), 'video', S, False, 'no-persistent-output'),
('VHS_VideoCombine save_output true, video job → PASS', g(**{'9': {'class_type': 'VHS_VideoCombine', 'inputs': {'images': ['3', 0], 'save_output': True}}}), 'video', S, True, None),
('a video job that only saves stills → FAIL wrong-output-kind', g(**save), 'video', S, False, 'wrong-output-kind'),
('an H3 sampler forces video → FAIL on a stills-only graph', g(**save, **{'5': {'class_type': 'MiniMaxH3ReferenceToVideo', 'inputs': {}}}), 'any', None, False, 'wrong-output-kind'),
('an explicit --expect image wins over the H3 default → PASS on the stills graph', g(**save, **{'5': {'class_type': 'MiniMaxH3ReferenceToVideo', 'inputs': {}}}), 'image', None, True, None),
('a link to a missing node → FAIL dangling-link', g(**{'9': {'class_type': 'SaveImage', 'inputs': {'images': ['7', 0], 'filename_prefix': 'x'}}}), 'image', S, False, 'dangling-link'),
('a class the server lacks → FAIL unknown-class', g(**save, **{'4': {'class_type': 'SaveImageExtended', 'inputs': {}}}), 'image', S, False, 'unknown-class'),
('a required input missing → FAIL missing-input', g(**{'9': {'class_type': 'SaveImage', 'inputs': {'images': ['3', 0]}}}), 'image', S, False, 'missing-input'),
('a save node with no input link → FAIL unfed-output', g(**{'9': {'class_type': 'SaveImage', 'inputs': {'images': 'x', 'filename_prefix': 'x'}}}), 'image', None, False, 'unfed-output'),
('a UI export → FAIL ui-format', {'nodes': [], 'links': []}, 'any', None, False, 'ui-format'),
('a Reroute left in an API graph → FAIL editor-only', g(**save, **{'6': {'class_type': 'Reroute', 'inputs': {'': ['3', 0]}}}), 'image', None, False, 'editor-only'),
]
ok = True
for label, graph, exp, sch, want, code in cases:
r = preflight(graph, exp, sch); got = [c for _, c, _ in r['errors']]
good = r['ok'] == want and (code is None or code in got); ok &= good
print(f" {'ok ' if good else 'BAD'} {label} (errors {got})")
w = preflight(g(**save, **{'2': {'class_type': 'KSampler', 'inputs': {'seed': 1, 'sampler_name': 'eulerx', 'model': ['1', 0]}}}), 'image', S)
good = w['ok'] and any(c == 'combo-value' for _, c, _ in w['warnings']); ok &= good
print(f" {'ok ' if good else 'BAD'} a combo value outside the server list → WARN, still PASS")
# the second pass: model files and packs
S2 = dict(S); S2['CheckpointLoaderSimple'] = {'input': {'required': {'ckpt_name': [['sd15.safetensors', 'sub/xl.safetensors']]}}, 'output_node': False}
S2['CustomLoader'] = {'input': {'required': {'model_name': ['STRING']}}, 'output_node': False, 'python_module': 'custom_nodes.ComfyUI-Custom'}
S2['VHS_VideoCombine'] = dict(S['VHS_VideoCombine'], python_module='custom_nodes.ComfyUI-VideoHelperSuite')
ck = lambda n: {'4': {'class_type': 'CheckpointLoaderSimple', 'inputs': {'ckpt_name': n}}}
cl = lambda n: {'5': {'class_type': 'CustomLoader', 'inputs': {'model_name': n}}}
def case(label, r, want, code=None):
nonlocal ok
got = [c for _, c, _ in r['errors']]; good = r['ok'] == want and (code is None or code in got); ok &= good
print(f" {'ok ' if good else 'BAD'} {label} (errors {got})")
case('a checkpoint missing from the loader\'s combo list → FAIL missing-model', preflight(g(**save, **ck('missing.safetensors')), 'image', S2), False, 'missing-model')
case('a checkpoint in the list (a subfolder path) → PASS', preflight(g(**save, **ck('sub/xl.safetensors')), 'image', S2), True)
r = preflight(g(**save, **cl('wan/x.safetensors')), 'image', S2)
case('a STRING model input, no /models listing → PASS, listed unchecked', r, True); ok &= len(r['unchecked']) == 1
case('… with a listing that holds it → PASS', preflight(g(**save, **cl('wan/x.safetensors')), 'image', S2, {'diffusion_models/wan/x.safetensors', 'wan/x.safetensors'}), True)
case('… with a listing that lacks it → FAIL missing-model', preflight(g(**save, **cl('wan/x.safetensors')), 'image', S2, {'other.safetensors'}), False, 'missing-model')
# the template checks: dynamic inputs keep their dotted keys (ComfyUI comfy_api/latest/_io.py finalize_prefix)
S3 = dict(S)
S3['ComfyMathExpression'] = {'input': {'required': {'expression': ['STRING'], 'values': [AUTOGROW, {'template': {}, 'min': 1}]}}, 'output_node': False}
S3['ResizeImageMaskNode'] = {'input': {'required': {'input': ['IMAGE'], 'resize_type': [DYNCOMBO, {'options': [
{'key': 'scale dimensions', 'inputs': {'required': {'width': ['INT'], 'height': ['INT'], 'crop': [['center', 'disabled']]}}},
{'key': 'scale by', 'inputs': {'required': {'multiplier': ['FLOAT']}}}]}]}}, 'output_node': False}
mx = lambda inputs: {'7': {'class_type': 'ComfyMathExpression', 'inputs': inputs}}
rz = lambda inputs: {'8': {'class_type': 'ResizeImageMaskNode', 'inputs': dict({'input': ['3', 0]}, **inputs)}}
case('an autogrow list set by its dotted keys (values.a) → PASS', preflight(g(**save, **mx({'expression': 'a/2', 'values.a': ['2', 0]})), 'image', S3), True)
case('an autogrow list with no entry at all → FAIL missing-input', preflight(g(**save, **mx({'expression': 'a/2'})), 'image', S3), False, 'missing-input')
case('a dynamic combo with its option and the dotted option inputs → PASS', preflight(g(**save, **rz({'resize_type': 'scale dimensions', 'resize_type.width': 1920, 'resize_type.height': 1088, 'resize_type.crop': 'center'})), 'image', S3), True)
r = preflight(g(**save, **rz({'resize_type': 'scale dimensions', 'width': 1920, 'height': 1088, 'crop': 'center'})), 'image', S3)
case('the same option with its keys flattened (width) → FAIL missing-input', r, False, 'missing-input'); ok &= any('flattened' in m for _, _, m in r['errors'])
w = preflight(g(**save, **rz({'resize_type': 'scale to fit', 'resize_type.width': 1})), 'image', S3)
good = w['ok'] and any(c == 'combo-value' for _, c, _ in w['warnings']); ok &= good
print(f" {'ok ' if good else 'BAD'} a dynamic combo value outside its options → WARN, still PASS")
pk = preflight(g(**{'9': {'class_type': 'VHS_VideoCombine', 'inputs': {'images': ['3', 0], 'save_output': True}}}), 'video', S2)['packs']
good = pk == {'ComfyUI-VideoHelperSuite': ['VHS_VideoCombine']}; ok &= good
print(f" {'ok ' if good else 'BAD'} the custom node pack is read from python_module: {pk}")
# over HTTP, against a local stand-in for the server
import http.server
routes = {'/object_info': S2, '/models': ['checkpoints', 'diffusion_models'], '/models/checkpoints': ['sd15.safetensors'], '/models/diffusion_models': ['wan/x.safetensors']}
class H(http.server.BaseHTTPRequestHandler):
def do_GET(self):
body = routes.get(self.path)
if body is None: self.send_response(404); self.end_headers(); return
b = json.dumps(body).encode(); self.send_response(200); self.send_header('Content-Type', 'application/json'); self.end_headers(); self.wfile.write(b)
def log_message(self, *a): pass
srv = http.server.ThreadingHTTPServer(('127.0.0.1', 0), H); threading.Thread(target=srv.serve_forever, daemon=True).start()
url = f'http://127.0.0.1:{srv.server_address[1]}'
try:
sch, mods = fetch_schema(url), fetch_models(url)
case('over HTTP: /object_info + /models/<folder> hold the file → PASS', preflight(g(**save, **cl('wan/x.safetensors')), 'image', sch, mods), True)
case('over HTTP: a file no folder lists → FAIL missing-model', preflight(g(**save, **cl('wan/y.safetensors')), 'image', sch, mods), False, 'missing-model')
routes.pop('/models'); none = fetch_models(url); good = none is None; ok &= good
print(f" {'ok ' if good else 'BAD'} a server with no /models listing → None (the combo lists decide alone)")
finally:
srv.shutdown()
print(f"SELFTEST {'PASS' if ok else 'FAIL'}"); return 0 if ok else 1
def main():
if '--selftest' in sys.argv: sys.exit(selftest())
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument('graph'); ap.add_argument('--expect', choices=['video', 'image', 'audio', 'any'], default='any')
ap.add_argument('--host', nargs='?', const=os.environ.get('COMFY_HOST', 'http://127.0.0.1:8188'), help='read the live /object_info (COMFY_HOST when no URL is given)')
ap.add_argument('--object-info', help='a saved /object_info snapshot instead of a live server'); ap.add_argument('--json', action='store_true')
a = ap.parse_args()
try: graph = json.load(open(a.graph))
except (OSError, ValueError) as e: print(f'unreadable graph {a.graph}: {e}'); sys.exit(2)
schema = None
try:
if a.object_info: schema = json.load(open(a.object_info))
elif a.host: schema = fetch_schema(a.host)
except (OSError, ValueError, urllib.error.URLError) as e: print(f'schema unreachable ({a.object_info or a.host}): {e} — nothing checked against the server'); sys.exit(2)
models = fetch_models(a.host) if a.host and not a.object_info else None
res = preflight(graph, a.expect, schema, models)
if a.json: print(json.dumps(res, indent=2)); sys.exit(0 if res['ok'] else 1)
report(a.graph, res); sys.exit(0 if res['ok'] else 1)
if __name__ == '__main__':
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Unverified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |