Two weeks of videos in one sitting: a script library, your voice, and auto-posting

Hi Claude. Please be my patient setup helper again.

Last time we built my content engine in this folder: one idea in, one finished, scheduled video out. Now I want two weeks of videos at a time. A library of scripts built from my own work, in my voice, planned two weeks at a time, made as one batch and scheduled in one sitting. I don't know how to code, so treat me like a smart beginner.

THE GUIDE
We're following this guide:
https://receiptsgroup.com/guides/two-weeks-of-videos
Its "manual way" sections are the source of truth for every file and command. When you need a file, download the page with curl (ask me first) and copy that file exactly from its code box. Each box is labeled with its file name, like engine/plan.py. Don't rewrite the scripts. Only fill in my details where the guide shows <angle brackets>. If you can't reach the page, tell me before you build anything from memory. Part one's guide is https://receiptsgroup.com/guides/ai-content-engine if you need it.

HOW TO TALK TO ME
- Plain words and short sentences. If you need a tech word, explain it in five words or less.
- Ask ONE question at a time. Then stop and wait for my answer.
- Before each step, tell me in one sentence what it does and why.
- Before each command, tell me in plain words what it does, so I know what I'm saying yes to.
- If I'm stuck, slow down and try another way. Never make me feel dumb.

SAFETY RULES (never break these)
1. Never ask me to paste a password, API key or secret into this chat. If I paste one by accident, tell me to delete that key and make a new one. Never show what's inside .env.
2. Ask me first before anything that costs money or credits, and before anything that posts in public. Do the free dry run first, every time.
3. Three steps wait for me to type an answer: the avatar renders (python3 engine/batch.py avatar), watching the videos (python3 engine/batch.py watch) and the real schedule (python3 engine/schedule.py --send). Never run those yourself. Tell me the exact command, I run it in a second terminal window, and you help me read what it says. The edit and captions steps run for a long time, so I run those there too.
4. AI disclosure stays on. Every video and every caption says it was made with an AI avatar.
5. My avatar is only me. Extra looks are new looks of me, never anyone else.
6. Scripts come only from my material and my answers. No made-up stories, numbers, results, customers or quotes. Leave out customer names and private details, even if they're in my files.
7. A script goes into a batch only after I've said ok to it. A video gets scheduled only after I've watched it and said yes.
8. Stay in this folder. Ask before you install anything, and tell me what it is in plain words.

THE PLAN
Go one step at a time. After each step, run any free check and tell me in one line if it passed. Keep a short checklist in SETUP-NOTES.md of what's done (no keys in it). If we stop partway, read it first next time and pick up where we left off.

Step 1. Check part one.
Look for CLAUDE.md, rules/VOICE.md, rules/GUARDRAILS.md, prompts/01-script.md to 03-captions.md, and engine/check.py, avatar.py and post.py. Run python3 engine/check.py on one of my runs/ folders. If part one isn't here or doesn't work, stop and help me finish part one first.

Step 2. Add the new pieces. (Guide: "Set up the new pieces".)
Make the sources, library and plans folders. Add the new line to CLAUDE.md. Copy rules/SHAPE.md, prompts/04-topics.md to 08-voice-pass.md, and engine/plan.py, batch.py and schedule.py from the guide. Show me the list of what you added.

Step 3. Gather my material. (Guide: "Build your script library from your own work", steps 1 and 2.)
Ask me what I've got: notes, how-tos, checklists, emails where I explained something, old posts, talks. Help me copy them into sources/ as text files. Remind me to leave out anything with a customer's name or private details. Then follow prompts/04-topics.md and show me the topics by series. I cut the ones that aren't me and add any you missed.

Step 4. Interview me. (Guide: "Build your script library from your own work", step 3.)
Follow prompts/05-interview.md: 50 questions in five rounds of ten, one at a time. I can stop between rounds and pick it up another day.

Step 5. My voice. (Guide: "Make it sound like you".)
Show me rules/VOICE.md and help me write my note at the top: how I want to sound, in my words. Then follow prompts/06-scripts.md for the first 10 topics, and prompts/07-review.md to go through them with me, one at a time. Every line I fix goes into my voice guide as a before-and-after pair. Once there are at least five pairs, follow prompts/08-voice-pass.md so the rest of the drafts match.

Step 6. Fill the library.
Repeat: 06 for the next 10, then 07 with me, then 08 when I've fixed a few more lines. Keep going until I've said ok to at least 14 scripts from at least 3 series. Ask if I want to stop for today between rounds.

Step 7. My looks. (Guide: "Plan two weeks", step 1.)
Ask if I have more than one HeyGen look of me. If I do, help me find their ids with heygen avatar looks list and put them in looks.txt. If not, skip it. One look works fine.

Step 8. The plan. (Guide: "Plan two weeks", step 2.)
Ask me which day to start (a few days out, so there's time to make everything) and what time I want to post. Run engine/plan.py. Show me the two weeks and ask if it looks right.

Step 9. The batch. (Guide: "Make the batch".)
Run python3 engine/batch.py to show me where everything is. Then walk me through the steps in my second terminal window: avatar (it spends HeyGen credits, so remind me first), edit, captions. They take a while. Tell me I can walk away, and how to pick up if one stops.

Step 10. Watch. (Guide: "Make the batch", step 5.)
I run python3 engine/batch.py watch and watch every video with sound, start to finish. Help me fix any I say no to.

Step 11. Schedule. (Guide: "Schedule the whole batch".)
Run python3 engine/schedule.py (the dry run). Explain anything that isn't ready, in plain words. When every day says ready, show me one day's full dry run with --show. Then I run --send myself. The AI label stays on.

Step 12. Wrap up.
Give me a short cheat sheet for the next batch: the commands in order, and the three things I always do myself (say ok to every script, watch every video, say yes before anything is scheduled).

Ready? Say hi and ask me your first question.

content-engine/
├── CLAUDE.md               now also loads rules/SHAPE.md
├── rules/
│   ├── VOICE.md            how you talk, plus your before-and-after pairs
│   ├── GUARDRAILS.md       what never goes out (part one)
│   ├── SHAPE.md            the six beats every script follows (new)
│   └── banned.txt          (part one)
├── prompts/
│   ├── 01 to 03            part one: script, edit, captions
│   ├── 04-topics.md        your material -> topics (new)
│   ├── 05-interview.md     50 questions -> more topics (new)
│   ├── 06-scripts.md       topics -> draft scripts (new)
│   ├── 07-review.md        you review the drafts; fixes go in VOICE.md (new)
│   └── 08-voice-pass.md    rewrite the drafts to match VOICE.md (new)
├── engine/
│   ├── check.py, avatar.py, post.py      part one
│   ├── plan.py             two weeks from your approved scripts (new)
│   ├── batch.py            part one's steps for every day (new)
│   └── schedule.py         the whole batch to Upload-Post (new)
├── sources/                your material (new)
├── library/
│   ├── topics.md           every topic, by series
│   ├── interview.md        your answers, in your words
│   └── scripts.json        the library: draft, approved or cut
├── looks.txt               optional: your HeyGen look ids
├── plan.json               the batch you're working on
├── plans/                  finished batches
└── runs/
    └── 2026-10-19-P01/     one folder per day, same as part one

#!/usr/bin/env python3
"""Make every video in plan.json with part one's steps, one step at a time across the whole batch.

    python3 engine/batch.py              # where every day is (spends nothing)
    python3 engine/batch.py avatar       # render every missing avatar video (spends HeyGen credits; asks first)
    python3 engine/batch.py edit         # build and render every missing edit (Claude + HyperFrames; slow)
    python3 engine/batch.py captions     # write and check every missing set of captions
    python3 engine/batch.py watch        # play each finished video and ask you: post it or not?

Each step skips the days that already have what it makes, so you can stop any time and run it again.
A day with a look.txt (from engine/plan.py and your looks.txt) renders in that look.
"""
import json
import os
import shlex
import subprocess
import sys
from pathlib import Path

EDIT_TOOLS = "Read,Write,Edit,Skill,Bash(npx hyperframes *),Bash(ffprobe *),Bash(ffmpeg *)"
CAPTION_TOOLS = "Read,Write,Edit,Bash(python3 engine/check.py *)"


def ask(question):
    """Your typed answer, or None when nobody can type one (e.g. Claude running the step for you)."""
    try:
        return input(question).strip().lower()
    except EOFError:
        print("\nThis step needs your answer: run it yourself in a terminal window.")
        return None


def days():
    if not Path("plan.json").exists():
        sys.exit("no plan.json yet: run engine/plan.py first")
    return [Path(d["run"]) for d in json.loads(Path("plan.json").read_text())]


def run(cmd, env=None):
    print("  $ " + " ".join(shlex.quote("python3" if c == sys.executable else c) for c in cmd), flush=True)
    return subprocess.run(cmd, env=env).returncode == 0


def checks_ok(r):
    return subprocess.run([sys.executable, "engine/check.py", str(r)], capture_output=True).returncode == 0


def status():
    print(f"{'day':<26} {'check':<6} {'avatar':<7} {'edit':<5} {'captions':<9} you")
    for r in days():
        yes = lambda f: "yes" if (r / f).exists() else "-"
        ok = (r / "approved.txt").read_text().strip() if (r / "approved.txt").exists() else "-"
        print(f"{r.name:<26} {'PASS' if checks_ok(r) else 'FAIL':<6} {yes('avatar.mp4'):<7} {yes('final.mp4'):<5} "
              f"{yes('captions.json'):<9} {ok}")


def avatar():
    todo = [r for r in days() if not (r / "avatar.mp4").exists()]
    bad = [r.name for r in todo if not checks_ok(r)]
    if bad:
        sys.exit("fix these scripts first (python3 engine/check.py runs/<day>): " + ", ".join(bad))
    if not todo:
        return print("every day already has its avatar video")
    for r in todo:
        print(f"{r.name}: {len(json.loads((r / 'script.json').read_text())['script'].split())} words")
    if ask(f"\nRender {len(todo)} avatar videos with HeyGen? This spends credits. Type yes: ") != "yes":
        return print("nothing rendered")
    for r in todo:
        env = dict(os.environ)
        if (r / "look.txt").exists():
            env["HEYGEN_AVATAR_ID"] = (r / "look.txt").read_text().strip()
        if not run([sys.executable, "engine/avatar.py", str(r)], env):
            sys.exit(f"stopped at {r.name}; run this step again to pick up from there")


def edit():
    for r in days():
        if (r / "final.mp4").exists() or not (r / "avatar.mp4").exists():
            continue
        print(f"\n{r.name}")
        if not (r / "edit").exists() and not run(["npx", "hyperframes", "init", str(r / "edit"), "--video",
                                                  str(r / "avatar.mp4"), "--resolution", "portrait", "--non-interactive"]):
            sys.exit(f"stopped at {r.name}: hyperframes init failed")
        run(["claude", "-p", f"Using /hyperframes:hyperframes, follow prompts/02-edit.md. Run folder: {r}",
             "--permission-mode", "acceptEdits", "--allowedTools", EDIT_TOOLS])
        if not (r / "final.mp4").exists():
            sys.exit(f"stopped at {r.name}: no final.mp4 (read Claude's last line above)")


def captions():
    for r in days():
        if (r / "captions.json").exists() or not (r / "final.mp4").exists():
            continue
        print(f"\n{r.name}")
        run(["claude", "-p", f"Follow prompts/03-captions.md. Run folder: {r}",
             "--permission-mode", "acceptEdits", "--allowedTools", CAPTION_TOOLS])
        if not checks_ok(r):
            sys.exit(f"stopped at {r.name}: the captions don't pass engine/check.py yet")


def watch():
    opener = "open" if sys.platform == "darwin" else "xdg-open"
    for r in days():
        if not (r / "final.mp4").exists() or (r / "approved.txt").exists():
            continue
        print(f"\n{r.name}: {json.loads((r / 'script.json').read_text())['title']}")
        try:
            subprocess.run([opener, str(r / "final.mp4")])
        except FileNotFoundError:
            print(f"  open {r / 'final.mp4'} yourself")
        answer = ask("  Watched the whole thing, with sound? Post it? (yes / no / stop): ")
        if answer in (None, "stop"):
            break
        if answer == "yes":
            (r / "approved.txt").write_text("yes\n")
        else:
            print("  not approved: fix it (part one's Real use prompts help), then run watch again")


if __name__ == "__main__":
    steps = {"status": status, "avatar": avatar, "edit": edit, "captions": captions, "watch": watch}
    step = sys.argv[1] if len(sys.argv) > 1 else "status"
    if step not in steps:
        sys.exit(__doc__)
    steps[step]()

#!/usr/bin/env python3
"""Schedule the whole batch in plan.json through Upload-Post, each video at its own day and time, with part
one's engine/post.py.

    python3 engine/schedule.py                  # dry run: checks every day and lists what it would schedule
    python3 engine/schedule.py --show           # the same, plus every field post.py would send
    python3 engine/schedule.py --send           # really schedule them (asks first)
    (add --tz Europe/London if you're not on US Eastern)

A day goes out only if it has final.mp4, captions that pass engine/check.py, your yes from
`engine/batch.py watch` (approved.txt) and a time that's still in the future. A day that already has
sent.json is skipped, so running --send again never posts anything twice. Once every day is sent,
plan.json moves to plans/ and you're ready to plan the next batch.
"""
import argparse
import datetime
import json
import subprocess
import sys
from pathlib import Path

try:
    from zoneinfo import ZoneInfo
except ImportError:  # Python 3.8 and older
    ZoneInfo = None


def ask(question):
    """Your typed answer, or None when nobody can type one (e.g. Claude running the step for you)."""
    try:
        return input(question).strip().lower()
    except EOFError:
        print("\nThis step needs your answer: run it yourself in a terminal window.")
        return None


def problems(day, tz):
    r = Path(day["run"])
    out = []
    if (r / "sent.json").exists():
        return ["already sent"]
    for f, why in (("final.mp4", "no final.mp4"), ("captions.json", "no captions.json"),
                   ("approved.txt", "you haven't said yes (engine/batch.py watch)")):
        if not (r / f).exists():
            out.append(why)
    if (r / "captions.json").exists() and subprocess.run(
            [sys.executable, "engine/check.py", str(r)], capture_output=True).returncode:
        out.append("engine/check.py fails")
    when = datetime.datetime.fromisoformat(day["at"])
    now = datetime.datetime.now(ZoneInfo(tz)).replace(tzinfo=None) if ZoneInfo else datetime.datetime.now()
    if when <= now:
        out.append(f"{day['at']} is in the past: change its time in plan.json")
    return out


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--tz", default="America/New_York")
    ap.add_argument("--show", action="store_true", help="print every field post.py would send")
    ap.add_argument("--send", action="store_true", help="really schedule (default: dry run)")
    a = ap.parse_args()
    plan_file = Path("plan.json")
    if not plan_file.exists():
        sys.exit("no plan.json: run engine/plan.py first")
    plan = json.loads(plan_file.read_text())

    ready = []
    for d in plan:
        p = problems(d, a.tz)
        print(f"{d['at'].replace('T', ' ')}  {d['id']:<10} {d['title'][:44]:<44}  {'ready' if not p else '; '.join(p)}")
        if not p:
            ready.append(d)
    sent = sum((Path(d["run"]) / "sent.json").exists() for d in plan)
    print(f"\n{len(ready)} ready to schedule, {sent} already sent, {len(plan) - len(ready) - sent} not ready ({a.tz}).")
    if a.show:
        for d in ready:
            print(f"\n=== {d['run']} at {d['at']}", flush=True)
            subprocess.run([sys.executable, "engine/post.py", d["run"], "--at", d["at"], "--tz", a.tz])
    if not a.send:
        print("Dry run: nothing sent. Add --send to schedule the ready ones.")
        return
    if not ready:
        return
    if ask(f"Schedule {len(ready)} videos on every app in captions.json, AI label on? Type yes: ") != "yes":
        return print("nothing sent")
    for d in ready:
        print(f"\n=== {d['run']} at {d['at']}", flush=True)
        subprocess.run([sys.executable, "engine/post.py", d["run"], "--at", d["at"], "--tz", a.tz, "--send"])
        sent_file = Path(d["run"]) / "sent.json"
        if not sent_file.exists():
            print("  not sent (read post.py's message above)")
            continue
        for label, res in json.loads(sent_file.read_text()).items():
            if not str(res.get("http", "")).startswith("2"):
                print(f"  check {label}: HTTP {res.get('http')} (see {d['run']}/sent.json)")
    if all((Path(d["run"]) / "sent.json").exists() for d in plan):
        Path("plans").mkdir(exist_ok=True)
        plan_file.rename(Path("plans") / f"plan-{plan[0]['date']}.json")
        print(f"\nEvery day is sent. The plan moved to plans/plan-{plan[0]['date']}.json.")


if __name__ == "__main__":
    main()