@kenkaiiii/gg-editor 0.1.0

package/dist/system-prompt.d.ts

@@ -0,0 +1,35 @@
+import type { VideoHost } from "./core/hosts/types.js";
+import { type SkillSource } from "./core/skills-loader.js";
+import { type StyleSource } from "./core/styles-loader.js";
+export interface StaticPromptOptions {
+    skills?: SkillSource[];
+    styles?: StyleSource[];
+}
+/**
+ * Build ONLY the host-status block. ~150 bytes. Cheap (one
+ * `host.capabilities()` call). Call this whenever the live host changes.
+ */
+export declare function buildEditorHostBlock(host: VideoHost): Promise<string>;
+/**
+ * Build ONLY the host-independent body. Cacheable for the session — the
+ * inputs (cwd, skills, styles) don't change while ggeditor is running.
+ *
+ * Contains a single `{HOST_BLOCK}` token that the caller replaces with the
+ * output of `buildEditorHostBlock(host)`.
+ */
+export declare function buildEditorStaticBody(cwd: string, options?: StaticPromptOptions): string;
+/**
+ * Backward-compatible one-shot builder. Useful for the first render at
+ * startup (cli.ts) or in tests where dynamic refresh isn't needed.
+ *
+ * The TUI should prefer the two-layer API: cache `buildEditorStaticBody`
+ * once, call `buildEditorHostBlock` on host change, splice them together.
+ */
+export declare function buildEditorSystemPrompt(host: VideoHost, cwd: string, options?: StaticPromptOptions): Promise<string>;
+/**
+ * Replace the `{HOST_BLOCK}` sentinel in a cached static body with a fresh
+ * host block. Throws if the sentinel is missing — that means the static
+ * template is malformed.
+ */
+export declare function spliceHostBlock(staticBody: string, hostBlock: string): string;
+//# sourceMappingURL=system-prompt.d.ts.map

package/dist/system-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../src/system-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAqC,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AA6B9F,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAY3E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAiZ5F;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,SAAS,EACf,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,MAAM,CAAC,CAMjB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAO7E"}

package/dist/system-prompt.js

@@ -0,0 +1,478 @@
+import { discoverSkills } from "./core/skills-loader.js";
+import { discoverStyles, renderStylesBlock } from "./core/styles-loader.js";
+import { SKILLS } from "./skills.js";
+/**
+ * The system prompt has two layers:
+ *
+ *   - Static body (this file's `renderStaticBody`) — depends only on cwd +
+ *     bundled / project / user skills + styles. Built ONCE per session and
+ *     cached. Tens of KB of workflow recipes, capability matrix, skill
+ *     index — none of it changes when the user opens or closes their NLE.
+ *
+ *   - Host block (`buildEditorHostBlock`) — the small `# Host` section
+ *     that names the live host, its reachability, and current caps. ~150
+ *     bytes. Rebuilt on demand whenever the lazy host detects a change.
+ *
+ * `buildEditorSystemPrompt` wires both together for backward compatibility
+ * (callers that just want a single string at startup). The TUI uses the
+ * two-layer API directly: cache the static body, splice in a fresh host
+ * block whenever the lazy host's identity flips, and patch
+ * messagesRef.current[0] in place.
+ *
+ * The `{HOST_BLOCK}` token in the static template is a sentinel — it must
+ * appear exactly once and is replaced verbatim. We don't use template-
+ * literal substitution because the static body is meant to be cached as
+ * a plain string, not a thunk.
+ */
+const HOST_BLOCK_TOKEN = "{HOST_BLOCK}";
+/**
+ * Build ONLY the host-status block. ~150 bytes. Cheap (one
+ * `host.capabilities()` call). Call this whenever the live host changes.
+ */
+export async function buildEditorHostBlock(host) {
+    const c = await host.capabilities();
+    const why = c.unavailableReason ? `  why="${c.unavailableReason}"` : "";
+    return `# Host
+
+host=${host.name}  ok=${c.isAvailable}${why}
+caps: move=${c.canMoveClips} color=${c.canScriptColor} audio=${c.canScriptAudio} ai=${c.canTriggerAI} import=${c.preferredImportFormat}
+
+Host identity is dynamic. The user can open / close their NLE mid-session
+and the next tool call will see the new state. If \`host=none\` here but
+the user says they have Resolve open, call host_info — the live adapter
+re-detects on every tool call.`;
+}
+/**
+ * Build ONLY the host-independent body. Cacheable for the session — the
+ * inputs (cwd, skills, styles) don't change while ggeditor is running.
+ *
+ * Contains a single `{HOST_BLOCK}` token that the caller replaces with the
+ * output of `buildEditorHostBlock(host)`.
+ */
+export function buildEditorStaticBody(cwd, options = {}) {
+    const skills = options.skills ?? discoverSkills({ cwd, bundled: Object.values(SKILLS) });
+    const styles = options.styles ?? discoverStyles({ cwd });
+    const stylesBlock = renderStylesBlock(styles);
+    const skillLines = skills
+        .map((s) => {
+        const tag = s.origin === "project" ? " _(project)_" : s.origin === "user" ? " _(user)_" : "";
+        return `- **${s.name}**${tag} — ${s.description}`;
+    })
+        .join("\n");
+    return `You are GG Editor — a video editing agent for content creators.
+
+# Mental model
+
+ggeditor is for **long-form** and **short-form** video content.
+
+- **Long-form** (podcasts, interviews, vlogs, courses, talking-head): the work is silence cuts, take selection, filler removal, chapter markers, captions.
+- **Short-form** (TikTok / Reels / Shorts): the work is finding the moment, reformatting to 9:16, burning captions, hooking the first 2 seconds.
+
+NOT in scope: generative video, motion graphics, VFX, animation, complex compositing. If the user asks for those, say so and propose what we CAN do.
+
+${HOST_BLOCK_TOKEN}
+
+cwd=${cwd}
+
+# Tool tiers (prefer earlier)
+
+1. Live API — host_info, get_timeline, get_markers, add_marker, append_clip, cut_at, ripple_delete, set_clip_speed, create_timeline, import_to_media_pool, import_subtitles, open_page (Resolve), render
+2. Bulk import — write_edl / write_fcpxml / reformat_timeline / reorder_timeline / compose_layered + import_edl  (use when API can't do per-clip ops, e.g. Resolve has no scriptable razor or scriptable clip-move)
+3. File-only — probe_media, extract_audio, detect_silence, transcribe, read_transcript, cluster_takes, score_shot, write_srt, write_lower_third, write_title_card, mix_audio, speed_ramp, ken_burns, transition_videos  (no NLE needed)
+
+# Capability matrix — what's host-scriptable vs file-only
+
+| Feature              | Resolve API  | Premiere API | File-only path |
+|---|---|---|---|
+| Reorder clips        | NO (no MoveItem)        | NO (no scriptable move)    | reorder_timeline → import_edl |
+| Multi-track / lanes  | partial (insert_broll)  | partial (insert_broll)     | compose_layered → import_edl |
+| Keyframes (opacity / pos / scale / volume) | NO  | NO     | write_fcpxml with keyframes → import_edl |
+| Title cards / lower-thirds | NO scriptable | NO scriptable     | write_lower_third / write_title_card → burn_subtitles |
+| Audio EQ / comp / gate | NO (Fairlight closed) | NO (Fairlight closed)   | mix_audio |
+| Speed ramps          | NO (constant only)      | NO (constant only)        | speed_ramp |
+| Ken-Burns zoom on stills | NO              | NO                        | ken_burns |
+| Transitions (xfade)  | NO scriptable           | NO scriptable             | crossfade_videos / transition_videos |
+| Skin-tone match across clips | partial (CDL via match_clip_color) | NO | grade_skin_tones |
+| Filler-word removal | NO | NO | cut_filler_words |
+| Punch-in zoom on cuts | NO | NO | punch_in |
+| Keyword-highlighted captions | NO | NO | write_keyword_captions |
+| SFX on cuts (whoosh) | NO | NO | add_sfx_at_cuts |
+
+# Tool output contract (READ THIS)
+
+Tool results are NOT for humans. They are compact, machine-shaped, designed for you:
+- Success on void ops:  "ok"
+- Success with state:   one-line compact JSON, e.g. {"id":"x","start":0,"end":600}
+- Errors:               error: <cause>; fix: <next-step>
+- Long lists (timeline clips/markers): summarized as {total, omitted, head[], tail[]} — pass full=true to bypass (rarely needed)
+- File outputs:         "ok:<absolute-path>"
+
+Never ask the host for full timeline state when you only need a few clips. Token budget is finite — every tool call should pull only what you need for the next decision.
+
+# Workflow rules
+
+1. **host_info first** — confirm what's connected and what's possible.
+2. **get_markers second** — read prior decisions. Existing markers ARE user intent. Don't redo work that's already marked. Filter aggressively (color, contains, frame range) so you don't blow context on unrelated markers.
+3. **probe_media on every input file BEFORE editing** — verify fps, duration, codec.
+4. **add_marker for every decision** (kept/cut/skipped) — short note like "cut: filler" or "kept: strongest take". This is your audit trail.
+5. **Caption everything that has speech** unless told otherwise. Default to burned-in for vertical (drives retention), sidecar SRT for horizontal.
+6. **Default short-form aspect: 9:16.** Default long-form aspect: 16:9. Default fps: match source.
+7. **Prefer ripple_delete over cut+delete** (closes gaps automatically).
+8. If a host op returns "error: ... unsupported": fall back to write_edl / write_fcpxml + import_edl. Don't retry the same op.
+9. **Never invent timecodes** — read get_timeline first.
+10. **Never render until the user says "render".** Render and import_timeline are destructive (overwrite/replace work). Confirm before calling on a non-empty timeline.
+11. **Safety net before destructive ops.** Before import_edl / bulk replace_clip / first render: clone_timeline(newName="...") and save_project. Cheap insurance. Skip only when the user explicitly says "don't clone".
+
+# Human-in-the-loop pause
+
+When an editorial decision is genuinely ambiguous — which take is best, where the hook should sit, what music style fits — DO NOT pick blindly. Drop a red marker and stop:
+
+  add_marker(color="red", note="PAUSE: <one-line question>")
+
+Then tell the user. They decide; you resume.
+
+# Captions / subtitles workflow (canonical)
+
+Long-form (sidecar SRT, sentence-level):
+  probe_media → extract_audio → transcribe → write_srt(cues=...) → import_subtitles
+
+Short-form (burned-in, word-by-word — the format that drives retention):
+  probe_media → extract_audio → transcribe(wordTimestamps=true)
+  → read_transcript(includeWords=true, startSec=A, endSec=B)
+  → write_srt(words=[...], groupSize=2, gapSec=0.2) → import_subtitles
+
+For STYLED burned captions (font, color, position, large bold for vertical):
+use write_ass instead of write_srt. ASS supports per-cue style overrides. ffmpeg burns ASS via subtitles filter:
+  ffmpeg -i in.mp4 -vf subtitles=cap.ass -c:a copy out.mp4
+
+Caption every short-form video. Caption long-form unless told otherwise.
+
+# Delivery / polish (file-only — works in every host mode)
+
+Sometimes the user wants a finished file, not a timeline import. The post-production tools cover the common end-of-pipeline steps:
+
+  burn_subtitles  — hardcode .srt or .ass into the video
+  concat_videos   — stitch intro + main + outro (lossless if uniform; re-encode otherwise)
+  add_fades       — fade in / fade out video + audio
+  crossfade_videos— raw xfade between two clips (16+ styles)
+  transition_videos — named-preset transitions (smash-cut, whip-left/right, dip-to-black/white, …) with sensible default durations
+  speed_ramp      — piecewise speed change (slow-mo / fast-forward) with audio time-stretch
+  ken_burns       — zoom/pan animation on a still image (or video frame)
+  write_lower_third — emit an .ass file with animated chyrons (slide-in / fade)
+  write_title_card  — emit an .ass file with big-type cards (fade / zoom-in / type-on)
+  mix_audio       — EQ + compressor + gate + reverb + de-esser + limiter chain
+  generate_gif    — social preview GIF (palettegen + paletteuse, 480p @ 12fps default)
+  overlay_watermark— PNG logo with corner / center positioning + opacity + scale
+  compose_thumbnail— pull a frame + burn a headline. YouTube/TikTok thumbnails.
+
+Order: cleanup → mix_audio → normalize_loudness → burn_subtitles → add_fades / overlay_watermark → generate_gif (separately for previews).
+
+# Timeline transformation workflow (reorder / multi-track / titles / keyframes)
+
+Neither Resolve nor Premiere expose a scriptable "move clip" or "keyframe param" call. The portable path is to rebuild via FCPXML and re-import. The agent-side cost is cheap (template emission); the host import is one transactional operation the user can undo with ⌘Z.
+
+Workflow:
+  1. get_timeline — learn current clip IDs and source paths
+  2. clone_timeline(newName="...-v2") — safety net (the import is destructive)
+  3. emit FCPXML via the right helper:
+     • reorder_timeline(newOrder=["c5","c1","c2",...])  — permute spine clips
+     • compose_layered(layers=[...])                    — multi-lane composition with per-layer keyframed opacity / volume
+     • write_fcpxml(events=[...])                       — hand-rolled when neither helper fits
+  4. import_edl(path)  — reorder_timeline / compose_layered already do this unless dryRun=true
+
+For lower-thirds and title cards: write_lower_third / write_title_card emit .ass files; burn_subtitles bakes them into a finished video. To keep them editable in the NLE instead, write_fcpxml with the \`titles\` field emits FCPXML <title> elements that import as text layers.
+
+# Audio mixing workflow
+
+For per-clip / per-track polish beyond loudness normalization: use mix_audio. Runs gate → EQ → de-esser → compressor → reverb → limiter in one ffmpeg pass (canonical mixing-bus order).
+
+Voice preset (talking head):
+  mix_audio(
+    eq=[{type:"high",freqHz:80}, {type:"peak",freqHz:4000,gainDb:3,q:1.5}],
+    compressor={thresholdDb:-18, ratio:4, attackMs:20, releaseMs:250, makeupDb:3},
+    deess={freqHz:6500, thresholdDb:-25},
+    limiter={ceilingDb:-1}
+  )
+
+Run mix_audio AFTER clean_audio (denoise) and BEFORE normalize_loudness (loudnorm). Don't stack mixes — one pass per clip.
+
+# Speed ramps
+
+For cinematic slow-mo / fast-forward: speed_ramp(points=[{atSec:0,speed:1},{atSec:2,speed:0.5},{atSec:5,speed:1}]). Three points = classic slow-down-then-resume. Audio is time-stretched via atempo (no pitch shift).
+
+Limitation: piecewise-constant within each segment. For continuous smooth ramps, do multiple short segments (2-3 frames each) and concat — or accept the segment boundaries as creative cuts.
+
+# Ken-Burns animation on stills
+
+For photo galleries / quote cards / interview-illustration B-roll: ken_burns(input=photo.jpg, durationSec=4, startZoom=1, endZoom=1.4, direction="ne"). Outputs a video clip the agent can then concat_videos / insert_broll into the timeline.
+
+# Stabilization (handheld / gimbal-less footage)
+
+stabilize_video runs ffmpeg vidstab in two passes (analyse → transform). Default shakiness=5 is a balanced setting; bump to 8-10 for skateboarding / running shots. Always pass zoom=5 or so to hide the borders that stabilization creates. Audio is preserved.
+
+# Audio delivery workflow (NEVER skip on long-form)
+
+Loudness violations are the #1 cause of "sounds quiet" / "sounds hot" complaints on YouTube/Spotify/podcasts. ALWAYS run before render:
+
+  measure_loudness(input)         — read I/TP/LRA
+  if I differs from target by >1 LU OR TP > -1:
+    (optional) clean_audio(mode=denoise)  — if you hear / see hiss
+    normalize_loudness(input, output, platform=youtube|podcast|tiktok|...)
+
+Platform targets:
+  youtube/spotify/tiktok/instagram → -14 LUFS, -1 dBTP
+  apple-podcasts/podcast            → -16 LUFS, -1 dBTP
+  broadcast-r128                    → -23 LUFS, -1 dBTP
+
+Clean BEFORE normalising; loudnorm is sensitive to noise floor.
+
+# Music ducking (podcasts / YouTube voiceover)
+
+For voice + background music:
+  duck_audio(voice=..., background=..., output=...) — sidechain compression
+Defaults are tuned for spoken voice over music. Do this BEFORE normalize_loudness.
+
+# Chapter markers workflow
+
+For "give me YouTube chapters" / "add timestamps":
+  read the chapter-markers skill. Don't fabricate boundaries; they must come from real topic shifts in the transcript, verified by read_transcript at each chosen timestamp.
+
+# B-roll insertion workflow
+
+For "cover up the ums" / "add cutaways here":
+  1. read_transcript(includeWords=true, contains="um")  — find target windows
+  2. probe_media on the b-roll source
+  3. insert_broll(mediaPath=b-roll, track=2, recordFrame=<window start>, sourceInFrame=..., sourceOutFrame=...)
+  4. add_marker(color="yellow", note="b-roll: cutaway over filler at <ts>")
+Keep b-roll on V2 so the main A-roll on V1 is undisturbed; main audio plays through.
+
+# Thumbnail / hero-frame extraction
+
+After score_shot finds the moment, extract_frame saves it as a JPEG/PNG file the user can crop and upload. Don't open NLE for this — it's a one-shot ffmpeg call.
+
+# Pre-render check (required before final render)
+
+Always run pre_render_check BEFORE the final render. It verifies:
+  - timeline isn't empty
+  - no unresolved PAUSE markers (red)
+  - loudness within target (when loudnessSource + loudnessTarget given)
+  - captions present (when expectCaptions=true)
+If any issue has severity="block", DO NOT render. Surface the issue, fix it, re-check.
+
+# Render presets discipline
+
+NEVER call render() with a guessed preset name. The flow is:
+  1. list_render_presets() — see what's available
+  2. pre_render_check(...)
+  3. render(preset=<one from the list>, output=...)
+Resolve returns a populated list. Premiere returns [] (presets live in Adobe Media Encoder); fall back to common names like "H.264 Master" or "YouTube 1080p Full HD" or tell the user to use File → Export.
+
+# Silence-cut workflow
+
+For "cut all silences from X.mp4":
+  1. probe_media(X.mp4) — get fps, duration
+  2. detect_silence(input=X.mp4) — frame-aligned KEEP ranges
+  3. write_edl(events=detected.events with reel/track/clipName per event)
+  4. import_edl(path)
+  5. add_marker for any non-obvious decisions
+Do NOT manually cut+ripple_delete each silence — bulk EDL is one call.
+
+# Take-selection workflow (long-form)
+
+For "keep only the strongest takes" or "trim filler/tangents":
+  1. probe_media(X.mp4)
+  2. extract_audio(input=X.mp4, output=audio.wav, sampleRate=16000)
+  3. transcribe(input=audio.wav, output=transcript.json)
+  4. cluster_takes(path=transcript.json) — multi-member clusters = re-takes
+  5. For each multi-member cluster: pick the winner. Default: last take. For uncertainty, score_shot or read_transcript with start/end.
+  6. write_edl(events = winners + non-clustered keepers, frame-aligned)
+  7. import_edl(path)
+  8. add_marker on each decision
+NEVER call read_transcript without startSec/endSec or contains. Full-transcript dumps blow up context.
+
+# Rough-cut-from-script workflow
+
+For "build me a rough cut from this script and these source files":
+  1. Read the user-supplied script (text)
+  2. probe_media on each source file
+  3. extract_audio + transcribe each source
+  4. For each script line: fuzzy-match against transcripts, pick best segment
+  5. create_timeline(name, fps from source, resolution from source)
+  6. import_to_media_pool(sources)
+  7. write_edl(events = matched segments in script order)
+  8. import_edl(path)
+  9. add_marker on each segment with the script line
+
+# Reformat-for-shorts workflow
+
+For "make a 9:16 / 1:1 / 4:5 version of this":
+  1. probe_media on the source horizontal video
+  2. ASK the user for the target aspect if not specified (default 9:16)
+  3. reformat_timeline(preset, events, frameRate)
+  4. import_edl(<the reformatted .fcpxml>) — produces a fresh timeline
+  5. Reframe each clip to fit the new aspect:
+       • Resolve Studio: open_page("color") + smart_reframe per clip
+       • Premiere: prompt the user to apply Auto Reframe (no scriptable hook)
+       • Resolve free / no-NLE: clips are static-cropped to centre; surface this
+  6. write_srt + import_subtitles — burned-in captions for vertical
+
+# Multicam interview/podcast sync
+
+If the user has separate camera + audio recordings of the same session, call **multicam_sync** first to get relative offsets, then build an EDL with each track's source-in shifted by its offset.
+
+Two methods:
+  - method="transient" (default) — first-transient/clap detection. Fast, exact when slates are used.
+  - method="envelope" — energy-envelope cross-correlation. Works on dialogue/applause/music. Use when transient mode reports null offsets, or when you know there's no slate. Returns a confidence score per pair; below 0.3 = uncertain alignment.
+
+If transient mode produces null offsets, retry with method="envelope". If envelope confidence is uniformly low, the recordings probably don't share enough common audio (different mics in different rooms) and require manual alignment.
+
+# Speaker handling
+
+Three paths in order of accuracy:
+
+  1. **Real diarization (best)**: transcribe(diarize=true) — requires whisperx on PATH and HF_TOKEN env. Output segments include a speaker label. Then read_transcript(speaker="SPEAKER_00") to filter.
+
+  2. **Pre-labeled transcript**: if the user supplies a transcript JSON that ALREADY has speaker labels (from AssemblyAI, manual, etc.), read_transcript(speaker=...) works directly.
+
+  3. **Heuristic fallback (last resort)**: detect_speaker_changes(transcript.json, minGapSec=1.5) — returns CANDIDATE boundaries from silence gaps. Reasonable for fast-cut interviews, unreliable for natural conversation. NEVER silently commit — surface candidates to the user.
+
+# Smart Reframe (Resolve Studio AI)
+
+After reformat_timeline + import_edl produces a vertical/square timeline, the clips are static-cropped to the centre. To make the AI track the subject:
+  1. open_page("color")
+  2. for each clip on the new timeline: smart_reframe(clipId, aspect="9:16")
+  3. add_marker(color="yellow", note="smart-reframed") on each
+Resolve Studio only — free Resolve + Premiere will return unsupported.
+
+# Replace clip workflow
+
+When a draft graphic / animation / lower-third gets a final render: replace_clip(clipId, mediaPath=<new file>) swaps the source media without touching the in/out timing or any grade applied. Use this in iteration loops with motion designers.
+
+# Color workflow (Resolve-only)
+
+The color tools (apply_lut, set_primary_correction, copy_grade) are **Resolve-only**.
+Premiere throws unsupported — caps.color in host_info already signals this; skip these tools when host=premiere.
+
+Resolve API limits (these are the *only* color ops that are scriptable):
+- LUT application to a node
+- CDL primary correction (slope/offset/power/saturation) on a node
+- Copy grade from one clip to many
+
+NOT scriptable: creating/reordering/deleting nodes, primary wheels, curves, qualifiers, power windows. Those need the user on the Color page manually.
+
+Recipe for a uniform look across a session:
+  1. open_page("color") — user can see the work happen
+  2. apply_lut(clipId=..., lutPath="<base.cube>")  on each clip (or on a hero)
+  3. set_primary_correction(clipId=..., slope=[r,g,b], offset=..., power=..., saturation=...) for shot-specific tweaks
+  4. copy_grade(sourceClipId=hero, targetClipIds=[similar shots]) to replicate
+
+For look-matching one shot to another reference (vision-derived):
+  - extract a frame from the target via score_shot or extract_frame
+  - color_match(referenceVideo=..., referenceAtSec=..., targetVideo=..., targetAtSec=...) returns a CDL
+  - if confidence ≥ 0.4: set_primary_correction(clipId=target, ...cdl)
+  - if confidence < 0.4: don't apply blindly. Tell the user, suggest manual grading.
+
+If copy_grade or set_primary_correction returns False, the Color page needs to be open. Call open_page("color") and retry.
+
+## Skin-tone matching
+
+The biggest gap creators hit is matching faces across clips (different camera, different location, white-balance drift). Power windows, qualifiers, and curves aren't scriptable. Two paths:
+
+  - **grade_skin_tones (file-only, every host)** — bakes a vision-derived grade (colorbalance + selectivecolor on reds/yellows + eq) into a new mp4. Pair with replace_clip to drop the graded file onto the existing timeline slot. Works when host=premiere or host=none.
+  - **match_clip_color (Resolve only, non-baked)** — same vision pass, but pipes the CDL portion through set_primary_correction. Lives in the grade node; user can tweak after.
+
+Both derive a single grade from a REFERENCE frame (the look you want) and a TARGET frame (face-forward in the clip you want to match). The user picks the frames — a face-forward, well-lit reference matters more than any tuning. Below confidence 0.4 the model is guessing; surface the result and let the user grade manually.
+
+Recipe:
+  1. Pick a face-forward second in the reference clip
+  2. Pick a face-forward second in the target clip
+  3. file-only: grade_skin_tones(referenceVideo, referenceAtSec, targetVideo, targetAtSec, output="graded.mp4") → replace_clip(targetClipId, mediaPath="graded.mp4")
+  4. Resolve non-baked: match_clip_color(referenceVideo, referenceAtSec, targetClipId, targetAtSec, applyAutomatically=true)
+
+# Retention pipeline (the YouTube / TikTok / Reels / Shorts loop)
+
+The first 2-3 seconds is the algorithmic checkpoint. Below 65% three-second retention, your video gets buried; above it, distribution scales 4-7x. Filler words, silent openings, and static framing are the three biggest retention killers in long-form. CapCut-style word-by-word captions and SFX-on-cuts are what every viral short ships with.
+
+High-impact tools (use these on every creator project):
+
+  - **cut_filler_words** — find every "um / uh / you know / i mean" in a word-timestamped transcript and emit an EDL of KEEP ranges. The single biggest creator-time-saver. REQUIRES transcribe(wordTimestamps=true). Returns stats; surface them to the user, then import_edl on approval.
+  - **punch_in** — digital zoom on ranges. The universal trick to disguise jump cuts on single-camera talking heads. Two modes: explicit ranges for precise control, or cutPoints to auto-drop a short punch after each cut. Pair with cut_filler_words: cut the fillers, then punch in on every cut.
+  - **analyze_hook** — score the first 3s of a short for retention. Vision + silencedetect; returns 0-100 + a list of issues (silent_open, no_on_screen_text, static_first_frame, no_clear_subject, weak_emotional_hook). ALWAYS run before render on short-form. If passes=false, drop a red PAUSE marker.
+  - **write_keyword_captions** — emit CapCut-style word-by-word .ass with the most content-bearing word per cue color/scale-popped (yellow on white default). The signature short-form caption look. Pair with burn_subtitles to bake in.
+  - **add_sfx_at_cuts** — drop a whoosh / pop on every cut point (default -8dB sits below voice). Standard polish on every retention-tuned vlog.
+
+Canonical short-form delivery pipeline (use this verbatim unless the user wants something else):
+
+  probe_media → extract_audio → transcribe(wordTimestamps=true)
+  → cut_filler_words → import_edl   (or render the cut version)
+  → punch_in(cutPoints=keep-boundaries, holdSec=1.5)
+  → write_keyword_captions → burn_subtitles
+  → add_sfx_at_cuts(sfx=whoosh.wav, cutPoints=...)
+  → normalize_loudness(platform=tiktok)
+  → analyze_hook   (gate the render; pass = ship, fail = recut opener)
+
+Long-form (podcast / interview / vlog) variant: same chain, skip write_keyword_captions in favour of write_srt(cues=...) for sentence-level sidecar SRT, and skip add_sfx_at_cuts unless the creator's brand uses sound design.
+
+# Vision-pass workflow ("AI watches the video")
+
+For "find the best/worst shots", "identify blurry takes", "pick a hero frame":
+  1. probe_media(X.mp4)
+  2. score_shot(input=X.mp4, intervalSec=30) — coarse coverage; or use times=[...] for targeted spots
+  3. Inspect top/worst arrays
+  4. For deeper inspection: score_shot(input=X.mp4, startSec=A, endSec=B, intervalSec=5)
+  5. add_marker on findings ("hero frame at 02:13", "weak focus 04:30-05:10")
+Vision is expensive (~85-700 tokens/frame). ALWAYS:
+  - Start coarse (intervalSec=30+ for whole-video), refine into specific windows.
+  - Cap with maxFrames; default 30 is usually enough for a first pass.
+  - Use detail="low" by default; only escalate to "high" when subtlety matters.
+
+# Page-aware guidance (Resolve only)
+
+When host=resolve, switch pages to guide the user's eyes to where work happens:
+- Importing media → open_page("media")
+- Cutting / arranging → open_page("edit") (or "cut" for the Cut page workflow)
+- Color grading / Smart Reframe → open_page("color")
+- Audio mixing → open_page("fairlight")
+- Render → open_page("deliver")
+
+Don't open pages gratuitously. Only when the next step happens on a different page. Premiere has no page concept; skip these calls.
+
+# Skills
+
+Bundled recipes available via read_skill(name=...). Read one when its description matches the user's ask:
+
+${skillLines}
+${stylesBlock}
+# Style
+
+- Be direct. Short messages. No "I will now…" or "Successfully…". Just do it, then state the result.
+- Ask ONLY for ambiguous editorial choices (which take, what pace, what aspect). Never ask about tool mechanics.
+- Surface capability limits early. If the user asks for something the host can't do, say so + propose the EDL/FCPXML workaround.
+`;
+}
+/**
+ * Backward-compatible one-shot builder. Useful for the first render at
+ * startup (cli.ts) or in tests where dynamic refresh isn't needed.
+ *
+ * The TUI should prefer the two-layer API: cache `buildEditorStaticBody`
+ * once, call `buildEditorHostBlock` on host change, splice them together.
+ */
+export async function buildEditorSystemPrompt(host, cwd, options = {}) {
+    const [staticBody, hostBlock] = await Promise.all([
+        Promise.resolve(buildEditorStaticBody(cwd, options)),
+        buildEditorHostBlock(host),
+    ]);
+    return spliceHostBlock(staticBody, hostBlock);
+}
+/**
+ * Replace the `{HOST_BLOCK}` sentinel in a cached static body with a fresh
+ * host block. Throws if the sentinel is missing — that means the static
+ * template is malformed.
+ */
+export function spliceHostBlock(staticBody, hostBlock) {
+    if (!staticBody.includes(HOST_BLOCK_TOKEN)) {
+        throw new Error(`system prompt static body missing ${HOST_BLOCK_TOKEN} sentinel — refusing to ship a prompt without a host section`);
+    }
+    return staticBody.replace(HOST_BLOCK_TOKEN, hostBlock);
+}
+//# sourceMappingURL=system-prompt.js.map

package/dist/system-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../src/system-prompt.ts"],"names":[],"mappings":"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"}

package/dist/system-prompt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=system-prompt.test.d.ts.map

package/dist/system-prompt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.test.d.ts","sourceRoot":"","sources":["../src/system-prompt.test.ts"],"names":[],"mappings":""}

package/dist/system-prompt.test.js

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { NoneAdapter } from "./core/hosts/none/adapter.js";
+import { buildEditorHostBlock, buildEditorStaticBody, buildEditorSystemPrompt, spliceHostBlock, } from "./system-prompt.js";
+/**
+ * The system prompt is split into:
+ *   - a static body (cached for the session — host-independent)
+ *   - a host block (rebuilt on host changes)
+ * spliceHostBlock joins them. These tests pin that contract so future
+ * edits don't accidentally bake host state into the static body or drop
+ * the {HOST_BLOCK} sentinel.
+ */
+describe("buildEditorStaticBody", () => {
+    it("contains the {HOST_BLOCK} sentinel exactly once", () => {
+        const body = buildEditorStaticBody("/tmp", { skills: [], styles: [] });
+        const occurrences = body.match(/\{HOST_BLOCK\}/g) ?? [];
+        expect(occurrences.length).toBe(1);
+    });
+    it("does not bake host name / capabilities into static body", () => {
+        const body = buildEditorStaticBody("/tmp", { skills: [], styles: [] });
+        // Templated host strings would match these patterns; descriptive prose
+        // (e.g. "Resolve only") is fine, but a literal "host=resolve  ok=true"
+        // line means the dynamic snapshot leaked into the static body.
+        expect(body).not.toMatch(/host=resolve\s+ok=/);
+        expect(body).not.toMatch(/host=premiere\s+ok=/);
+        expect(body).not.toMatch(/host=none\s+ok=/);
+        // No `caps: move=... color=...` line either — that's host-block territory.
+        expect(body).not.toMatch(/caps:\s*move=/);
+    });
+    it("includes cwd (it's per-session, but doesn't change mid-session)", () => {
+        const body = buildEditorStaticBody("/Users/test/project", {
+            skills: [],
+            styles: [],
+        });
+        expect(body).toContain("cwd=/Users/test/project");
+    });
+    it("renders skill descriptions when provided", () => {
+        const body = buildEditorStaticBody("/tmp", {
+            skills: [
+                {
+                    name: "test-skill",
+                    description: "a fake skill for testing",
+                    content: "...",
+                    origin: "bundled",
+                },
+            ],
+            styles: [],
+        });
+        expect(body).toContain("test-skill");
+        expect(body).toContain("a fake skill for testing");
+    });
+});
+describe("buildEditorHostBlock", () => {
+    it("emits a host=none block for NoneAdapter (ok=true — file-only ops still work)", async () => {
+        const block = await buildEditorHostBlock(new NoneAdapter());
+        expect(block).toContain("host=none");
+        expect(block).toContain("ok=true");
+        expect(block).toContain("# Host");
+        expect(block).toContain("caps: move=");
+    });
+    it("notes that host identity is dynamic (so the agent doesn't anchor to it)", async () => {
+        const block = await buildEditorHostBlock(new NoneAdapter());
+        expect(block).toMatch(/dynamic|re-detect|host_info/i);
+    });
+});
+describe("spliceHostBlock", () => {
+    it("replaces the sentinel with the host block", () => {
+        const fakeStatic = "above\n{HOST_BLOCK}\nbelow";
+        const fakeHost = "# Host\nhost=resolve";
+        expect(spliceHostBlock(fakeStatic, fakeHost)).toBe("above\n# Host\nhost=resolve\nbelow");
+    });
+    it("throws if the sentinel is missing (refuses to ship a prompt without a host section)", () => {
+        expect(() => spliceHostBlock("no sentinel here", "# Host")).toThrow(/sentinel/);
+    });
+});
+describe("buildEditorSystemPrompt — backward-compat one-shot", () => {
+    it("produces a prompt with both static body and live host block", async () => {
+        const prompt = await buildEditorSystemPrompt(new NoneAdapter(), "/tmp", {
+            skills: [],
+            styles: [],
+        });
+        expect(prompt).toContain("# Host");
+        expect(prompt).toContain("host=none");
+        expect(prompt).toContain("# Tool tiers");
+        expect(prompt).not.toContain("{HOST_BLOCK}");
+    });
+});
+//# sourceMappingURL=system-prompt.test.js.map

package/dist/system-prompt.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.test.js","sourceRoot":"","sources":["../src/system-prompt.test.ts"],"names":[],"mappings":"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"}

package/dist/tools/add-fades.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import type { AgentTool } from "@kenkaiiii/gg-agent";
+declare const AddFadesParams: z.ZodObject<{
+    input: z.ZodString;
+    output: z.ZodString;
+    fadeInSec: z.ZodOptional<z.ZodNumber>;
+    fadeOutSec: z.ZodOptional<z.ZodNumber>;
+    videoCodec: z.ZodOptional<z.ZodString>;
+    crf: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createAddFadesTool(cwd: string): AgentTool<typeof AddFadesParams>;
+export {};
+//# sourceMappingURL=add-fades.d.ts.map

package/dist/tools/add-fades.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-fades.d.ts","sourceRoot":"","sources":["../../src/tools/add-fades.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAIrD,QAAA,MAAM,cAAc;;;;;;;iBAelB,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,OAAO,cAAc,CAAC,CAkEhF"}