Hmm, in addition to the general points I generated below, there are a few important assumptions missing:

• ComfyUI is the most advanced tool available, aside from those designed for programmers, and unless you started using it with the specific intention of doing everything manually from the very beginning, it’s extremely difficult beyond the basics. While end-to-end tutorials and instructional videos generally exist for the basic workflow, making it possible even for beginners, the actual work involved is highly advanced
• On top of that, video generation is one of the most difficult tasks in generative AI and one of the tasks that requires the most VRAM.
• For the reasons above, “there are almost never cases where the answer or workflow has already been explained.” This is a tool for people who want to create through trial and error. You’ll need to search GitHub for hints from fragmented information, ask generative AI for help, keep trying until it works, and in the worst case, build custom nodes or code yourself… It sounds simple, but it’s difficult without the necessary knowledge and experience
• In generative AI, tasks like fixing output tend to consume more VRAM than the initial generation. This is because more data is loaded during processing → Therefore, if you can regenerate the output instead of fixing it, that’s the more cost-effective approach.
• Achieving the same results with more limited resources (like VRAM) requires more advanced knowledge and skills. This isn’t limited to PCs, by the way…
• But 8GB of VRAM… even 24GB isn’t particularly powerful for video generation. Data center GPUs are in the 80GB range, after all…

For these reasons, I think you’ll probably need to become an advanced user first if you want to do everything perfectly… Or, look for an easier path, or don’t try to accomplish everything at once…

One reason you can’t find a satisfactory answer even after searching is that, under current conditions, it’s actually quite difficult…

---

You are not missing something obvious — you are trying to do a different job than most inpainting tutorials show

What most beginner tutorials teach is:

• load one image
• mask an area
• use a prompt to replace that area
• get a new image

That is generic inpainting.

What you want is different:

• you already have a broken frame from a video
• you know who the face is supposed to be
• you want to repair only the face
• then use that repaired frame as the starting point for the next shot

That is a real and common workflow. It is closer to identity repair or reference-guided face repair than to ordinary “mask + prompt” inpainting.

---

The short answer

Yes — there are real workflows for this.

For your case, the practical choices are:

1. Repair the bad frame Best when the shot is already good and only the face drifted.

2. Recreate the shot Best when pose, staging, camera, or multiple frames are wrong.

3. Use the repaired frame as the next shot’s input This is the key continuity trick.

For your hardware and current stage, I would not jump to training a custom LoRA yet. I would first make this simpler loop work:

1. generate a short shot
2. inspect the last frame
3. repair that frame if only the face is wrong
4. use that repaired frame to start the next short shot

That is the most realistic and least frustrating route on an 8 GB machine.

---

The core distinction: repair vs recreate

This is the biggest practical decision.

Repair

Repair when the frame is already mostly correct and only a local area is wrong.

Typical examples:

• the face became the wrong person
• the face is melted or soft, but the pose is still right
• the lighting, clothes, bench, and composition are all correct
• the frame would be usable if the face were fixed

In other words:

the shot is good, the face is bad

That is a repair case.

Recreate

Recreate when the problem is global , not local.

Typical examples:

• both people drifted too far
• the body pose is wrong
• the bench relationship is wrong
• the camera angle drifted
• the motion between two states is wrong
• several frames in a row are unusable
• fixing the face would still leave the shot bad

In other words:

the shot itself is bad

That is a recreate case.

The practical rule

A good production rule is:

• if the frame is about 80–90% right , repair
• if the shot is structurally wrong, recreate

That one rule will save you a lot of time.

---

What “repair that frame” actually means

It does not mean “run a magical video repair model over the whole movie.”

It usually means this:

1. export or grab the bad last frame
2. load it as a still image
3. mask only the face
4. repair the face using one of the methods below
5. save the result as a new repaired frame
6. feed that repaired frame into the next shot

So yes — it is often a still-image repair inside a video workflow.

That is normal.

---

The three repair methods that matter

1) Plain masked inpainting

Use this when the face is only slightly wrong.

Good for:

• soft face drift
• mild face deformation
• one eye or mouth going wrong
• keeping everything else in the frame unchanged

You can learn the base mechanic from the official ComfyUI inpaint tutorial:

• ComfyUI Inpainting Workflow

That tutorial covers:

• the Mask Editor
• masking only the area you want to change
• the VAE Encoder (for Inpainting)
• rebuilding just the masked region

This is the simplest route and the best one to learn first.

2) Face swap / identity replacement

Use this when the face became the wrong person.

Good for:

• “the shot is fine, but the character is now someone else”
• bridge-frame correction
• repeating the same identity across many frames

The most direct tool for this in ComfyUI is:

• ComfyUI-ReActor

ReActor is specifically a face-swap extension for ComfyUI and supports reusable face models, which makes it very attractive for recurring characters.

3) Reference-guided face repair

Use this when you want another image to actively guide the face repair.

Good for:

• “make this broken face look like this person”
• stronger identity control than a prompt alone
• cases where plain inpaint is too vague

The most relevant OSS tool here is:

• ComfyUI IPAdapter Plus

IPAdapter Plus is important because it supports FaceID-style identity guidance. The repo notes that most FaceID models require the matching LoRA, and that regional use is most effective inside an inpaint-style workflow.

---

The actual OSS options I would care about for your case

A. Official ComfyUI inpaint workflow

Best first step because it teaches the basic mask-and-repair loop.

• ComfyUI Inpainting Workflow

Why I care:

• it is official
• it is simple
• it teaches the exact mechanics you need for single-frame repair

B. Official Wan 2.2 5B workflow

This is the video-generation backbone I would use on 8 GB.

• Wan2.2 Video Generation ComfyUI Official Native Workflow Example

Why I care:

• official template path
• documented model placement
• explicitly aimed at the 5B low-VRAM workflow

C. Official Wan FLF workflow

This is the best tool for your sit-down transition.

• ComfyUI Wan FLF workflow

Why I care:

• first/last-frame control is exactly the right abstraction for:
  • standing near bench
  • seated on bench
  • controlled transition between the two

D. ReActor

Most direct route for “wrong face in one frame.”

• ComfyUI-ReActor repo

Why I care:

• fast face swap
• reusable face models
• very good for bridge-frame identity repair

E. Impact Pack

Best fallback if ReActor keeps wasting time.

• ComfyUI Impact Pack

Why I care:

• MaskPainter
• FaceDetailer
• MaskDetailer
• designed for local detection/detail/inpaint workflows

The repo explicitly describes:

• MaskPainter as a mask-drawing feature
• FaceDetailer as a face detector/improver
• MaskDetailer as a simple inpaint node that applies the detailer to the masked area

That is extremely close to your actual need.

F. IPAdapter Plus

Best when you want reference-guided identity repair.

• ComfyUI IPAdapter Plus

Why I care:

• strongest “use this face as the guide” option
• but more setup-heavy than plain inpaint

G. VACE

Important later, but not my first recommendation for your machine.

• Wan VACE To Video node docs

Why it matters:

• this is the heavier path for real video-region editing / masked V2V
• it is useful to know it exists
• but I would not start here on 8 GB

H. Musubi-tuner

Later, not now.

• musubi-tuner

Why it matters:

• useful reality check for training
• the repo recommends roughly:
  • 12 GB+ for image training
  • 24 GB+ for video training

That is why I would not make “train my own LoRA” your next move.

---

My actual recommendation for your case, as a whole

If this were my setup, I would do it in this order:

Phase 1 — Stabilize ComfyUI

Goal: get one repair path working, not ten.

1. Stop expanding the setup

For now, stop downloading more:

• checkpoints
• LoRAs
• random custom nodes
• giant workflow packs

Keep only a small active set.

2. Fix custom node installation properly

The official docs say every custom node install has two steps :

1. put the node repo into ComfyUI/custom_nodes
2. install that node’s Python dependencies in the same ComfyUI environment

Official docs:

• Install custom nodes in ComfyUI
• ComfyUI-Manager install
• Custom-node troubleshooting

If a node repo is sitting in something like custom_model, that is the wrong place. Node repos go in custom_nodes.

3. Read the startup logs every single time

Do not trust “installed successfully” messages alone.

Trust:

• startup console
• import failed
• missing dependency messages
• missing node report

The troubleshooting docs explicitly say to inspect logs and error reports.

4. Try ReActor once, cleanly

If you want ReActor, follow the repo literally:

• put it in ComfyUI/custom_nodes/ComfyUI-ReActor
• run its install step
• download required models
• restart ComfyUI
• check the logs
• confirm the nodes actually appear

If it still fails after one clean pass, stop fighting it and move to Impact Pack.

That is not “giving up.” That is good production discipline.

---

Phase 2 — Prove a minimal workflow works

Goal: one small workflow that is reliable.

5. Use the official Wan 2.2 5B template

Do not start from a huge community graph.

Start from:

• Wan2.2 Video Generation ComfyUI Official Native Workflow Example

Why:

• official
• documented
• suitable for your VRAM tier
• much easier to debug

6. Stop thinking “2-minute video”

Think in shots :

1. walk
2. approach bench
3. sit
4. seated

That is the correct structure for your project.

7. Create three still anchors first

Before any more video, create:

• Anchor A — both characters walking
• Anchor B — both characters near the bench
• Anchor C — both characters seated

If those three are not right, the video will not stay right.

These anchors are your cast lock.

---

Phase 3 — Use repair and recreate correctly

Goal: keep continuity without overcomplicating the workflow.

Shot 1 — Walk

Generate a short walking clip from Anchor A.

After rendering:

• if only the face drifted near the end → repair the last frame
• if body motion / spacing / camera drifted → recreate the shot

Shot 2 — Approach bench

Use the repaired last frame from Shot 1 as the next shot’s starting image.

Again:

• local face problem → repair
• global shot problem → recreate

Shot 3 — Sit down

This is where I would usually recreate , not repair.

Use:

• first frame = correct standing-near-bench frame
• last frame = Anchor C
• workflow = FLF

That is what Wan FLF is for.

Shot 4 — Seated

Generate from the seated anchor and keep motion subtle.

This is the safest place to get extra screen time.

---

How I would decide: repair vs recreate

Use this table mentally:

Situation	What I would do
Face is wrong, everything else is good	Repair
Face is slightly deformed, everything else is good	Repair
Face is wrong and you have a reference image	Repair with identity guidance
Body pose is wrong	Recreate
Bench/camera/staging drifted	Recreate
Multiple frames in a row are bad	Recreate
Sit-down motion is wrong	Recreate with FLF

That is the real production logic.

---

The actual repair routes I would use

Route 1 — Plain face-region inpaint

Use when the face is only moderately wrong.

Workflow

1. load broken frame
2. draw a tight mask over the face
3. run inpaint
4. save repaired frame

Learn from

• ComfyUI Inpainting Workflow

Best when

• the identity is close
• the face just needs correction
• you want the simplest path

Route 2 — ReActor face swap

Use when the face became the wrong character.

Workflow

1. load broken frame
2. load face reference / face model
3. run ReActor
4. save repaired frame

Source

• ComfyUI-ReActor

Best when

• the shot is fine
• the identity is wrong
• you want the fastest bridge-frame fix

Route 3 — Impact Pack + IPAdapter FaceID

Use when you want stronger reference guidance and local repair.

Workflow

1. load broken frame
2. mask the face with MaskPainter
3. use FaceDetailer / MaskDetailer
4. add IPAdapter FaceID guidance if needed
5. save repaired frame

Sources

• ComfyUI Impact Pack
• ComfyUI IPAdapter Plus

Best when

• ReActor is unavailable or unstable
• you want stronger reference control
• you want local repair, not a global rewrite

---

What I would not do right now

1. I would not train a LoRA

Not yet.

That may become useful later, but the current official/community guidance makes it a poor next step for your hardware and stage.

Use:

• repair
• anchors
• short shots
• FLF

first.

2. I would not jump to full video inpainting

True masked video editing exists, and VACE is the right place to look for that.

But for your current setup, it is the later tier, not the next tier.

3. I would not keep downloading assets “just in case”

That is how disk fills up and clarity disappears.

For now, your active set should be small:

• Wan 2.2 5B
• one repair route
• three anchor stills
• your active project files

---

The exact “if this were my setup” plan

Day 1 — setup sanity

• clean custom_nodes
• fix folder locations
• try one clean ReActor install
• read startup logs
• if it still fails, switch to Impact Pack

Day 2 — learn one-frame repair

• use the official inpaint tutorial
• take one bad frame
• repair one face
• save a corrected frame

If you cannot do one bad frame → one repaired frame , do not touch the full video workflow yet.

Day 3 — generate one walk shot

• use official Wan 2.2 5B template
• keep it short
• inspect the last frame

Day 4 — use the repaired frame as the handoff

• repair the last frame if needed
• feed it into the approach shot

Day 5 — build the sit-down shot with FLF

• good standing frame
• good seated frame
• FLF transition

Day 6 — generate the seated shot

• short and subtle
• repair only if needed

Day 7 — assemble in an editor

Use editing for pacing. Do not ask the model to generate every second of your screen time if editing can solve it more reliably.

---

The most important takeaway

The winning pattern for your project is:

short shot → inspect last frame → repair if the problem is local → recreate if the problem is global → use the repaired frame to start the next shot

That is the cleanest, safest, least frustrating version of the workflow.

---

The actual links I would open first

If you only open a few tabs, I would make them these:

1. Install custom nodes in ComfyUI
2. ComfyUI-Manager install
3. Custom-node troubleshooting
4. ComfyUI Inpainting Workflow
5. Wan2.2 Video Generation ComfyUI Official Native Workflow Example
6. ComfyUI Wan FLF workflow
7. ComfyUI-ReActor
8. ComfyUI Impact Pack
9. ComfyUI IPAdapter Plus
10. Wan VACE To Video node docs
11. musubi-tuner

---

Final recommendation

If I had to turn everything above into one practical recommendation, it would be this:

Right now

• keep the stack small
• fix installs properly
• use Wan 2.2 5B
• repair only bridge frames
• recreate bad transitions
• use FLF for the sit-down shot
• treat ReActor as useful but optional
• use Impact Pack if ReActor wastes time

Later

• stronger reference-guided repair
• true video-region editing
• training, if you still need it after the workflow is stable

That is the path I would trust most for your setup and your specific project.