AI Production & Agent System

THINKING BLOCK:
Input: [list files provided]
Expected Output: [what you plan to create]
Constraints: [face blur, codec, dimensions, etc.]
Tool Selection: [which tools you'll use and why]
Resource Check: [RAM/GPU availability]

If anything is unclear or missing, ask BEFORE proceeding.

Be direct and concise. Avoid preambles, greetings, or conversational fluff. Lead with key answers, plans, or diffs. Use tables, markdown lists, and diagrams for clarity.

On failure: do NOT guess. Proactively execute a web search or codebase grep using the error string. Find verified working solutions and apply them.

Token Efficiency: Batch related file reads into a single tool call. Avoid reading directories recursively unless necessary. Prune context proactively.

Test & Verify: Always compile/run and verify code using tests or script executions. Iterate on fix-test-verify cycle until all tests pass and requirements are fully met.

# AGENT CORE SYSTEM PROMPT — AUTONOMOUS PRODUCTION AGENT

## IDENTITY
You are a fully autonomous production agent running locally on macOS.
You complete EVERY task end-to-end without stopping early. You never
claim success without proof (a real file on disk, a passing test, a
validated number). You are resourceful, error-defensive, and precise.

## CORE OPERATING LOOP (run on EVERY task, no exceptions)
1. THINK — Restate the task in your own words. List: inputs I have,
   inputs missing, expected output, risks, success criteria.
2. PLAN — Break into numbered sub-tasks. Each = {input → tool →
   output file → verification method}. Write to plan.json.
3. SPEC — For each sub-task: which skill/tool? If a tool is missing,
   find a lightweight free one and install in the isolated venv.
4. PREFLIGHT — Verify tools exist (which ffmpeg), verify inputs exist (ls).
   NEVER assume. Measure everything (ffprobe, file size, etc).
5. ACT — Execute one sub-task. Capture stdout, stderr, exit code.
6. VERIFY — Confirm the output file EXISTS and is valid (not 0 bytes,
   correct duration/dimensions). Update progress.json.
7. FIX — On error: read the error → try easiest fix → retry. After
   2 fails, SEARCH the exact error string → apply found fix.
   Max 3 attempts, then report the blocker clearly.
8. NEXT — Re-read progress.json. Move to next sub-task.
9. DELIVER — Only when ALL sub-tasks show "done" with verified files.
   Output: result paths + manifest.json + re-runnable script.

## ABSOLUTE RULES (zero tolerance)
- NEVER guess a number (duration, size, count). Always measure it.
- NEVER say "done" if the output file does not exist or is invalid.
- NEVER skip a sub-task to save time.
- NEVER touch the protected company bundle. New tools go in the venv only.
- ALWAYS write progress.json after each step so context is never lost.
- ALWAYS prefer the simplest working solution first (error-defensive mode).

## KEYWORD ROUTING (skills activate by these trigger words)
- "trim" / "cut" → audio_trim skill
- "merge" / "join" → audio_merge skill
- "sync" / "fit" → audio_video_sync skill
- "transcribe" → whisper skill
- "keyframes" / "watch" → video_understand skill
- "generate image" → image_prompt skill
- "animate" → animation skill
- "search" / "fetch" → web_research skill

## RESOURCE DISCIPLINE (local Mac, quality preserved)
- Use streaming/chunked processing for large media (never load full file into RAM if avoidable).
- Pick smallest model that meets quality bar (Whisper small before medium).
- Clean temp files after each sub-task.
- Cap parallel jobs to (CPU cores - 1).

#!/bin/bash
# install_agent.sh — sets up everything in an isolated, removable env

set -e
ENV=~/agent-env
echo "==> Creating isolated environment (company bundle untouched)..."
python3 -m venv $ENV
source $ENV/bin/activate

echo "==> Installing core skills..."
pip install --upgrade pip
pip install \
  pydub librosa auditok soundfile numpy \
  requests beautifulsoup4 duckduckgo-search \
  pillow moviepy tqdm rich

echo "==> Checking system tools..."
command -v ffmpeg >/dev/null || brew install ffmpeg
command -v whisper-cli >/dev/null || echo "  (install whisper.cpp manually)"

echo "==> Done. Activate with: source $ENV/bin/activate"
echo "==> Remove anytime with: rm -rf $ENV  (company software safe)"

# agent_core.py — the backbone that guarantees correct autonomous execution
import json, subprocess, time, os
from pathlib import Path
from datetime import datetime

class AgentCore:
    def __init__(self, task_name):
        self.task = task_name
        self.work = Path(f"./work/{task_name}")
        self.work.mkdir(parents=True, exist_ok=True)
        self.progress_file = self.work / "progress.json"
        self.state = {"task": task_name, "subtasks": {}, "complete": False,
                      "started": str(datetime.now())}
        self._save()

    def _save(self):
        self.progress_file.write_text(json.dumps(self.state, indent=2))

    def plan(self, subtasks: list):
        for s in subtasks:
            self.state["subtasks"][s] = {"status": "pending", "output": None}
        self._save()
        print(f"[PLAN] {len(subtasks)} sub-tasks queued: {subtasks}")

    def run(self, step, cmd, expect_file, validator=None, max_tries=3):
        self.state["subtasks"][step]["status"] = "in_progress"
        self._save()

        for attempt in range(1, max_tries + 1):
            print(f"[ACT] {step} (attempt {attempt})")
            r = subprocess.run(cmd, capture_output=True, text=True)

            if r.returncode == 0 and self._verify(expect_file, validator):
                self.state["subtasks"][step].update(status="done", output=str(expect_file))
                self._save()
                print(f"[VERIFY] {step} ✅ -> {expect_file}")
                return True

            err = r.stderr.strip()[-400:]
            print(f"[FIX] {step} failed: {err}")
            if "No such file" in err and attempt == 1:
                print("  -> input missing, re-checking paths")
            time.sleep(1)

        self.state["subtasks"][step]["status"] = "FAILED"
        self._save()
        print(f"[BLOCKER] {step} failed after {max_tries} tries. Search this error: {err[:150]}")
        return False

    def _verify(self, f, validator):
        f = Path(f)
        if not f.exists() or f.stat().st_size == 0:
            return False
        if validator and not validator(f):
            return False
        return True

    def finish(self):
        done = all(v["status"] == "done" for v in self.state["subtasks"].values())
        if done:
            self.state["complete"] = True
            self._save()
            print("[DELIVER] ✅ ALL sub-tasks verified complete.")
            return True
        pending = [k for k, v in self.state["subtasks"].items() if v["status"] != "done"]
        print(f"[DELIVER] ❌ Cannot finish. Incomplete: {pending}")
        return False

def valid_media(path, min_dur=0.1):
    r = subprocess.run(["ffprobe","-v","error","-show_entries","format=duration","-of","csv=p=0",str(path)], capture_output=True, text=True)
    try:
        return float(r.stdout.strip()) > min_dur
    except (ValueError, AttributeError):
        return False

# skills/web_research.py
import requests, time, random
from bs4 import BeautifulSoup
from duckduckgo_search import DDGS

UA_POOL = [
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0",
]

def web_search(query, max_results=5):
    with DDGS() as ddgs:
        results = list(ddgs.text(query, max_results=max_results))
    return [{"title": r["title"], "url": r["href"], "snippet": r["body"]} for r in results]

def fetch_page(url, retries=3):
    for i in range(retries):
        try:
            r = requests.get(url, timeout=15, headers={"User-Agent": random.choice(UA_POOL)})
            r.raise_for_status()
            soup = BeautifulSoup(r.text, "html.parser")
            for tag in soup(["script", "style"]): tag.decompose()
            return soup.get_text(separator="\n", strip=True)[:8000]
        except Exception as e:
            time.sleep(2 ** i + random.random())  # exponential backoff
    return None

def search_error_fix(error_string):
    results = web_search(f"fix: {error_string}", max_results=3)
    return [r["url"] for r in results]

# skills/registry.py — automatic tool routing
import re

class SkillRegistry:
    def __init__(self):
        self.skills = {}
        self.triggers = {}

    def register(self, name, fn, keywords):
        self.skills[name] = fn
        for kw in keywords:
            self.triggers[kw.lower()] = name

    def route(self, prompt):
        prompt_l = prompt.lower()
        matched = []
        for kw, skill in self.triggers.items():
            if re.search(rf"\b{re.escape(kw)}\b", prompt_l):
                if skill not in matched:
                    matched.append(skill)
        return matched

    def call(self, skill_name, *args, **kwargs):
        return self.skills[skill_name](*args, **kwargs)

# Usage: registry.register("audio_trim", trim_fn, ["trim", "cut", "clip"])
# needed = registry.route("trim the audio then search for fix")
# -> ['audio_trim', 'web_research']

# skills/audio_edit.py
import subprocess
from pydub import AudioSegment, silence
from pathlib import Path

def probe_duration(path):
    r = subprocess.run(["ffprobe","-v","error","-show_entries","format=duration","-of","csv=p=0",str(path)], capture_output=True, text=True)
    return float(r.stdout.strip())

def trim_audio(src, out, start, end):
    subprocess.run(["ffmpeg","-y","-i",str(src),"-ss",str(start),"-to",str(end),"-c:a","aac","-b:a","192k",str(out)], check=True)
    return out

def auto_trim_silence(src, out, thresh=-40, min_sil=500):
    audio = AudioSegment.from_file(src)
    chunks = silence.detect_nonsilent(audio, min_sil, thresh)
    if not chunks: return None
    audio[chunks[0][0]:chunks[-1][1]].export(out, format="mp3", bitrate="192k")
    return out

def merge_audio(files, out, crossfade_ms=300):
    combined = AudioSegment.from_file(files[0])
    for f in files[1:]:
        combined = combined.append(AudioSegment.from_file(f), crossfade=crossfade_ms)
    combined.export(out, format="mp3", bitrate="192k")
    return out

# skills/video_understand.py
import subprocess, json
from pathlib import Path

def extract_keyframes(video, out_dir, every_sec=2):
    Path(out_dir).mkdir(parents=True, exist_ok=True)
    subprocess.run(["ffmpeg","-y","-i",str(video),"-vf",f"fps=1/{every_sec}",f"{out_dir}/frame_%04d.png"], check=True)
    frames = sorted(Path(out_dir).glob("frame_*.png"))
    return [{"frame": str(f), "timestamp": i*every_sec} for i, f in enumerate(frames)]

def detect_scene_changes(video, threshold=0.4):
    r = subprocess.run(["ffmpeg","-i",str(video),"-vf",f"select='gt(scene,{threshold})',showinfo","-f","null","-"], capture_output=True, text=True)
    times = []
    for line in r.stderr.split("\n"):
        if "pts_time:" in line:
            t = line.split("pts_time:")[1].split(" ")[0]
            try: times.append(float(t))
            except ValueError: pass
    return times

def transcribe_timed(audio, model="~/whisper-models/ggml-small.bin"):
    out = "transcript"
    subprocess.run(["whisper-cli","-m",str(Path(model).expanduser()),"-f",str(audio),"--output-json","-of",out], check=True)
    return json.loads(Path(f"{out}.json").read_text())

# skills/sync_engine.py
import json, subprocess
from pathlib import Path

def detect_topic_changes(transcript_json, gap_threshold=1.5):
    segs = transcript_json["segments"]
    breaks = [0]
    for i in range(1, len(segs)):
        gap = segs[i]["start"] - segs[i-1]["end"]
        if gap > gap_threshold: breaks.append(i)
    breaks.append(len(segs))
    return breaks

def build_sync_plan(transcript_json, images, gap_threshold=1.5):
    segs = transcript_json["segments"]
    breaks = detect_topic_changes(transcript_json, gap_threshold)
    plan = []
    for bi in range(len(breaks) - 1):
        start_seg = segs[breaks[bi]]
        end_seg = segs[breaks[bi+1]-1]
        block_start = start_seg["start"]
        block_end = end_seg["end"]
        img = images[bi % len(images)]
        text = " ".join(s["text"].strip() for s in segs[breaks[bi]:breaks[bi+1]])
        plan.append({
            "image": str(img), "start": round(block_start, 2),
            "end": round(block_end, 2),
            "duration": round(block_end - block_start, 2),
            "spoken_text": text
        })
    return plan

def render_synced_video(sync_plan, audio, out, W=1080, H=1920):
    work = Path("./work/sync_clips"); work.mkdir(parents=True, exist_ok=True)
    clips = []
    for i, item in enumerate(sync_plan):
        clip = work / f"clip_{i:03d}.mp4"
        dur = max(item["duration"], 1.0)
        subprocess.run(["ffmpeg","-y","-loop","1","-i",item["image"],"-t",str(dur),"-vf",f"scale={W}:{H}:force_original_aspect_ratio=decrease,pad={W}:{H}:(ow-iw)/2:(oh-ih)/2,setsar=1","-c:v","libx264","-pix_fmt","yuv420p","-r","30",str(clip)], check=True, capture_output=True)
        clips.append(clip)
    concat_file = work / "concat.txt"
    concat_file.write_text("\n".join(f"file '{c.resolve()}'" for c in clips))
    silent = work / "silent.mp4"
    subprocess.run(["ffmpeg","-y","-f","concat","-safe","0","-i",str(concat_file),"-c","copy",str(silent)], check=True)
    subprocess.run(["ffmpeg","-y","-i",str(silent),"-i",str(audio),"-c:v","copy","-c:a","aac","-b:a","192k","-shortest",str(out)], check=True)
    # CRITICAL VERIFY
    vd = float(subprocess.run(["ffprobe","-v","error","-show_entries","format=duration","-of","csv=p=0",str(out)], capture_output=True, text=True).stdout)
    ad = float(subprocess.run(["ffprobe","-v","error","-show_entries","format=duration","-of","csv=p=0",str(audio)], capture_output=True, text=True).stdout)
    assert abs(vd - ad) < 0.5, f"SYNC FAIL: video {vd}s vs audio {ad}s"
    return out

A full-body editorial illustration of a stylized human character, FACE COMPLETELY BLANK — no eyes, no nose, no mouth, no facial features, no mask, smooth featureless face surface, but clearly a living human figure with natural posture and expressive body language. Style: cinematic editorial, ultra-vibrant saturated color palette, bold complementary color contrast (teal & orange), dramatic rim lighting, high dynamic range, 8K resolution, sharp focus, professional color grading like a feature film. Clean composition, single subject, plain gradient background. NEGATIVE: facial features, eyes, mouth, nose, mask, text on face, robot, mechanical parts, deformed anatomy, extra limbs, blur, low resolution, watermark, distorted hands.

A gentle storybook-style human character, FACE TOTALLY FEATURELESS — no drawn eyes, mouth or nose, completely smooth blank face, no mask, yet a believable lifelike person with warm relatable body posture. Style: soft pastel palette, painterly textures, diffuse warm lighting, high saturation kept tasteful, gentle contrast, high resolution, clean professional finish. Single character, simple soft background. NEGATIVE: face details, facial features, mask, robot, text on face, harsh shadows, deformed body, extra fingers, low quality, watermark.

Cinematic-Storybook Fusion: A lifelike stylized human character, FACE 100% BLANK AND FEATURELESS — absolutely no eyes, nose, mouth, no mask, smooth empty face, but unmistakably a living human with dynamic natural pose. Fuse two styles: the dramatic rim lighting + teal-orange cinematic grade of editorial film, blended with the soft painterly pastel textures of storybook art. Ultra-high saturation with balanced contrast, 8K, sharp, professional cinematic color grading. Single subject, clean gradient background. NEGATIVE: facial features, eyes, mouth, nose, mask, text on face, robot, mechanical, deformed, extra limbs, blur, watermark, low-res.

CHARACTER PROMPT:
Full-body living human woman, FACE TOTALLY BLANK — no features, no mask, smooth featureless face, expressive through posture and hands. Flowing traveler's clothing, warm earth-and-teal palette, cinematic rim light, 8K, saturated, film-grade grading. Single subject.
NEGATIVE: face features, mask, face text, robot, deformity, low-res.

CLOSED-END STORY (self-contained):
Mira leaves a quiet village at dawn, crosses three landscapes — desert, river, mountain — searching for a lost song. At the peak she finds it was her own voice all along, and returns home complete. (Beginning → journey → revelation → closed resolution.)

ANIMATION PROMPT:
Animate the blank-faced traveler walking forward with gentle wind in her clothing and hair. Camera slowly pushes in. Subtle parallax in background. KEEP FACE COMPLETELY BLANK AND UNCHANGED — do not add eyes, mouth, or any facial features during motion. Smooth natural body movement only. Cinematic, high quality, stable, no flicker.
NEGATIVE: face features appearing, mask, morphing face, robot, warping limbs, flicker, artifacts, distortion.

CHARACTER PROMPT:
Full-body living human man, FACE COMPLETELY FEATURELESS — no eyes, mouth, nose, no mask, smooth blank face, lifelike through stance and gesture. Sturdy workwear, soft pastel palette, warm diffuse light, high tasteful saturation, painterly texture, high resolution.
NEGATIVE: face features, mask, face text, robot, deformity, low-res.

CLOSED-END STORY (self-contained, different tone from Mira):
Theo builds a bridge across a divided town. Each plank is a problem solved; each problem teaches patience. When the bridge connects, the town celebrates — and Theo quietly starts the next one. (Setup → escalating challenge → completion → closed ending.)

ANIMATION PROMPT:
Animate the blank-faced builder lifting and placing a plank, calm steady motion, soft light shifting warmly. KEEP FACE FULLY FEATURELESS AND STATIC — no facial features added during animation. Gentle, believable body mechanics only. Soft, high quality, stable.
NEGATIVE: face features, mask, face morphing, robot, limb warping, flicker, artifacts.

VOICEOVER FOR MIRA (read aloud while her images show):
"At first light, she leaves everything familiar behind. [PAUSE — switch to desert image] The desert tests her patience. [PAUSE — switch to river image] The river teaches her to flow. [PAUSE — switch to mountain image] And at the very top, she discovers the song was never lost — it lived in her all along."

SYNC NOTES (feed to sync_engine):
- Each [PAUSE] = a topic break (>1.5s) = image switch.
- The sync_engine auto-detects these pauses in your recorded audio and holds each image for exactly that spoken segment's length.
- Long line = image held longer; short line = image held shorter.