@cliangdev/conductor 0.25.0 → 0.26.0

package/assets/claude/commands/conductor/creative.md

@@ -1,6 +1,6 @@
 ---
 name: conductor:creative
-description: One entry point for Conductor creative work — checks the workspace brand, offers to set it up if it's never been configured, asks what to make (static ad, short video, an existing clip), gathers the few inputs needed, then hands off to the conductor-creative skill through render, preview and attach.
+description: One entry point for Conductor creative work — checks the workspace brand, offers to set it up if it's never been configured, asks what to make (static ad, short video, an existing clip), gathers the few inputs needed, then hands off to the conductor-creative skill through draft, preview, approval, commit and attach.
 allowed-tools: mcp__conductor__*, AskUserQuestion, Skill, WebFetch, Read, Glob, Grep
 ---
 
@@ -18,39 +18,10 @@ follow it.
 
 ## Step 1 — Check the brand
 
-Call `get_brand_kit` (pass `kitId` only if the person already named a specific brand).
-
-**If `configured` is `false`**, this workspace has no brand set up yet — offer to fix that before
-making anything:
-
-```json
-{
-  "questions": [{
-    "question": "This workspace's Brand Kit hasn't been set up yet (default colours, no font, no logo). Set it up now?",
-    "header": "Brand Kit",
-    "options": [
-      {"label": "From a website", "description": "Fetch a URL and infer colours, voice and name"},
-      {"label": "From a brand doc", "description": "Read a local file (guidelines, style doc)"},
-      {"label": "Answer a few questions", "description": "Name, colours, font, CTA line, approved lines"},
-      {"label": "Skip for now", "description": "Proceed with the default kit as-is"}
-    ],
-    "multiSelect": false
-  }]
-}
-```
-
-- **From a website**: ask for the URL, `WebFetch` it, infer a plausible accent colour, name, CTA
-  claim and a couple of approved lines from the copy on the page. Show what you inferred and confirm
-  before writing.
-- **From a brand doc**: ask for the file path, `Read` it, extract the same fields, confirm before
-  writing.
-- **Answer a few questions**: ask for name, primary/accent colour (hex or a description you convert),
-  font (if any), the CTA claim, and any lines that must run verbatim. Keep it to one AskUserQuestion
-  batch, not a long interview.
-- Once confirmed, call `update_brand_kit` with whatever was gathered. If a logo file or URL is
-  available, `upload_brand_image` for the `mark` slot at least. Verify with `get_brand_kit` —
-  `configured` should now read `true`.
-- **Skip for now**: proceed; the skill below will render against the default kit as given.
+Read `references/brand-kit-setup.md` in the `conductor-creative` skill
+(`.claude/skills/conductor-creative/references/brand-kit-setup.md`, in this project or under `~/.claude`)
+and follow it: check the Brand Kit, and offer to set it up if it has never been configured. Then
+continue with Step 2.
 
 ## Step 2 — What to make
 
@@ -77,22 +48,43 @@ Keep this light — one or two follow-up questions, not a form:
 
 - **Static ad / short video from a photo**: the headline (or let the skill draft one from the
   Knowledge page), and a photo. Call `list_creative_media({kind: "IMAGE"})` first and offer what's
-  already on hand before asking for a new upload.
+  already on hand before asking for a new photo. A new photo is a local file path (a URL: download it
+  to a local file first) — it is only uploaded after the person approves the preview.
 - **Video from a clip I have / Post an existing video as-is**: call
-  `list_creative_media({kind: "VIDEO"})` first; if nothing fits, ask for a local path or URL.
+  `list_creative_media({kind: "VIDEO"})` first; if nothing fits, ask for a local path (a URL:
+  download it first). A clip used as a MOTION background is previewed from the local file too.
 - **Test a headline variant**: ask which existing Creative (id or display id like `12a`) and the new
   headline.
 
 ## Step 4 — Hand off to the skill
 
 Call `Skill(skill: "conductor-creative")` and follow it from wherever this command's gathering left
-off — angle, copy rules, layout, `create_creative`/`update_creative`, render, look at the result
-honestly, readiness. Don't re-derive what that skill already covers.
-
-## Step 5 — Finish with a render → preview → attach, or a clear next step
-
-Once the skill's readiness check passes: full `render_creative`, `preview_creative` to show the
-result, and `attach_creative_to_post` if there's already a Post to attach it to (ask for the Post's
-id if not obvious from context). If there is no Post yet, say so plainly and name the next step —
-creating one via the `conductor-publisher` skill — rather than leaving the artwork stranded with no
-stated destination.
+off — angle, copy rules, layout, then the draft-first flow: `preview_creative_draft`, look at the
+image, ask for approval, and only then `commit_creative_draft`. Don't re-derive what that skill
+already covers.
+
+## Step 5 — Preview, approve, commit, attach
+
+Nothing is saved to Conductor until the person approves what they have seen:
+
+1. `preview_creative_draft` with what was gathered (local files go in `photoPath`/`clipPath`/
+   `audioPath`; an edit to an existing Creative passes `baseCreativeId`). It renders on this machine
+   and returns the image — no Creative is created and nothing is uploaded.
+2. Read `passed` and `checks` in the result first. The preview runs the full render's per-placement
+   checks (text spill, platform safe zones such as TikTok/Reels' overlay band, contrast, fonts,
+   images), so a design that would fail the real render shows up here. If `passed` is false, fix the
+   design (shorter copy, `layoutOverrides`, `typeOverrides`, a different layout) and preview again
+   **before** showing it or asking anything — never offer Approve & upload while a blocking check
+   fails, and tell the person what you changed. (Bigger or smaller text on one placement is
+   `typeOverrides`, e.g. `{"9x16": [96]}`, not a layout switch.)
+3. Once `passed` is true, look at the image against the skill's checklist, then show it and ask with
+   `AskUserQuestion`: Approve & upload / Request changes / Stop. On changes, preview again; on
+   Stop, leave it — the draft stays local under `.conductor/drafts/`.
+4. On approval, `commit_creative_draft` with the `draftDir`. It uploads the files, saves the
+   Creative and does the full render. (A headline variant is previewed with `baseCreativeId` plus the
+   new headline, but on approval is saved with `create_creative` and `variantOf` — never commit that
+   draft, which would update the original.)
+5. Once the skill's readiness check passes, `attach_creative_to_post` if there's already a Post to
+   attach it to (ask for the Post's id if not obvious from context). If there is no Post yet, say so
+   plainly and name the next step — creating one via the `conductor-publisher` skill — rather than
+   leaving the artwork stranded with no stated destination.

package/assets/claude/skills/conductor-creative/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: conductor-creative
-description: Creates on-brand marketing creative through the Conductor MCP tools — static ads and short videos alike, rendered locally on this machine and checked by eye before it's called done. Covers a photo-plus-headline ad at every enabled placement (e.g. TikTok/Reels 9:16, Instagram feed 4:5, Facebook 1:1); a short video made from a still photo or an existing clip (animated text, zoom/pan, background music, a TikTok/Reels/Shorts-ready cut); posting a finished video as-is; a story or carousel sequence; a lettered headline/hook variant for testing; and, when a workspace's Brand Kit has never been set up, setting one up first (colours, font, logo, copy rules) from a website, a brand doc, or a few direct answers. Use when asked to make, design, write or export a social ad, a promo image, a short-form video, an animated ad, or to configure/update a project's brand.
+description: Creates on-brand marketing creative through the Conductor MCP tools — static ads and short videos alike, rendered locally on this machine as a draft, checked by eye and approved before anything is saved to Conductor. Covers a photo-plus-headline ad at every enabled placement (e.g. TikTok/Reels 9:16, Instagram feed 4:5, Facebook 1:1); a short video made from a still photo or an existing clip (animated text, zoom/pan, background music, a TikTok/Reels/Shorts-ready cut); posting a finished video as-is; a story or carousel sequence; a lettered headline/hook variant for testing; and, when a workspace's Brand Kit has never been set up, setting one up first (colours, font, logo, copy rules) from a website, a brand doc, or a few direct answers. Use when asked to make, design, write or export a social ad, a promo image, a short-form video, an animated ad, or to configure/update a project's brand.
 user-invocable: true
 allowed-tools: mcp__conductor__*, AskUserQuestion, Read, Glob, Grep, WebFetch
 ---
@@ -17,7 +17,13 @@ things that already exist for this workspace — a Brand Kit (data: tokens, copy
 lines) and a Knowledge page (prose: positioning, voice, facts). Read them rather than inventing.
 
 Rendering happens locally, through this MCP server, with a browser on this machine — there is no
-separate render service to wait on. `render_creative` typically finishes in well under a minute.
+separate render service to wait on. A preview typically finishes in well under a minute.
+
+**Draft first, save after approval.** Every Creative here goes draft, look, approve, commit:
+`preview_creative_draft` renders the artwork on this machine and writes **nothing** to Conductor — no
+Creative, no upload — then the person looks at it, and only on their approval does
+`commit_creative_draft` upload the media, save the Creative and do the full render. Never commit a
+draft the person has not seen and approved.
 
 ## How to make a Creative
 
@@ -50,8 +56,8 @@ Prefer an approved line from the Knowledge page verbatim. Otherwise write one th
 real and specific, not a generic claim.
 
 If the Brand Kit's `accentPhraseRequired` is true, mark exactly one phrase per headline with
-asterisks: `Every saved link, *finally usable*.` Never zero, never two — `create_creative` and
-`update_creative` refuse a headline that gets this wrong, naming the rule.
+asterisks: `Every saved link, *finally usable*.` Never zero, never two — `preview_creative_draft`,
+`create_creative` and `update_creative` refuse a headline that gets this wrong, naming the rule.
 
 Keep it short — checked at thumbnail size, not read up close.
 
@@ -69,10 +75,13 @@ uploading a new one — id, dimensions, checked/blocked state and provenance for
 the project's media library. A photo needs `checked: true` and not `blocked` before a Creative can
 go to `READY`.
 
-A new photo goes through `upload_creative_media` (local path or URL), which requires `source` (a
-URL or a short provenance note, e.g. "Generated with a named model on a given date") and `licence`
-(e.g. "Own work", "Unsplash Licence", "Generated, house use"). This closes a real legal exposure: an
-unattributed or unlicensed photo running as paid or organic media.
+A photo that is not in the library yet is previewed straight from its local file (`photoPath` on
+`preview_creative_draft`; a URL is downloaded to a local file first) and is only uploaded when the
+draft is committed — pass `source` (a URL or a short provenance note, e.g. "Generated with a named
+model on a given date") and `licence` (e.g. "Own work", "Unsplash Licence", "Generated, house use")
+to `commit_creative_draft`, which records them on every file it uploads. This closes a real legal
+exposure: an unattributed or unlicensed photo running as paid or organic media. A photo already in
+the library is used by its id (`photoId`) with no upload at all.
 
 **Open the photo and look at it before using it.** A picture can break every copy rule with text,
 a logo or a claim burned into its pixels, and no automated check can see that — this is the first
@@ -83,48 +92,98 @@ Match the crop to the subject: a layout that lays copy over the photo (e.g. `ble
 the top third in collision with the headline — prefer a layout that keeps the photo and copy on
 separate panels (e.g. `stacked`) for those.
 
-### 6. Create, then render
-
-`create_creative` with the Brand Kit (if not the default), layout, theme, photo, headline, body,
-caption and alt text. To test a headline variant of an existing concept, pass `variantOf` with that
-Creative's id instead of starting fresh — it inherits everything else and gets the next letter.
-Then call `get_creative` to verify what was actually stored.
-
-`render_creative` (previewOnly: true first, for a quick contact sheet) runs the render locally and
-returns the render id, state, frame URLs and any warnings. Then `preview_creative` to actually look
-at it — it returns the contact sheet as an image directly, not just a URL to trust.
+### 6. Preview the draft
+
+`preview_creative_draft` with the Brand Kit (if not the default), layout, theme, photo (`photoPath`
+for a local file, `photoId` for one already in the library), headline, body, caption and alt text.
+It renders a contact sheet on this machine and returns it as an image, with the `draftDir` it wrote
+to (`.conductor/drafts/<timestamp>-<slug>/`), the readiness gaps and any render warnings. **Nothing
+has been saved to Conductor.** A copy-rule or accent-phrase violation comes back as an error naming
+the rule and field, without rendering — fix the copy and preview again.
+
+To change an existing Creative's copy, layout or photo, preview the edit first with `baseCreativeId`:
+only the fields you pass change, and the commit then updates that Creative instead of creating one.
+
+To test a headline variant of an existing concept, preview the new headline the same way
+(`baseCreativeId` plus `headline`) so the person sees it on the artwork — but do **not** commit that
+draft, since a commit would update the original. Once they approve, call `create_creative` with
+`variantOf` and the headline instead: it inherits everything else and gets the next letter.
+
+Pass `full: true` to render every placement at full size instead of the contact sheet (slower; the
+image returned is the first placement).
+
+**Read `checks` and `passed` before you show anything.** The contact sheet never runs the render's
+safety checks, so the preview also runs them for every placement (and, for a video, its end card)
+and returns them as `checks: [{placementKey, index?, rule, message, severity}]` plus `passed`. An
+`error` check (`safeZone`, `spill`, `contrast`, `font`, `image`, ...) is exactly what would fail the
+full render after the person approved: e.g. an App Store badge intruding into the band TikTok/Reels
+reserve on 9:16. A `warning` (a soft, upscaled photo) does not block, but mention it.
+
+When `passed` is false, **do not show the image or ask for approval yet.** Fix the design and
+preview again, repeating until `passed` is true:
+
+- the copy collides with a reserved zone: shorten the headline or drop the body;
+- the photo takes too much of a placement: lower its height there with `layoutOverrides.band`
+  (e.g. `{"band": {"9x16": 1100}}`);
+- the bottom row (CTA/badge) does not clear the safe zone: raise the clearance with
+  `layoutOverrides.padBottom`, or pick a layout that keeps it clear;
+- the text is too large or too small for a placement: set it with `typeOverrides` (below).
+
+Tell the person what you changed and why when you do show it. Never offer **Approve & upload**
+while a blocking check fails.
+
+**Bigger or smaller text on one placement: use `typeOverrides`, not a different layout.** It pins
+the headline per placement as `{"<placementKey>": [fontSize, lineHeight?, letterSpacing?]}`, e.g.
+`{"9x16": [96], "1x1": [88]}` for a bigger headline on 9:16 and 1:1. `fontSize` is in artboard px
+(a 9:16 board is 1080 wide), `lineHeight` a multiplier (e.g. `1.0`) and `letterSpacing` in px
+(usually negative); leave the last two out to take the engine's defaults for that size. A placement
+you do not name stays auto-fitted. A pinned size is not shrunk to fit, so re-check `checks` after
+setting one. It works on `preview_creative_draft` and `create_creative`/`update_creative`; changing
+the headline or layout of a saved Creative clears pinned sizes unless you send them again.
 
 ### 7. Look at the result honestly
 
-**A successful render proves the frame is structurally correct, not that the ad is good.** Its
-in-page checks catch text spilling out of a safe zone, a font that failed to load, a photo that
+**Passing checks prove the frame is structurally correct, not that the ad is good.** The checks
+(`passed: true`) catch text spilling out of a safe zone, a font that failed to load, a photo that
 never decoded, or contrast below the accessible minimum — not whether the headline reads at a
 glance, whether the accent phrase falls on the words that carry the meaning, or whether the copy is
-sitting on the subject's face. Judge those yourself from the image `preview_creative` hands back. If
-the copy collides with the photo, switch layout (see step 5) and re-render rather than shrinking
-text until it technically fits.
+sitting on the subject's face. Judge those yourself from the image `preview_creative_draft` hands
+back. If the copy collides with the photo, switch layout (see step 5) and preview again rather than
+shrinking text until it technically fits.
+
+Only once `passed` is true, show the image to the person and ask with `AskUserQuestion` —
+**Approve & upload**, **Request changes**, **Stop**. If `passed` is false you are not at this step
+yet: fix it and re-preview first (step 6). On changes, preview again with the edits (another draft; nothing was saved). On
+Stop, leave it: the draft stays on this machine under `.conductor/drafts/` and is cleaned up
+automatically once it is committed or two weeks old. Only on **Approve & upload**, call
+`commit_creative_draft({draftDir})` with the `draftDir` the approved preview returned.
 
 ### 8. Check readiness before calling it done
 
-`get_creative` includes a `readiness` block: caption, alt text, the photo's checked/blocked state
+The preview already lists the readiness gaps, so fix what you can (caption, alt text, a checked
+photo) before asking for approval. After the commit, `get_creative` includes a `readiness` block: caption, alt text, the photo's checked/blocked state
 and provenance, and the Creative's own state (not `DRAFT`) are blocking; an AI-generation disclosure
 is informational only. Do not call a Creative done while `ready` is false.
 
-### 9. Render for real, then hand off
+### 9. Commit, then hand off
 
-Once the preview looks right, `render_creative` again with `previewOnly: false` (or omitted) for the
-full-size placement frames, then `attach_creative_to_post` with the Post's Work Item id — it maps
-each placement to the right destinations (9:16 to TikTok/Reels, 4:5 to Instagram feed, 1:1 to
-Facebook, story to story targets) for every destination that has not set its own custom media, and
-never touches one that has. Verify with `get_post_status`. From here, use the `conductor-publisher`
-skill for scheduling, review and publishing — this skill's job ends at attaching the artwork.
+`commit_creative_draft` uploads the draft's local files, creates the Creative (or updates
+`baseCreativeId`'s), and runs the full-size render in one call, then returns the Creative id and
+display id, the frames and the readiness. It can be run once per draft; if its render fails the
+Creative is already saved — call `render_creative`, don't commit again. Verify with `get_creative`.
+Then `attach_creative_to_post` with the Post's Work Item id — it maps each placement to the right
+destinations (9:16 to TikTok/Reels, 4:5 to Instagram feed, 1:1 to Facebook, story to story targets)
+for every destination that has not set its own custom media, and never touches one that has. Verify
+with `get_post_status`. From here, use the `conductor-publisher` skill for scheduling, review and
+publishing — this skill's job ends at attaching the artwork.
 
 ## Making a sequence instead of a single ad
 
 For a platform surface that's tapped or swiped through, set `sequenceKind` to `story` (2 to 7
-beats, aim for 3 to 5) or `carousel` (2 to 10 cards, 5 to 7 performs best) on `create_creative` or
-`update_creative`, with a `sequence` array. Each beat inherits the Creative and overrides only its
-own `headline`, and optionally `body`, `photoId` or `cta`. Structure a story hook, mechanism,
+beats, aim for 3 to 5) or `carousel` (2 to 10 cards, 5 to 7 performs best) on
+`preview_creative_draft` (then `commit_creative_draft`), with a `sequence` array. Each beat inherits
+the Creative and overrides only its own `headline`, and optionally `body`, `photoPath` (a local
+photo, uploaded on commit) or `photoId`, or `cta`. Structure a story hook, mechanism,
 payoff — the first beat has to earn the next tap on its own, since that's where the drop-off is
 worst. A logo lockup and CTA claim land on the last beat only by default; `cta: true` on an earlier
 beat overrides that. A carousel renders every card at one shared aspect ratio (`carouselRatio`),
@@ -136,6 +195,9 @@ Not every video needs the brand layout above — a finished clip (a demo recordi
 something a person or another tool already produced) can go up as-is. That's a CLIP Creative: no
 photo, headline or layout, just the video.
 
+A CLIP has no artwork to render, so it is the one flow without a draft preview: open the video
+itself and check it with the person before uploading.
+
 1. Check `list_creative_media({kind: "VIDEO"})` for a clip already in the project before uploading a
    new one. A new one goes through `upload_creative_media` (local path or URL) — same provenance
    fields as a photo (`source`, `licence`, `aiGenerated`). It detects video vs. audio vs. photo
@@ -162,10 +224,11 @@ of a static frame — no separate video tool needed. Use it when a still doesn't
 destination rewards video over an image.
 
 1. Pick a photo (step 5) or, for a moving background, a video — check `list_creative_media({kind:
-   "VIDEO"})` first, then `upload_creative_media` only if nothing already fits — and note its media
-   id. For background music, `list_creative_media({kind: "AUDIO"})` the same way before uploading a
-   new track.
-2. `create_creative`/`update_creative` with `kind: "MOTION"` plus:
+   "VIDEO"})` first and use its media id if something fits; otherwise pass the local file as
+   `clipPath` (previewed from disk, uploaded on commit). For background music,
+   `list_creative_media({kind: "AUDIO"})` the same way, else `audioPath`.
+2. `preview_creative_draft` with `kind: "MOTION"` (to change a saved MOTION Creative, `baseCreativeId`
+   instead) plus:
    - `motion.preset` — how the copy enters: `fade-up` (default), `word-by-word`, `accent-pop`, or
      `none` (everything visible from the first frame).
    - `motion.durationSec` — 3 to 60, default 8.
@@ -177,13 +240,13 @@ destination rewards video over an image.
    - `audio` — `source: "clip"` (the background clip's own recorded sound — the default when there
      is one), `"track"` (a separate library track: `trackId` from `upload_creative_media`, plus
      `volume` and `fadeOutSec`), or `"none"`.
-3. `render_creative` runs a local, ffmpeg-driven encode — roughly 20 seconds per placement for an
-   8-second video. No ffmpeg on this machine fails with a clear message naming how to get one rather
-   than silently producing nothing.
-4. `preview_creative` renders three key moments across the timeline into one sheet image (not the
-   finished video). Judge it the same honest way as step 7 above — does the copy's entrance finish
-   before the next beat, does the end card actually hold long enough to read — before spending a
-   full render on it.
+3. The preview renders three key moments across the timeline into one sheet image (not the finished
+   video). Judge it the same honest way as step 7 above — does the copy's entrance finish before the
+   next beat, does the end card actually hold long enough to read — and get approval before
+   spending a full render on it.
+4. `commit_creative_draft` then uploads the media, saves the Creative and runs the local,
+   ffmpeg-driven encode — roughly 20 seconds per placement for an 8-second video. No ffmpeg on this
+   machine fails with a clear message naming how to get one rather than silently producing nothing.
 5. `attach_creative_to_post`, same as any Creative — one MP4 per placement.
 
 A library music track's `licence` has to be recorded on upload (same as a photo's provenance) — the
@@ -203,6 +266,9 @@ Automated checks are real but incomplete. These are the ones worth remembering t
 - **A Brand Kit with no copy rules, or no accent-phrase requirement, never fails a save on that
   account.** That is permissive by design, not a bug — but it means the model, not the platform, is
   the only check on brand voice for that workspace until someone configures rules.
+- **A draft is not a saved Creative.** `preview_creative_draft` writes nothing to Conductor, so a
+  Creative or media id does not exist until `commit_creative_draft` runs — don't hand a draft's
+  folder to `attach_creative_to_post` or a Post.
 - **A stale write is refused, not silently overwritten.** `update_creative` requires the Creative's
   current `version`; a mismatch comes back as a 409 naming the conflict rather than clobbering a
   concurrent edit — reread with `get_creative` and reapply, don't retry blind.

package/assets/claude/skills/conductor-creative/references/brand-kit-setup.md

@@ -0,0 +1,41 @@
+# Brand Kit check and setup
+
+Shared by `/conductor:creative` and the `conductor-creative` skill: check whether this workspace's
+Brand Kit has been set up, and offer to set it up if not. The text below is the command's Step 1,
+unchanged.
+
+## Step 1 — Check the brand
+
+Call `get_brand_kit` (pass `kitId` only if the person already named a specific brand).
+
+**If `configured` is `false`**, this workspace has no brand set up yet — offer to fix that before
+making anything:
+
+```json
+{
+  "questions": [{
+    "question": "This workspace's Brand Kit hasn't been set up yet (default colours, no font, no logo). Set it up now?",
+    "header": "Brand Kit",
+    "options": [
+      {"label": "From a website", "description": "Fetch a URL and infer colours, voice and name"},
+      {"label": "From a brand doc", "description": "Read a local file (guidelines, style doc)"},
+      {"label": "Answer a few questions", "description": "Name, colours, font, CTA line, approved lines"},
+      {"label": "Skip for now", "description": "Proceed with the default kit as-is"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+- **From a website**: ask for the URL, `WebFetch` it, infer a plausible accent colour, name, CTA
+  claim and a couple of approved lines from the copy on the page. Show what you inferred and confirm
+  before writing.
+- **From a brand doc**: ask for the file path, `Read` it, extract the same fields, confirm before
+  writing.
+- **Answer a few questions**: ask for name, primary/accent colour (hex or a description you convert),
+  font (if any), the CTA claim, and any lines that must run verbatim. Keep it to one AskUserQuestion
+  batch, not a long interview.
+- Once confirmed, call `update_brand_kit` with whatever was gathered. If a logo file or URL is
+  available, `upload_brand_image` for the `mark` slot at least. Verify with `get_brand_kit` —
+  `configured` should now read `true`.
+- **Skip for now**: proceed; the skill below will render against the default kit as given.

package/assets/cli-manifest.json

@@ -171,7 +171,7 @@
       },
       {
         "name": "conductor:creative",
-        "description": "One entry point for creative work \u2014 checks the workspace brand (offers to set it up if unconfigured), asks what to make (static ad, short video, an existing clip), then hands off to the conductor-creative skill through render, preview and attach."
+        "description": "One entry point for creative work \u2014 checks the workspace brand (offers to set it up if unconfigured), asks what to make (static ad, short video, an existing clip), then hands off to the conductor-creative skill through draft, preview, approval, commit and attach."
       }
     ],
     "agents": [
@@ -195,7 +195,7 @@
       },
       {
         "name": "conductor-creative",
-        "description": "Makes a Creative end to end, static or short video: sets up the Brand Kit if unconfigured, reads it and its Knowledge page, picks media and an angle, creates the Creative, renders and looks at the result, fixes what's wrong, then hands it to conductor-publisher."
+        "description": "Makes a Creative end to end, static or short video: sets up the Brand Kit if unconfigured, reads it and its Knowledge page, picks media and an angle, previews a draft locally and shows it for approval before anything is saved, commits it, fixes what's wrong, then hands it to conductor-publisher."
       }
     ]
   },
@@ -781,7 +781,7 @@
     },
     {
       "name": "upload_creative_photo",
-      "description": "Deprecated alias for upload_creative_media — same behavior, including for video/audio.",
+      "description": "Deprecated alias for upload_creative_media \u2014 same behavior, including for video/audio.",
       "category": "marketing"
     },
     {
@@ -800,6 +800,19 @@
         "creativeId"
       ]
     },
+    {
+      "name": "preview_creative_draft",
+      "description": "Look at a Creative before anything is saved: renders a draft locally from the create_creative fields plus local files (photoPath, clipPath, audioPath) and returns the contact sheet as an image. Never writes to Conductor; commit only after the person approves.",
+      "category": "marketing"
+    },
+    {
+      "name": "commit_creative_draft",
+      "description": "Save an approved draft: uploads its local files, creates (or updates) the Creative, and renders the real frames. The first write to Conductor; a draft commits once. Call get_creative to verify.",
+      "category": "marketing",
+      "requiredParams": [
+        "draftDir"
+      ]
+    },
     {
       "name": "attach_creative_to_post",
       "description": "Attach a Creative's rendered frames to a Post as its media, placement to platform, for every destination without its own custom media. Call get_post_status (postId) to verify.",

package/dist/creative/assertions.js

@@ -121,12 +121,23 @@ function sameRgb(a, b) {
 export async function runAssertions(board, placement, brand, { outputScale = 2 } = {}) {
   const errors = [];
   const warnings = [];
+  // The same findings with a stable `rule` id each, for callers (the draft preview) that report them
+  // structured. `errors` / `warnings` stay plain message arrays, exactly as before.
+  const checks = [];
+  const fail = (rule, message) => {
+    errors.push(message);
+    checks.push({ rule, severity: 'error', message });
+  };
+  const warn = (rule, message) => {
+    warnings.push(message);
+    checks.push({ rule, severity: 'warning', message });
+  };
   const br = rectOf(board);
 
   const nodes = [...board.querySelectorAll(CHECKED_SELECTOR)].map((n) => ({ name: n.className, rect: rectOf(n) }));
 
   const spill = spillDetect(br, nodes);
-  if (spill.length) errors.push(`text spill: ${spill.join('; ')}`);
+  if (spill.length) fail('spill', `text spill: ${spill.join('; ')}`);
 
   const safe = {
     top: Number(board.dataset.safeTop) || 0,
@@ -134,19 +145,19 @@ export async function runAssertions(board, placement, brand, { outputScale = 2 }
     right: Number(board.dataset.safeRight) || 0,
   };
   const intrusion = safeZoneIntrusion(br, nodes, safe);
-  if (intrusion.length) errors.push(`safe-zone intrusion: ${intrusion.join('; ')}`);
+  if (intrusion.length) fail('safeZone', `safe-zone intrusion: ${intrusion.join('; ')}`);
 
   if (brand && brand.fontFamily) {
     const headlineEl = board.querySelector('.cc-headline');
     const size = Math.round(parseFloat(getComputedStyle(headlineEl).fontSize)) || 16;
     if (!document.fonts.check(`800 ${size}px "${brand.fontFamily}"`)) {
-      errors.push(`font "${brand.fontFamily}" did not load (would export in a fallback face)`);
+      fail('font', `font "${brand.fontFamily}" did not load (would export in a fallback face)`);
     }
   }
 
   const imgs = [...board.querySelectorAll('img')];
   const broken = imgs.filter((i) => !i.complete || i.naturalWidth === 0).map((i) => i.getAttribute('src'));
-  if (broken.length) errors.push(`image(s) failed to load: ${broken.join(', ')}`);
+  if (broken.length) fail('image', `image(s) failed to load: ${broken.join(', ')}`);
 
   // A bleed/card layout paints its photo as a CSS background, invisible to
   // the <img> check above — probe it directly, the same way a typo'd path
@@ -161,11 +172,11 @@ export async function runAssertions(board, placement, brand, { outputScale = 2 }
       img.src = bgUrlMatch[1];
     });
     if (!probe.ok) {
-      errors.push(`background photo failed to load: ${bgUrlMatch[1]}`);
+      fail('image', `background photo failed to load: ${bgUrlMatch[1]}`);
     } else if (placement && probe.w < placement.w * outputScale && probe.h < placement.h * outputScale) {
       // Soft photography check: a source smaller than the output frame (2x for images, 1x for video) is
       // upscaled, so the photo goes soft while the text stays crisp.
-      warnings.push(`photo is ${probe.w}x${probe.h}, upscaled to fit ${placement.w * outputScale}x${placement.h * outputScale}`);
+      warn('photoResolution', `photo is ${probe.w}x${probe.h}, upscaled to fit ${placement.w * outputScale}x${placement.h * outputScale}`);
     }
   }
 
@@ -176,9 +187,9 @@ export async function runAssertions(board, placement, brand, { outputScale = 2 }
     const expectedRaw = getComputedStyle(board).getPropertyValue('--cc-accent').trim();
     const expectedRgb = expectedRaw ? resolveCssColor(expectedRaw) : null;
     if (!emRgb) {
-      errors.push('accent colour did not resolve on the headline');
+      fail('accent', 'accent colour did not resolve on the headline');
     } else if (expectedRgb && !sameRgb(emRgb, expectedRgb)) {
-      errors.push(`accent colour unresolved: headline em is ${getComputedStyle(em).color}, brand accent resolves to ${expectedRaw}`);
+      fail('accent', `accent colour unresolved: headline em is ${getComputedStyle(em).color}, brand accent resolves to ${expectedRaw}`);
     }
   }
 
@@ -207,15 +218,15 @@ export async function runAssertions(board, placement, brand, { outputScale = 2 }
     if (fgRgb && bgRgb) contrast = contrastRatio(fgRgb, bgRgb);
   }
   if (contrast !== null && contrast < 3) {
-    errors.push(`headline contrast is ${contrast}:1 against its background, below the 3:1 floor for large text`);
+    fail('contrast', `headline contrast is ${contrast}:1 against its background, below the 3:1 floor for large text`);
   }
 
   const boxRect = board.getBoundingClientRect();
   const width = Math.round(boxRect.width);
   const height = Math.round(boxRect.height);
   if (placement && (width !== placement.w || height !== placement.h)) {
-    errors.push(`artboard is ${width}x${height}, expected ${placement.w}x${placement.h}`);
+    fail('size', `artboard is ${width}x${height}, expected ${placement.w}x${placement.h}`);
   }
 
-  return { errors, warnings, contrast, width, height };
+  return { errors, warnings, checks, contrast, width, height };
 }

package/dist/creative/frame.js

@@ -15,7 +15,7 @@
  *   }
  *
  * Result contract:
- *   window.__RENDER_RESULT = { ok, errors?, warnings?, width, height } | { ok: false, error }
+ *   window.__RENDER_RESULT = { ok, errors?, warnings?, checks?, width, height } | { ok: false, error }
  *   window.__ready = true   // set exactly once, success or failure, when the
  *                           // job's page.waitForFunction should stop waiting
  *
@@ -108,8 +108,8 @@ async function main() {
       return;
     }
 
-    const { errors, warnings, width, height } = await runAssertions(board, placement, spec.brand || {});
-    finish({ ok: errors.length === 0, errors, warnings, width, height });
+    const { errors, warnings, checks, width, height } = await runAssertions(board, placement, spec.brand || {});
+    finish({ ok: errors.length === 0, errors, warnings, checks, width, height });
   } catch (err) {
     finish({ ok: false, error: String((err && err.message) || err) });
   }