Takes for Mac

Put b-roll clips into a session's broll/ folder (an APFS clone: no extra disk space), so they show on its Assets tab next to the takes. Use the file from list_broll.

Say a clip again in another voice with the ElevenLabs voice changer: same words, timing and emotion. The user acts the line, a character voice comes out. Whole file or start/end (at most 5 minutes); writes generated/<file>-<voice>-vN.wav, and an .mp4 with the video for a video.

Check each new edit before you show it. It compares the edit with its take: sound, picture, sync, cut words, undone fixes, rules with a check. Fix each failure in a new version and check that. pass null: did not run (skip says why). A failure looks wrong: tell the user its say. review: with a Gemini key, Gemini watches the edit with the rules (about 5 cents, cached per version); without one, a frame sheet for you to look at. Follow review.note.

Make a take's voice sound like a proper mic (the user's voice-cleanup: room echo, noise, clipping, hum, then EQ, compressor and loudness). The first call starts it in the background (about 15-60 s per minute of audio); get_session then shows 'voice' under the take, with 'file' when it is done: use that WAV as the take's voice in edits instead of the audio in the .mov. Later calls only change the settings (instant). The user sets the same in the app's player.

Copy library files from one library to another: 'style:<Name>' or a project name (copy to a new 'style:<Name>' to start a new style from an old one). items are paths inside the library (README.md, tokens.json, assets/Logos/mark-v2.svg); omit for everything. tokens.json merges by token name; other existing files are skipped, never overwritten. move=true trashes the copied files in the source.

Add other versions of the session's LinkedIn or X post (e.g. 'Story first', 'Shorter', 'Single tweet'). The app shows them as tabs above the post preview; the user compares, edits, comments and picks one with 'Use as main'. Only the main post is scheduled. Write the main post with set_post first. Edit a variant later with set_post variant=<slug>. For different openings of the same post use set_post_hooks.

Create a project (a folder in the Takes library).

Create a recording session with a title and the script to read on the teleprompter, optionally with variants. Offers it in the Takes app unless open=false (see open_in_app).

Start a new style from an example the user gives: a link, a video, an image, or words. Makes the style folder (status new) and returns the steps: study the source, write the guide and tokens, build the parts, render the preview. The user compares it with the other styles on the Styles board and keeps or trashes it.

Add alternative versions of the script (e.g. 'Punchy hook', 'Story first'). Each shows up as a tab above the teleprompter; the user can read any of them and pick one as main. Use this instead of overwriting the main script when offering options.

Cut takes into one clip: video at a constant frame rate, the voice in sync, and word times for the clip. It is the default for a cut of a take: it fixes the take's audio offset and frame rate, moves a cut point that falls inside a word to the word's edge (listed in 'moved'), and uses the take's clean voice when clean_voice is done. For what it cannot do (a J/L cut, a speed change, a cut inside a word, an effect), use your own ffmpeg on its clip and .wav, or on the take with get_session's audio_offset_s, and tell the user what you did. set_best_cut only marks a range; cut_take makes the video. Writes _work/<name>-vN.mp4, .wav (voice only) and .words.json in the session. A short cut comes back done; a long one returns a job.

Move post variants to the macOS Trash (their text stays in post history).

Move variants to the macOS Trash (their text stays in history).

Design a new ElevenLabs voice from a description ('warm German woman, 40s, calm, slow'): writes three samples (generated/voice-<name>-1..3.mp3 with session, else _library/voices/) for the user to hear on the Assets tab. Then save the pick: save=<the sample's save id> with name.

Correct what was said in a take or clip: ElevenLabs says the new words in the voice (default: The user's default voice, often a clone) with the sentences around them for the same tone, and Takes cuts them in at the word edges with the take's cleaned voice when there is one. old = the words as said (from the transcript; Takes transcribes the file first when it has no <stem>.words.json), or start/end in seconds. Writes generated/<file>-fix-vN.wav, plus an .mp4 with the video when the new words fit the old time (speed 0.8-1.25x), so the take's times still hold. The lips do not move with the new words: say so when the fix is on camera.

The user's review comments in a session or a library (pass library, not session). Video: 'when' (start/end s), an optional rect (x,y,w,h fractions from top left) and a 'frame' PNG with the area outlined in orange: read it to see what the comment means; 'said' quotes the words spoken then (from the video's transcript). Image: rect + frame. Text (script, variant, README.md, tokens.json): 'quote' is the selected text. Default: open comments.

The recipe of an edit: how it was made (cut list, voice, layers, music, sfx, cover, checks, the exact commands) and the versions before it. get_session shows a short form of the newest one.

A job's status (starting, running, done, failed, stopped, lost), progress, time left, last log lines, exit code and files. wait_s waits for the end in this call (other takes tools wait too); call again to keep waiting. With session and no id: the running jobs and those that ended in the last day.

Read the style a video uses: The user picks one of the named styles per video or per project (e.g. Magazine), and the project library adds to it. Returns the style's name and 'template', the style library and the project library (README.md style guide, tokens.json colours/type/spacing/radius, assets by group with every version, fonts, open comment counts) and the merged tokens. Without project: the list of styles. Read it before you design anything: a thumbnail, captions, a motion graphic, a slide.

The user's posting plan: the weekdays to post, the slots in the next 14 days, which are empty (next_gap), the buffer (covered slots before the first empty one) and ready posts with no time yet. Use it to tie a new take or edit to the slot it can fill, and to suggest a time when the user marks a post ready. No plan yet: ask the user which days, then set_plan.

The posting plan: every LinkedIn and X post the user marked ready or that is scheduled, across all projects, sorted by time. Each has platform, session, title, text (X: also 'tweets'), media_path (the video to upload), status, at (iso, utc, local in the chosen tz, this_mac = the Mac's zone, which LinkedIn's scheduler uses) and 'action': what to do on that platform now (schedule, move, replace text, delete, or nothing). The user sets the times with [schedule] on the post tab, or asks you to pick them.

The rules learned from the user's comments, one file per step: plan (storyboard, script), make (sound, cut, picture, captions, graphics), package (thumbnail), publish (post-all, post-linkedin, post-x, post-youtube, post-vertical), engage (comments) and other. Read and follow the steps you work on before you write, edit or design. get_session and next_path show new ones once per chat; a write tool shows unseen ones once. Without area: the steps with rule counts (full=true at 10).

Get the full text of one saved version.

Get a session: its id, title, full script, and every take with file path, duration, keeper flag, name and start time (camera and screen files of one take share a number), plus every asset file (edits/, thumbnails/, stills/, assets/), the folder rules ('folders') and 'warnings' about files in the wrong place: fix those. Each take shows edit_ready (word times are ready). Cut takes with cut_take and rough_cut by default: they fix the audio offset and frame rate. checks: the check_edit state of each newest edit. rules: the rules for the session's next step that this chat has not seen yet; follow them.

Make or change a video with Higgsfield (Seedance, Kling, Veo and 30+ more video models) from inside Takes. Video only: images go to make_image. Returns at once; the job runs in the background and the file lands in <session>/generated/<name>-vN, where the Assets tab shows it. With shot=<id> the storyboard shot shows 'Generating' and then plays the clip (aspect ratio = the storyboard format, length = the shot's length, 4-15 s). For a shot, write a real-footage prompt from the shot's do and say (subject, setting, light, camera move); pass image='sketch' to use the sketch only as a composition reference with params {mode: omni_reference}, and say in the prompt that the result is real footage, not a drawing. Change a video: video=<session file> with params {mode: video_edit} (Seedance), or workflow=reframe with aspect_ratio for a new shape. Default model: the one the user picked on Plugins › Higgsfield (higgsfield_status default_model); other models by id (`higgsfield model list` in Bash; `higgsfield model get <id>` for params). Each job costs the user's Higgsfield credits: one job per ask, never a batch nobody asked for. Not installed or not signed in: tell the user to open Plugins › Higgsfield.

Is Higgsfield installed and signed in, and how many credits are left; with session, its Higgsfield jobs (running, done, error).

Add recordings that already exist (e.g. from QuickTime, a phone, a download, or files placed in the session folder) to a session as takes. Never edit session.json by hand: this names the file take-NN-[name-]camera.<ext>, gives it the next take number, reads its length and lists it. One take: path (+ screen_path for its screen recording). Several: takes=[{path, screen_path, name, keeper}], one take each, in order. Files outside the session are copied (move=true moves them); files already in the session folder are renamed in place.

List the user's own b-roll (_library/broll/<folder>/): self-filmed clips at the desk, hands typing, reactions, lifestyle, outdoor. Each has title, folder, filmed (YYYY-MM), orientation, duration, description, keywords and path. Use it for B-ROLL shots in a storyboard or an edit before asking the user to film new b-roll. The user browses the same clips on the app's B-roll tab.

List the user's music and sound effects (_library/audio/Music, SFX, ...): file, title, artist, genre, bpm, duration, path. New downloads in the source folder (Epidemic Sound) are copied in first. Use for picking a song or an SFX for an edit. SFX are short effects (whoosh, pop, typing, notification). Mix songs and effects into a new version of the edit with ffmpeg, under the voice: the app plays only the file, never a song or an effect beside it. The app's Use button asks you for this.

List Takes projects and how many sessions each has. Start here.

List sessions in a project, newest first, with take and keeper counts.

Make or change an image straight from Google or OpenAI (much cheaper than a Higgsfield image: never use higgsfield for images). Drafts first, final last: while the user finds the direction, draw with GPT Image (fast, 1536 px at most): flare (GPT Image 2.5 Flare, the default for a new image) or sunburst (GPT Image 2.5 Sunburst, the default for a change or with references). When the user likes a draft, make its final: from=<that draft> redraws it with Nano Banana 2.1 at 4K, the newest and sharpest, with the draft and its references as the guide and the same prompt (add one only for a change). Never make a final before the user picks. When one model fails the next one draws. Waits about 10-60 s and returns the file, <session>/generated/<name>-vN.png, and the model that drew it; the Assets tab shows both. Change an image: images=[session files] (a thumbnail, a still, 'sketch' with shot=<id>) and say what to change. One image per ask.

Move sessions to another project (created if missing).

The path for a new file: the right folder and the next version. kind=edit: <session>/edits/<name>-vN.mp4. kind=thumbnail: <session>/thumbnails/<name>-vN.png (the edit's name, plus an option word for several). kind=library: <library>/assets/<group>/<name>-vN.<ext>. Call it before you write any of these. For edit and thumbnail it also gives the user's rules for that step once per chat: follow them.

Offer the user a project, session or file (e.g. a new edit) in the Takes app. It never takes focus or plays anything: the session gets a dot and opens only on a click. Once per finished result, not for drafts or in-between steps.

The videos the user AirDropped from an iPhone that wait in ~/Downloads (AirDrop or iPhone recordings only; all=true for every video), oldest first, with length, recording time and, with listen=true, the first words said (Whisper, about 10 s per video). Also lists the newest sessions with the start of each script, so you can match each video to its session and import_take it with move=true.

Put a session's video card on a day of the user's Plan board (the calendar in Takes), move it to another day, or take it off (day empty). Use it when the user asks you to plan videos; one call per video. A card shows the session's title and thumbnail; the user drags cards to reorder them. A card covers that day's posting slot as planned; a post with a time fills it. The board grows to show the card's week. Returns get_plan.

Every saved version of the post and its variants, newest first: version, draft ('main' or a variant slug), author (user or claude), note, created, preview. Pass version to get its full text, e.g. to compare with the current post. A version is saved on every change by Claude and while the user edits.

Make a variant the main script. The old main stays in history.

Save a checked render as the next version, edits/<name>-vN.mp4, with its recipe. In one call: reads the checks the render ran (it refuses on a failed check; accept=[{rule, why}] for a fail you meant), puts the version on the posts that follow this edit (a version the user picked stays), answers the review comments it fixes (replies: like reply_comment; fixed_in and resolve are set for you) and saves note as the changelog line. Call it once per version. To show another file on a post, call set_post media=... after. Its review (Gemini watched it, or a frame sheet when there is no key) is for the next version: follow review.note.

Name a take. Its files become take-NN-<name>-camera.mov / -screen.mov. Empty name resets.

Build an edit from a recipe, as a job, and check it. First version: recipe={name, cut} (cut = rough_cut's cut) plus what you need: frame {shape '9:16'|'16:9'|'1:1'|'4:5'|'source', crop}, over (picture layers: alpha graphics or b-roll, with at/in/out), music and sfx (file, at, gain_db), steps (commands that make the layers, run in _edit/<name>/), cover (a thumbnail). Next version: base=<name> and changes (a JSON merge patch on the newest recipe; a list replaces the whole list; {"name": "hook-vertical"} starts a new line). Takes uses the clean voice once and never uses a finished edit as an input. One render of a name runs at a time: to compare two options, give the second a new name. Returns a job; then publish_edit.

Make or change a video on Replicate: the same models as Higgsfield (Seedance 2.5, Kling, Veo, ...) at a price per second of video, no plan. Returns at once; the job runs in the background and the file lands in <session>/generated/<name>-vN.mp4, where the Assets tab shows it. model: owner/name; leave it out for the user's default (replicate_status lists the default models, the first is the default; pick another of them when it fits better). Takes maps prompt, image (the FIRST FRAME), end_image, video, duration, aspect_ratio, resolution and audio to the model's own input names; anything else goes in params by the model's names (call replicate_model first to see its inputs, defaults and allowed values). File inputs, in those fields or params, take a session file, a take number or 'sketch' (the shot's sketch); Takes uploads them. With shot=<id> the storyboard shot shows 'Generating' and then plays the clip (aspect ratio = the storyboard format, length = the shot's length, 4-15 s). For a shot, write a real-footage prompt from the shot's do and say; never use the sketch as the first frame (the video would look drawn): pass it only to a reference-image input if the model has one. Each job costs the user money: one job per ask, never a batch nobody asked for. No token: tell the user to open Plugins › Replicate.

A Replicate model's inputs (type, default, allowed values, what each does), so a job can set what the user asks for. Leave model out for the default.

Is a Replicate token set, which account, the user's default video models; with session, its Replicate jobs (running, done, error).

Reply to review comments and resolve them. After a round of fixes, send ONE call with replies=[{id, text, resolve, fixed_in, fixed_at, lesson}] for every comment. fixed_in: the new version's file; fixed_at: the second in it where the fix shows (a click on the reply jumps there). text: one line ('Caption 20% smaller'). Unclear comment: ask a question, resolve omitted. In a session each resolved comment needs a lesson: a rule id from get_rules, with missed=true when the edit broke that rule (the same mistake again) or missed=false for a new ask or taste near it; 'new' with rule={area, text} (it applies to the next videos too); else 'one-off'.

Put an old version back (into its variant if it still exists, else the main post). The current text is saved to history first.

Put an old version back (the current text is saved to history first).

Make a first cut of the takes against script.md: each script line once (the last full try), without false starts, stutters, ums and pauses longer than gap. A take with a best cut uses only that range. Returns the clip (like cut_take) plus dropped (each with why) and missing (script lines no take has). Show the user the clip and tell them what you dropped and what is missing. It is only a first draft: improve it freely (edit cut and call cut_take; see cut_take for your own ffmpeg).

Run slow work (a render, Demucs, Whisper, matting, any command over about 30 s) in Takes, never as a background Bash job or with sleep. Returns a job id at once. The job outlives the chat and Takes, and shows its progress in the session's Jobs row. cmd runs in zsh in the session folder. The result's note says how to wait.