gooseworks 0.4.4 → 0.4.5-dev.15.facf60fb

package/skills/make-custom-video/SKILL.md

@@ -3,7 +3,7 @@ name: make-custom-video
 slug: make-custom-video
 description: Connect the shared video production harness to GooseWorks projects, script and ingredient approvals, managed media generation, budgets and final delivery. Use for original briefs, Instagram/video references and resumed custom projects.
 category: ads
-version: 2.2.0
+version: 2.4.0
 author: GooseWorks
 requires_skills: [video-production-harness]
 harness_binding: gooseworks/v2
@@ -69,6 +69,159 @@ and approval before spending. Hosted installed snapshots use the existing Skills
 Skill content and a host's cached MCP tool schemas are separate: refreshing one does not refresh
 the other. Check the actual advertised tools before using new fields.
 
+## No GooseWorks tools in this session? Call them through the CLI
+
+The GooseWorks tools named here (for example `account_whoami`, `brand_onboarding`,
+`brand_read`) normally come from the GooseWorks connector. If they are not registered in this
+session but you have a shell with the `gooseworks` CLI signed in (a cloud sandbox such as
+ChatGPT agent, Meta AI or Grok), call the same tool from the shell:
+
+```bash
+npx gooseworks tool <name> '<arguments as a JSON object>'
+```
+
+- Run `npx gooseworks tool --list` once first. It prints the server's rules for using the tools
+  and every tool name; `npx gooseworks tool <name> --schema` shows one tool's arguments.
+- The result prints as JSON. When a tool answers with a one-line summary, the fields you act on
+  (such as `next_step` and ids) follow under "Data:". It exits 1 when the tool reports an error.
+- Nothing renders as a widget here, so tell the user the result in plain words.
+- The same rules apply as over the connector: state the credit total and get the user's yes
+  before paid work.
+- If it says you are not logged in, run `npx gooseworks login --device --no-wait`, show the
+  user the link and code it prints, and run `npx gooseworks login --device` once they approve.
+
+When the tools are registered in this session, call them directly instead.
+
+## Prepare the video workflow and brand before creative work
+
+**Installed entry files are bootstrap instructions.** For new work started from an installed
+file or an old chat, fetch `catalog_fetch { type: "skill", slug: "make-custom-video" }` on the selected
+connection and read its returned content and dependencies before continuing. Use the already
+fetched body when this entry came from that connection in this run; do not recursively fetch
+the same entry. A CLI freshness warning does not block using the current connected package.
+Keep the fetched package and hashes in a new run folder; do not replace edited installed files.
+If current instructions cannot be loaded, resolve the connection before format suggestions,
+script writing or production. Do not continue from an old installed workflow or session notes.
+
+**Follow the connector's full-guide requirement when available.** Fetch
+`catalog_fetch { type: "skill", slug: "gooseworks-guide" }` when the connector requires it.
+The only older-server exception is below; it never removes brand preparation or approvals.
+
+| Returned guide/workflow state on the selected connection | Required action |
+| --- | --- |
+| Guide returns `not_found`, and this same connection already returned the complete current matching video entry with its required dependencies | Continue with that authoritative entry's workflow, full brand preparation and existing approvals. |
+| Guide has another error, no response, or incomplete content; or the matching entry/dependencies are missing, incomplete or from another connection | Stop before creative work, project writes or paid calls; resolve a compatible connection on this same environment. |
+
+A missing custom entry or required custom tool/schema remains unavailable: never substitute
+a template or an import to bypass it. Never hide other fetch errors or continue from cached
+instructions merely because the guide was not found.
+
+**For an existing project or batch, read `video_project_read` first.** Determine its actual
+route and saved review state before fetching a recipe or doing local work. Resume an approved
+run with its recorded packages, brand inputs, script and ingredients; do not silently replace
+them with today's release or brand rules. Follow returned preparation requirements and use
+the existing affected review/approval flow for an intentional change. Reads, free drafts,
+imports and existing-job retrieval do not grant permission for new paid production.
+
+**For every new plan, resolve the brand and call**
+`brand_read { brand_id, sections: ["summary", "kit", "products", "learnings"] }` **before**
+suggesting formats, mining video angles, writing any script, creating a production plan or
+handing the work to another agent. Use `brand_get_context` with those same four sections only
+when advertised. Reuse a complete read from this run on the same connection and brand.
+Onboarding completion, a summary-only response and earlier session notes do not supply the
+kit, selected product facts or saved rules. If the full read is unavailable, resolve it before
+creative work. Use known kit facts while research is incomplete; do not restart research
+solely because its status is pending. Never invent a product fact or accept a campaign to
+bypass preparation. Then search the Brand Brain (next section) before suggesting formats,
+choosing an angle or asking the user for a brand fact.
+
+Carry that context through custom/template/idea routing and delegation. Before writing, make
+the workflow's brand-rules file from those sources: pronunciations, required spoken copy,
+prohibited claims, real logo, font, palette and the selected product's supported facts.
+Entries prefixed `Video preference:` and visual/pacing instructions are creative direction,
+not spoken lines. Use the kit's audience, offer and voice as defaults without an interview.
+The rules file mirrors context; it is not proof of a read or permission to spend. Keep the
+route's existing script, ingredient and budget approvals, including its allowed previews.
+
+**Use the server's brand bundle when the selected API returns it.** Project create/read may
+return top-level
+`brand_context`: `{ version: 1, brand_id, digest, loaded_at, sections, brand, kit, products,
+learnings }`. Its sections cover summary, kit, products and learnings.
+
+| Returned brand/project response on the selected connection | Required action |
+| --- | --- |
+| A complete authoritative version-1 `brand_context` is returned | Binding is required: use its contents for the plan/rules and include `script_drafts.brand_context_digest = brand_context.digest` with each new/changed script save. |
+| An older API returns the actual four brand sections but no `brand_context` in either the brand read or project response | Prepare from those full sections, write the brand rules and follow the selected connection's existing approval flow and advertised fields. Do not fabricate a receipt or send nonexistent bundle/digest fields. |
+
+An incomplete/malformed bundle or missing brand section is a preparation failure, never the
+older-API exception. Once this connection returns an authoritative bundle, use its binding
+contract. `script_drafts.video_brand_context` is server-owned: do not author, replace or forge
+it, and do not invent a read receipt or hash local brand facts into one. Keep the full bundle
+out of client review payloads. If managed generation returns HTTP 409
+`video_brand_context_required`, reload the project and bind the plan to its returned bundle
+through the normal review flow before retrying. That refusal never permits the older-API
+fallback, skipping sections or retrying paid calls blindly. Unchanged approved legacy resumes
+retain their package, context and approvals; an upgrade alone needs no extra approval.
+
+**To apply a deliberate brand correction to a new or revised plan**, make a fresh, unfiltered
+`brand_read` of those four sections. When it returns the authoritative bundle, use its
+returned `brand_context.digest` in the complete revised `script_drafts` through the existing
+`video_project_upsert` `patch.script` save; the server verifies the current brand and replaces
+its snapshot with the saved plan. On an older API with no bundle contract, apply the actual
+four-section correction and save the revised draft through its existing flow without inventing
+digest fields. If a connection that already returned a bundle cannot supply the fresh bundle,
+resolve that failure before rebinding. Review and approve the affected script, ingredients and
+budget through the normal flow. Never refresh an ongoing approved run automatically; its
+recorded package and brand inputs stay pinned until an intentional change.
+
+## Search the Brand Brain, then propose — before any creative choice or question
+
+The Brand Kit is a summary. The brand's saved knowledge (its Brain) holds what the Kit does not:
+rules from past feedback, approved and rejected creatives, customer evidence, approved claims,
+reports and documents. **After `brand_read`, and before you choose an angle, claim, hook,
+product emphasis, format or source ad — and before you ask the user for any brand fact — call
+`knowledge_search { brand_id, query }`** when it is registered. It is free and read-only: no
+approval, no announcement to the customer and no questionnaire.
+
+1. **Search for this task, not the whole Brain.** Run one short query (under 500 characters) in
+   the user's own words plus the product (for example "ads for <product>: what worked, what to
+   avoid") and one with
+   `source_types: ["evidence", "claim", "learning", "creative", "document"]` for proof and past
+   creative results. Add a query only for a specific open question. Reuse results from this run.
+2. **Keep these states distinct** and record which one each query returned:
+
+| Result | Means | Do |
+| --- | --- | --- |
+| `status: "ok"` with matches | Saved knowledge exists | Use it; keep each fact's citation in your working brief |
+| `status: "empty"` | Nothing saved matches this query | Say "no saved evidence for <topic>", never "the brand has no proof" |
+| `refresh_required` | The results shown are current; some changed sources were left out | Use them; search again shortly for anything missing |
+| `building` | The index is not ready | Retry once shortly, then continue with the gap stated |
+| An error, or the tool is not registered | Retrieval failed or is unavailable | Retry an error once, then continue from `brand_read` and treat evidence as unchecked |
+| An empty Kit field | Only that field is blank | Not a search result: still search before asking |
+
+3. **Let the findings change the plan.** A `dont`/`must` learning or a rejected creative rules
+   options out; an approved or well-rated past creative is a proven angle to lead with; a report
+   shows what worked. Claim-grade proof is a result with `approved_ad_claim: true` or the kit's
+   `approvedClaims` within their stated applicability; the kit's `proofPoints` are what the
+   backend allows an ad to state, used as written. Other Kit text, documents and performance
+   numbers are context, never public claims. Never invent an offer, price or result. Judge
+   relevance and skip results about another product or business.
+4. **Propose; don't interview.** Lead with one recommended direction (angle, product, source or
+   format) and a one-line reason naming what you found, with up to two alternatives. When several
+   directions fit (two audiences, products or campaigns), pick the one the evidence favours, such
+   as an active campaign or approved past creatives, and name the other as an alternative instead
+   of asking. Ask only for a decision the brand read and the search cannot settle, or for spend
+   approval. Never ask the user for a fact the Brain already answered.
+   Keep directions already chosen (the user's words, a project's creative brief, handed-off
+   defaults, approved plans): search only to fill empty fields and to apply saved rules. When a
+   returned card or picker presents the choice, your recommendation is its one acknowledgement
+   line and the saved plan's defaults, not a separate list.
+5. **Carry an evidence brief** into the routed skill, writer or plan: findings with citations,
+   the state of each query, what it ruled out and the open gaps. Tell the customer the findings
+   in plain words; the citations stay in the brief.
+
+On an approved resume, keep the saved brief and evidence; search again only for a new decision.
+
 ## Keep the selected connection for the whole run
 
 Call `account_whoami` on the connection that owns the brand/project before the first write.
@@ -108,7 +261,21 @@ review set; do not add a separate approval round.
 
 ## Make Custom Video
 
-The generic production phases run in the Growth sandbox or a connected agent with a shell. GooseWorks owns the project, approvals, budget, uploads and final selection. This adapter replaces Studio desktop files and Tauri approval events with the product contract below.
+The generic production phases run in the Growth sandbox or with an agent that can run shell commands on the customer's computer. GooseWorks owns the project, approvals, budget, uploads and final selection. This adapter replaces Studio desktop files and Tauri approval events with the product contract below.
+
+## Execution preflight
+
+Who makes it: if you can run shell commands on the customer's own computer, you execute this custom project there. If you can't, create the project and hand it to the GooseWorks coworker with goose_run_task { brand_id, project_id, message: the customer's words }. Inside the GooseWorks coworker's own sandbox, make it yourself. Decide this yourself; the server needs no flag for it. Missing libass does not remove shell capability: fetch [[composes::caption-burn]], which uses Pillow and FFmpeg overlay. Fetch every selected specialist and the invoked harness step files before declaring a route unavailable.
+
+For MCP-owned runs set GW_MEDIA_VIA=mcp and GW_PROJECT_ID before running any helper, even if CLI credentials exist. Record the selected account_whoami public API origin as GW_EXPECTED_API_ORIGIN; never open credential files to discover it. Use HTTP only after verifying the matching origin through supported CLI diagnostics. For large MCP relay bodies, use the helper's body_file without retyping: upload that JSON file to this same video project, confirm the returned asset, then call data_post_provider with body_asset_id and omit body when the tool advertises that argument. Its normal project, approval, budget and secret checks still apply. Older connectors must relay the exact saved JSON unchanged.
+
+Before taking over a delegated project, cancel its delegate task and read back that it is detached. Do not request another approval while a stale delegate remains attached. If cancellation is unsupported, save the blocker; a Stop followed by reapproval can wake the same delegate again.
+
+After a paid failure, reconcile the known job and actual charges. Stop after the first identical infrastructure failure; a failed coworker turn can still cost credits. Quotes are estimates, not actual spend. Preserve approved copy while changing cost explanations; show actual cumulative charges from the project ledger.
+
+Run helpers from the run's working directory with explicit absolute input/output paths. For footage, save inspected source in/out bounds and fit:width, including screen.fit:width. A planned creator image may be absent during free take planning; use plan_takes --plan-only instead of generating a placeholder.
+
+The writer's paid critic cannot run before custom script approval. Perform its rubric locally before script review and save that evidence. Only run an external critic when the host explicitly supports it in the current approved phase and budget; never bypass a spend gate or silently claim an independent critic ran.
 
 ## Check the connected tool contract first
 
@@ -118,11 +285,34 @@ video_project_upsert must expose custom_mode and idempotency_key for creation, r
 
 The environment owner must confirm the app-MCP service rollout and refresh the connector's discovered tool schemas. Resume only when the required parameters are visible on the same selected connection. Review and approval stay in the current chat; the Studio creative page is optional. Custom generation requires separate authenticated script and ingredient approvals with their current review tokens and cumulative budgets. Template skills' one-approval instructions do not replace either custom gate. A missing approval field is a tool rollout mismatch, not a reason to require Chrome.
 
+## Match a named format before going custom
+
+Before creating a custom project, when the brief changes, and before any paid preview, check whether the request names or implies a catalog format: street interview / vox pop / man-on-the-street, street testimonial, podcast, iMessage or chat, split-screen creator, screen insert, listicle, and so on. Call video_catalog_list {kind:"formats", brand_id}, then fetch that format's renderer or recipe skill and run its own selector or checks. A street row marked fit.ok: false means no finished street video for this brand; when they asked for a street interview, the one-person conversation (preview only) still fits.
+
+For a street interview, fetch render-street-interview, read its street-script-writing guide, write a brief JSON with mode, offering_type (physical, service or digital), interaction_type and participants (people interviewed on screen, not counting the interviewer), and run python3 scripts/prepare_script_context.py --brief <brief.json> --out <context.json>. It exits 2 whenever the status is not ready-for-writing. Its route output is binding: route.support ("render" or "preview-only"), route.person_reference and route.max_participants. A status of unsupported-route lists route_gaps and alternatives; it is a stop, not permission to go custom: show the alternatives and go custom only if the customer picks it. For a software, app or service brand, a laptop, phone or other device showing the software is a prop, not their product: offering_type stays digital or service, so guessing stays unsupported. A brand that sells the device or hardware itself is physical and keeps guessing (product-guess) with that device.
+
+| Street route | On screen | Person image reference | Status |
+| --- | --- | --- | --- |
+| render-street-interview product-guess (physical product only) | Interviewer and up to four participants in one take | Forbidden: people are written in the prompt; the only reference is a standalone physical product photo | Renders |
+| render-street-interview conversation (mic-only, product-sample, concept-challenge) | Interviewer and one participant | Forbidden: no reference images, no phone, screen or UI | Preview only in this format: script and prompt dry run, no paid render |
+| ugc-street-testimonial format | One person, no interviewer | Required: the creator still that format's recipe prescribes | Template format |
+
+If the request fits a route, use that format; a fitting template format is not a custom video. If nothing fits, tell the customer in plain words what is supported and what is preview only, and name the closest supported options (the selector's alternatives) and how each differs. Or propose custom and say why. Go custom only when the customer chooses it. A custom video built on a named format still keeps that format's hard constraints. For a street interview, those are:
+
+- product-guess only with a physical product the brand sells; never a phone, laptop or screen showing software (no phone, screen or UI demonstration);
+- people described in text, never as uploaded person photos;
+- one generation per interview take;
+- deep focus;
+- the first take at 720p;
+- every caption and letter drawn locally.
+
+A selector result of needs-reference or unsupported-route, a provisional creative review or an unobserved reference is unresolved. Report it and ask before script approval; never continue past it silently.
+
 ## Load the shared production harness first
 
 This entry contains only the GooseWorks connection. Production sequencing, creative craft, reviews and repair loops are maintained in video-production-harness, published from the existing Studio harness. Do not invent a shorter local workflow.
 
-For a new run, use the video-production-harness dependency returned by catalog_fetch or fetch_skill. If absent, fetch catalog_fetch {type:"skill",slug:"video-production-harness"}; CLI users can use gooseworks fetch video-production-harness. Require nonempty content, scripts, files, version and contentHash. If unavailable, stop before generation; never fall back to a vendored playbook.
+For a new run, use the video-production-harness dependency returned by catalog_fetch or fetch_skill. If absent, fetch catalog_fetch {type:"skill",slug:"video-production-harness"}; CLI users can use gooseworks fetch video-production-harness. Require nonempty content, scripts, files, version and contentHash. Require the returned files references/editorial-review.md, references/specialist-handoff.md and references/hook-compatibility.md as nonempty text too; a coherent older release or version label does not supply missing guides. If unavailable, stop before new creative work, project writes or generation; never fall back to a vendored playbook. An unchanged approved resume keeps its recorded package and approvals.
 
 Read the returned content, orchestrator.md, capabilities.md and every detailed step invoked by the orchestrator. Materialize every returned script and file at its package-relative path in a run-specific video-production-harness folder. scripts are relative to its scripts directory; files are relative to the package root. Reject paths outside the package. Save the exact bundle only in the run's persistent workspace. Store only {slug,version,content_hash,package_path} as script_drafts.harness in the saved project; never inline the package content, files or scripts into the review draft. The review payload must stay below its 256,000-character limit. Keep the saved package in this run's durable folder, not a shared mutable installation.
 
@@ -152,7 +342,9 @@ or gooseworks fetch <slug>. Inspect the selected connection's advertised schemas
 | Real product footage, screen recordings or screenshots | [[composes::footage-cutlist]] | Inspect source windows, map each proof shot to its line, review the cut list and render the product layer. |
 | Creator beside, over or between product footage | [[composes::compose-creator-layer]] | Combine the inspected creator track and product layer per beat. Preserve the creator's dialogue as the master audio. |
 | Native multi-cut performance or general generated B-roll | [[composes::create-video-seedance-2-fal]] or [[composes::create-video-fal]] | Choose from the actual supported endpoint/schema and quoted operations; use H3 when a continuous exact-script creator track is the better fit. |
-| Character anchors, grounded product edits or scene stills | [[composes::create-image-fal]] or [[composes::create-image-gpt-image-fal]] | Reuse approved identity and real product references. Check preview eligibility and bounded pricing for the exact endpoint. |
+| Street interview, vox pop or man-on-the-street | [[composes::render-street-interview]] | Run its selector first (see "Match a named format before going custom"). Keep its route contract: people in text, one take per interview, 720p first take, local captions, end card and ambience bed. Do not call its one-shot driver or create a second project. |
+| A generated person in any still or as a video reference | [[composes::create-creator-takes-h3]] (scripts/make_character.py) | Follow "People in generated images" below. The selected route decides whether a person still is allowed at all. |
+| Grounded product edits or scene stills without a person | [[composes::create-image-fal]] or [[composes::create-image-gpt-image-fal]] | Reuse approved product references. Check preview eligibility and bounded pricing for the exact endpoint. |
 | Separate narrator or voice audition | [[composes::create-vo-elevenlabs]] | Use the host-approved voice and locked copy. Do not add a second narration over native creator speech. |
 | Music bed or song | [[composes::create-music-elevenlabs]] | Include its actual quote in the phase budget; preserve the approved audio strategy and lyric/beat timing. |
 | Branded text cards, graphics or end card | [[composes::goose-graphics]] | Start from a fitting layout/style and real logo. It produces graphics; animation still requires an actual local renderer. |
@@ -162,13 +354,23 @@ or gooseworks fetch <slug>. Inspect the selected connection's advertised schemas
 | Replace a defective silent B-roll window in a UGC master | [[composes::ugc-fixloop]] | Keep the original continuous dialogue; this repair does not fix a talking shot's lips or voice. |
 | Complete-video observation and finished-ad checks | [[composes::watch]] and [[composes::review-finished-ad]] | Supply real frames/audio, brand assets and timestamps. Their results support the shared final QC; they do not grant approval. |
 
-For format-specific motion, chat, podcast, product or music layouts, search the catalog for
+For format-specific motion, chat, podcast, street-interview, product or music layouts, search the catalog for
 the matching render-* capability and inspect its config and inputs. Reuse a compatible
 renderer or phase implementation without changing the custom project into a fixed template.
 Do not call a template's one-shot driver, create a second project, or replace the shared
 production sequence just to use one of its helpers. The table is a starting map, not an
 exhaustive catalog or a promise that every published skill is executable on this connection.
 
+## People in generated images
+
+Apply this whenever a generated image or video shows a person: creator, presenter, interviewee or any face in focus. Customers reject smooth, airbrushed, AI-looking people and blurred backgrounds.
+
+- The selected route decides first. When it forbids person references (every render-street-interview route), describe people in the video prompt and make no person stills. When it requires a person reference, make it with the builder that route prescribes. The ugc-street-testimonial recipe prescribes its own creator still.
+- Otherwise, every generated person comes from create-creator-takes-h3's scripts/make_character.py. Fetch create-creator-takes-h3 and create-image-fal together, because the builder calls create-image-fal's gen_image.py. Pass the customer's six choices (age, gender, ethnicity, hair, wardrobe and scene) and keep its defaults: fal-ai/nano-banana-pro, 4K, phone capture with deep focus, head and upper chest, face filling 45 to 55 percent. Run it with --dry-run --payload-out <file> first: the file holds {model, body}, the exact request. Quote that body through data_post_provider with path set to its model and query:{quote_only:true}, as in "Saved review schema". Once the still is approved and quoted, run make_character.py again without --dry-run and with GW_PROJECT_ID set to this project, so the same body goes through the managed proxy.
+- Never hand-write a person prompt, fill the generic avatar template by hand, or use fal-ai/flux/dev, fal-ai/flux/schnell or another Flux route for a face. A hand-written generic prompt is not a substitute for the builder. If the builder's request cannot be quoted, report a pricing blocker.
+- Never send a generated photoreal person still as a reference image to bytedance/seedance-2.0/reference-to-video; its likeness gate refuses uploaded images of people. For an exact-script creator from an approved still, use create-creator-takes-h3's takes.
+- Before showing ingredients, crop each face, enlarge it 2× and look. Fix it or report it when skin is waxy or glossy, pores are missing, the background is blurred or bokeh, hands or lettering are garbled, or the face is under about 300 px tall. Show the customer only stills that pass.
+
 ## Bind and retain the selected specialists
 
 A fetched package proves that instructions exist; it does not prove that its provider,
@@ -207,7 +409,7 @@ the limitation and propose a supported revision instead of improvising a bypass.
 
 ## Carry the sourced brief and verify the handoff
 
-Before script writing, save the writer's documented creative-brief.json from the current brand/product evidence and project directions. Include exact product/variant, buyer situation, supported mechanism/claims, offer/CTA, constraints, delivery intent, locked copy, applicable prior decisions and explicit unknowns with source references. Use the fetched write-video-ad-script preparation command with --brief working/script/creative-brief.json and its documented bank/brand/product/template arguments; set the new shape.requires_creative_brief to true. The writer and critic consume that same angle-context. Save only the concise brief/revision and workspace reference in script_drafts extra fields, never full research/package contents. A missing required brief fails the script check; do not rerun known research or rewrite user-locked wording silently.
+Before script writing, save the writer's documented creative-brief.json from the current brand/product evidence (the Brain search's evidence brief: cited findings, the state of each query and open gaps) and project directions. Include exact product/variant, buyer situation, supported mechanism/claims, offer/CTA, constraints, delivery intent, locked copy, applicable prior decisions and explicit unknowns with source references. Before using the writer, run its free python3 <saved-writer-package>/scripts/verify_handoff.py --package-dir <saved-writer-package> --out working/script/writer-handoff-check.json check against the actual fetched prepare/lint scripts and retain the result and script hashes. A missing checker, failed check or unsupported --brief command blocks the required writer route before saving or approving a new plan; keep any chat proposal unsaved and unapproved until the compatible package is available on this same connection. Do not remove the brief, strict check or requires_creative_brief requirement to run an older parser. Use the fetched write-video-ad-script preparation command with --brief working/script/creative-brief.json and its documented bank/brand/product/template arguments; set the new shape.requires_creative_brief to true. The writer and critic consume that same angle-context. Save only the concise brief/revision and workspace reference in script_drafts extra fields, never full research/package contents. A missing required brief fails the script check; do not rerun known research or rewrite user-locked wording silently.
 
 Read references/specialist-handoff.md from the saved shared harness. For each selected UGC, product/demo or motion operation, extend the existing script_drafts.capability_plan entry with the exact approved brief/script revisions, mapped scene/beat numbers and timing, selected product/reference/source IDs and excerpt ranges, audio/performance choice, package/version/hash and expected returned artifact roles. These are existing extra draft/project artifacts, not new API parameters. Preserve the distinction between numeric script_drafts.scenes[].scene and string production scene IDs.
 
@@ -299,7 +501,7 @@ Only the authenticated customer-facing connection can record the customer's appr
 
 ## Paid execution and resume
 
-Every managed media call carries project_id (GW_PROJECT_ID in scripts) and a stable input fingerprint. Use the managed fal/ElevenLabs endpoints and credentials supplied by Growth; never request customer provider keys. Do not expose those credentials in logs. Recheck custom_review before dispatch. The backend reserves estimated outstanding costs atomically, enforces the approved total (maximum3,000 credits) and prevents duplicate submissions. At most a20% overrun can be newly approved; this is not automatic permission to spend above the customer's selected limit.
+Every managed media call carries project_id (GW_PROJECT_ID in scripts) and a stable input fingerprint. Use the managed fal/ElevenLabs endpoints and credentials supplied by Growth; never request customer provider keys. Do not expose those credentials in logs. Recheck custom_review before dispatch. The backend reserves estimated outstanding costs atomically, enforces the approved total (maximum 3,000 credits) and prevents duplicate submissions. At most a 20% overrun can be newly approved; this is not automatic permission to spend above the customer's selected limit. A custom video's budget grows only through a renewed approval. On SPEND_CAP_REACHED the open render is asked to stop: report it "stopped" with what was kept (see "Render run states") and tell the customer what was made and spent. Then save a revised estimate, show the new custom_review.approval_quote with its current total, record the customer's approval of that total, and open a new render that reuses the saved pieces.
 
 Preview eligibility and price support are separate checks. Use an exact endpoint permitted by the backend preview policy and confirm its current request schema and server quote. Model discovery and provider pricing can change: use the selected connection's actual quote, including supported provider estimates, instead of a skill-maintained priced-model list. A model-family name does not make every route eligible for script previews. Do not move a preview to another phase to bypass its approval gate. If pricing cannot be established, keep the saved request and report a system pricing blocker; do not ask the customer to choose when their choices are already approved. Final clip models require ingredient approval. Existing-job polls remain permitted after edits; retrieval does not authorize new media.
 
@@ -311,6 +513,26 @@ Use the selected packages in script_drafts.capability_plan for each scene and op
 
 Open a render with video_render_run {brand_id,project_id,kind:"full"}; executor:"cloud_agent" for Growth when exposed by the current schema. Report live workflow_stage/progress_note/progress_percent while producing it. Upload the final file to scope:"video_project", scope_id:project_id. The tool opens/reports a client-executed render; fixed server orders remain paused.
 
+### Render run states
+
+Report the open render's state with video_render_run {brand_id,project_id,render:{render_id,...}}. Use the row that matches:
+
+| Situation | status | workflow_stage | quality_status | Also send |
+| --- | --- | --- | --- | --- |
+| Producing, checking or repairing | "running" | preparing, rendering, checking, repairing or rechecking | "pending" | progress_note, progress_percent, steps |
+| Waiting for the customer: they must approve a candidate, choose or give feedback, with or without an uploaded candidate | "running" | "blocked" | "blocked" | output_url when an uploaded candidate exists, error_message saying in plain words what you need from them, and choices (at most 4 buttons; put credits on any paid choice). A quality_report is optional while waiting; when sent, it carries the current findings |
+| Stop requested: a progress callback returned stop:true because the customer stopped the video or a paid step hit the spending limit | "stopped" | omit | omit | progress_note saying in plain words what was kept. Start no new paid step; let a call already running finish. |
+| Real failure: no usable candidate can be produced (provider refusal with no approved alternative, or a system blocker you cannot recover) | "failed" | omit (the server sets blocked) | "blocked" | error_message in plain words |
+| Done | "complete" | omit (the server sets ready) | "passed" | output_url and the full quality_report, only after the final recipe is saved and read back as described below |
+
+Waiting for the customer is not a failure, and neither is a stop. Never report "failed" because you are waiting for approval, a choice or feedback, or because the customer or the spending limit stopped the video. When stop:true comes with stop_reason "superseded", report nothing further on that render. The app shows a waiting render's candidate as "Needs your approval" and keeps it for up to 14 days; after that the server ends it as failed with failure_code review_expired. The uploaded file stays in the project either way.
+
+A waiting state is valid only while the approval it rests on is current. A render can complete only under the approval it was opened with. After any script or ingredient edit (yours or the customer's), or after review_expired, the old render cannot be completed: read video_project_read {brand_id,project_id,include:["assets","renders"]}, show the changed review and the current custom_review.approval_quote in chat, record the customer's approval of each phase it asks for, then open a new render. Opening a new render stops the older open render of this video with stop_reason "superseded" ("Replaced by a newer version."). Report nothing more on a superseded render and start no paid step for it; continue on the new one. To deliver an unchanged candidate on the new render, follow "Finalize an existing candidate after re-approval" below.
+
+When the customer approves a waiting candidate and nothing in the review changed, finish the shared final review and complete that same render; a candidate needs no separate approval phase. When they ask for changes, save the feedback and follow the normal edit and approval gates.
+
+On resume, treat a render left at "running" with workflow_stage "blocked" as a pending customer decision. Read custom_review and custom_review.feedback before doing anything else. If your own render shows stop_reason "superseded", another run replaced it: read video_project_read {brand_id,project_id,include:["assets","renders"]} and continue on the newer render; do not open another one just to resume.
+
 After each accepted generation or deterministic edit, update patch.production with the steps and settings that actually ran. Save and read back the actual candidate recipe before showing its preview or pausing for review, so an interrupted or waiting run does not leave only an early plan in the backend. Partial progress is allowed; pending creative approval or QC must stay explicit and must never be converted into passing clip evidence.
 
 Before completing or pinning a candidate, replace the early planning manifest with the actual production recipe. Record every current script scene using its string scene number, exact current spoken line, measured duration and full generation prompts or deterministic rendering instructions. Record the actual pipeline/model settings, assembly/captions/audio settings, and repairs in fixes. Never leave blocked/pending planning statuses in a completed recipe. Preserve full prompts and guards; do not reduce them to summaries. Save partial progress while working, but an unfinished recipe is not a reusable final.
@@ -405,19 +627,31 @@ The following is a one-scene JSON shape example. Replace all placeholders with a
 }
 ```
 
-Complete with video_render_run {brand_id,project_id,render:{render_id,status:"complete",output_url,quality_status:"passed",quality_report:{version:1,summary,checks:{source,brand,product,hook_and_scene_order,voice_and_script,captions,endcard_and_cta,duration_and_ratio,visual_artifacts},detected_issues:[],repair_actions:[],checked_at}}}. Each final check is {status:"pass"|"fail"|"not_applicable",note}; brand/product/scene order/duration/visual artifacts must pass. Save a failed candidate as blocked/failed with its issue, not complete. Final completion binds approval revisions, output and quality evidence to the render; pin with patch.final_render_id only after passing.
+Complete with video_render_run {brand_id,project_id,render:{render_id,status:"complete",output_url,quality_status:"passed",quality_report:{version:1,summary,checks:{source,brand,product,hook_and_scene_order,voice_and_script,captions,endcard_and_cta,duration_and_ratio,visual_artifacts},detected_issues:[],repair_actions:[],checked_at}}}. Each final check is {status:"pass"|"fail"|"not_applicable",note}; brand/product/scene order/duration/visual artifacts must pass. A candidate that fails QC is never complete: keep it "running" with workflow_stage "repairing" while you fix it, report the waiting state above when the customer must decide, and use "failed" only for a real failure. Final completion binds approval revisions, output and quality evidence to the render; pin with patch.final_render_id only after passing.
 
 All nine named final checks above are required, including source, voice_and_script, captions and endcard_and_cta when they are not applicable. A final check uses status:"pass"|"fail"|"not_applicable" and an optional note. The five mandatory passing checks are brand, product, hook_and_scene_order, duration_and_ratio and visual_artifacts; no final check may fail and detected_issues must be empty to complete. Record why a permitted check is not_applicable. Keep actual repair_actions and use the actual ISO 8601 checked_at time. The backend report is a minimum; it does not replace the full shared watch, claim verification or craft review.
 
-This blocked report illustrates every required field. Replace its findings and example timestamp with actual evidence. Only after repairs and the shared final review pass may the render be reported complete with quality_status:"passed", its confirmed output_url and no unresolved issues.
+This waiting-for-the-customer report illustrates every required field. Replace the URL, reason, choices, findings and example timestamp with actual evidence. Only after repairs and the shared final review pass may the render be reported complete with quality_status:"passed", its confirmed output_url and no unresolved issues.
 
 ```json
 {
   "render": {
     "render_id": "<existing render ID>",
-    "status": "failed",
+    "status": "running",
+    "workflow_stage": "blocked",
     "quality_status": "blocked",
-    "error_message": "<actual unresolved issue>",
+    "output_url": "https://example.com/confirmed-candidate-in-this-project.mp4",
+    "error_message": "<what you need from the customer, in plain words>",
+    "choices": [
+      {
+        "label": "Approve this version",
+        "message": "I approve this version"
+      },
+      {
+        "label": "Change something",
+        "message": "I want to change something in this version"
+      }
+    ],
     "quality_report": {
       "version": 1,
       "summary": "<actual full-video review summary>",
@@ -469,6 +703,17 @@ This blocked report illustrates every required field. Replace its findings and e
 }
 ```
 
+### Finalize an existing candidate after re-approval
+
+Use this when an uploaded candidate (a confirmed video in this project) already shows and says exactly what the current script says, but its render can no longer complete: the script was amended to match the take, or the wait ended as review_expired. If any spoken line, caption, scene or ingredient differs from the current script, this route does not apply: repair or regenerate under the normal gates.
+
+1. If the script changed, save it and record the customer's script approval first, as in "Record each approval in this chat". Then save the candidate as a video ingredient (its confirmed URL) in the review set, show the candidate and the current custom_review.approval_quote in chat, and record the ingredient approval. The earlier render was approved against the old review, and the server will not complete it.
+2. Open a new render with video_render_run {brand_id,project_id,kind:"full"}. Start no provider call. The older waiting render stops as superseded.
+3. Run the shared final review on the existing file against the current script. voice_and_script and captions must match the current lines.
+4. Save and read back the final production recipe with the current lines and one checked clip per scene, as described in "Clips, assembly and quality". Reuse the clip records from the candidate's saved recipe, updated to the current lines.
+5. Complete the new render with status:"complete", output_url set to the existing candidate's confirmed URL, quality_status:"passed" and the full quality_report. Do not regenerate or re-upload. No credits are spent.
+6. Pin it with video_project_upsert patch.final_render_id (alias set_final_render).
+
 ## Feedback and delivery
 
 Save customer script/ingredient/video feedback through the connected project tools before continuation; affected creative edits invalidate their approvals. Read custom_review.feedback on every turn, preserving the original watched render/time and text when provided. A selected final change never relocates an earlier note. Resolve only after the candidate satisfies the original intended effect and full-output recheck; keep incomplete or conflicting notes open. Replace only the affected assets; save revised estimates and show the changed review and cumulative budget in the same chat before recording renewed approval. Deliver the playable current_render_url with render_artifact kind:"video" in Growth and actual project spend. Include the Studio app_url when a text host or the customer needs it; do not require it for approval. Keep final history; never create another project just because an agent restarted.

package/skills/manifest.json

@@ -1,12 +1,12 @@
 {
   "package": "gooseworks",
-  "version": "0.4.4",
+  "version": "0.4.5-dev.15.facf60fb",
   "entries": {
-    "gooseworks": "5dfa07724741e44cb93451077168c36539468c34c1624e3d57fa58eb36a7e69b",
-    "goose-ads": "73e8f31ac8fd0fb2c8eb38be048808d954936e11ce54e7f803daf50f1ed4ffc5",
-    "goose-video": "ab3d0c549a0bc28eb3c33f6d6895f5ae0575a7d53ede98b2b1d596e52f4ff488",
-    "goose-video-local": "2972937123d0f75d0c6af989a8a20c10395ad50781eeff7f64082584d80acc94",
-    "make-custom-video": "2ad4a37664c45fe93d26f321aa9d72d16b542be0d5f0952f8331f274df39ef25",
-    "goose-product-photos": "1bbaa7eb72b5882b5ba4756b85ff37bc1db557822ae00b485262d3dee7c3fce5"
+    "gooseworks": "20f9a5190616feaf711a6ab5b5ab388698a0a0fb4ad62273214918c5a74fa2ce",
+    "goose-ads": "ed21e246ee06c396a623f87530542022213a2056cabea4f0200f379c928eb738",
+    "goose-video": "e34bad74f467bf40469e1e307e3a3612aac89546fc6175e577b6cb93c7091d8f",
+    "goose-video-local": "564652f895a1089181e2f0fbd7040b1474a3e23ae8226a4571844d284fbfbfcd",
+    "make-custom-video": "791babd54cc2082b7d043aae7e3f1691aa1e59a6d156a21a6c272b109e32b00d",
+    "goose-product-photos": "9dfc37696b2bef8a0d9755ba85ff6681339f08ebbc93a14e7ac35f77c80b0f35"
   }
 }

package/skills/routes.json

@@ -5,7 +5,7 @@
     {
       "skill": "goose-ads",
       "when": "Remix/make an ad, research a brand for ads, OR analyze ad performance — Meta/Google ad campaigns, creative fatigue, CAC/lead quality, competitor ad intel, ad angles & hooks",
-      "how": "Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.",
+      "how": "In a chat app, fetch it with `catalog_fetch { type: \"skill\", slug: \"goose-ads\" }`. In a terminal, use the installed entry skill; if it is missing, run `gooseworks install --claude`.",
       "delivery": "entry"
     },
     {
@@ -16,32 +16,32 @@
     },
     {
       "skill": "goose-video",
-      "when": "Make a **video** ad from a template or an original brief. Template-free briefs and Instagram/direct video references route to make-custom-video. Growth renders in its sandbox; connected coding agents use their local toolchain.",
-      "how": "Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.",
+      "when": "Make a **video** ad from a template or an original brief. Template-free briefs and Instagram/direct video references route to make-custom-video. An agent that can run shell commands on the customer's computer makes it there; otherwise the GooseWorks coworker makes it.",
+      "how": "For new work, fetch the current goose-video entry from the selected connection, then load the full brand before format suggestions. An installed entry is a bootstrap; keep approved project packages on resume.",
       "delivery": "entry"
     },
     {
       "skill": "make-custom-video",
-      "when": "Create an original branded video without a template, adapt an Instagram/direct video reference, or resume a generated custom project; separate Studio script and ingredient approvals are required",
-      "how": "Use the installed GooseWorks connection entry, or fetch make-custom-video through the catalog. It loads video-production-harness; Growth uses its sandbox and connected agents use their local tools.",
+      "when": "Create an original branded video without a template, adapt an Instagram/direct video reference, or resume a generated custom project; separate script and ingredient approvals are required in the same chat",
+      "how": "Fetch the current make-custom-video entry and its production harness for new work, then read summary, kit, products and learnings before script writing. Read an existing project first and retain its approved package/context on resume.",
       "delivery": "entry"
     },
     {
       "skill": "goose-video-local",
       "when": "Render an EXISTING app video project or batch on this machine — the app's \"copy for Claude\" command names it",
-      "how": "Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.",
+      "how": "Read the existing project first. Use the current goose-video-local entry as the connection adapter, retain approved recipe packages/context and apply brand preparation before a new plan or script.",
       "delivery": "entry"
     },
     {
       "skill": "goose-product-photos",
       "when": "Make **product photos** — studio, lifestyle, marketplace, social, or on-model product photography",
-      "how": "Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.",
+      "how": "In a chat app, fetch it with `catalog_fetch { type: \"skill\", slug: \"goose-product-photos\" }`. In a terminal, use the installed entry skill; if it is missing, run `gooseworks install --claude`.",
       "delivery": "entry"
     },
     {
       "skill": "animate-image",
       "when": "Animate an approved static ad or product image",
-      "how": "Fetch with `gooseworks fetch animate-image` and follow its GooseWorks MCP workflow.",
+      "how": "Fetch it (`catalog_fetch { type: \"skill\", slug: \"animate-image\" }` in a chat app, `gooseworks fetch animate-image` in a terminal) and follow its GooseWorks MCP workflow.",
       "delivery": "fetch"
     }
   ],

package/dist/skills/fetcher.d.ts

@@ -1,18 +0,0 @@
-export interface SkillCatalogEntry {
-    slug: string;
-    name: string;
-    description: string;
-    category: string;
-    skill_md: string;
-    scripts?: Array<{
-        filename: string;
-        content: string;
-    }>;
-}
-export interface SkillCatalog {
-    skills: SkillCatalogEntry[];
-    master_skill_md: string;
-}
-export declare function fetchSkillCatalog(apiBase: string, apiKey: string): Promise<SkillCatalog>;
-export declare function fetchSkillCatalogFromGithub(): Promise<SkillCatalog>;
-//# sourceMappingURL=fetcher.d.ts.map

package/dist/skills/fetcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetcher.d.ts","sourceRoot":"","sources":["../../src/skills/fetcher.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,KAAK,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;CACzB;AAuBD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAa9F;AAeD,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,YAAY,CAAC,CAkDzE"}

package/dist/skills/fetcher.js

@@ -1,118 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchSkillCatalog = fetchSkillCatalog;
-exports.fetchSkillCatalogFromGithub = fetchSkillCatalogFromGithub;
-const https = __importStar(require("https"));
-const http = __importStar(require("http"));
-function httpGet(url, headers) {
-    return new Promise((resolve, reject) => {
-        const client = url.startsWith('https') ? https : http;
-        const req = client.get(url, { headers }, (res) => {
-            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-                httpGet(res.headers.location, headers).then(resolve, reject);
-                return;
-            }
-            if (res.statusCode && res.statusCode >= 400) {
-                reject(new Error(`HTTP ${res.statusCode} from ${url}`));
-                return;
-            }
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-            res.on('error', reject);
-        });
-        req.on('error', reject);
-    });
-}
-async function fetchSkillCatalog(apiBase, apiKey) {
-    const url = `${apiBase}/v1/skills/catalog`;
-    const body = await httpGet(url, {
-        'Authorization': `Bearer ${apiKey}`,
-        'Accept': 'application/json',
-    });
-    const response = JSON.parse(body);
-    if (response.status === 'error') {
-        throw new Error(response.message || 'Failed to fetch skill catalog');
-    }
-    return response.data;
-}
-const GITHUB_RAW_BASE = 'https://raw.githubusercontent.com/gooseworks-ai/goose-skills/main';
-async function fetchSkillCatalogFromGithub() {
-    const indexUrl = `${GITHUB_RAW_BASE}/skills-index.json`;
-    const indexBody = await httpGet(indexUrl, { 'Accept': 'application/json' });
-    const index = JSON.parse(indexBody);
-    const skills = [];
-    for (const entry of index.skills) {
-        try {
-            const skillMdUrl = `${GITHUB_RAW_BASE}/${entry.path}/SKILL.md`;
-            const skillMd = await httpGet(skillMdUrl, {});
-            const scripts = [];
-            if (entry.scripts) {
-                for (const scriptPath of entry.scripts) {
-                    try {
-                        const scriptUrl = `${GITHUB_RAW_BASE}/${entry.path}/scripts/${scriptPath}`;
-                        const content = await httpGet(scriptUrl, {});
-                        scripts.push({ filename: scriptPath, content });
-                    }
-                    catch {
-                        // Skip scripts that fail to download
-                    }
-                }
-            }
-            skills.push({
-                slug: entry.slug,
-                name: entry.name,
-                description: entry.description,
-                category: entry.category,
-                skill_md: skillMd,
-                scripts: scripts.length > 0 ? scripts : undefined,
-            });
-        }
-        catch {
-            // Skip skills that fail to download
-        }
-    }
-    // Fetch master skill
-    let masterSkillMd = '';
-    try {
-        masterSkillMd = await httpGet(`${GITHUB_RAW_BASE}/skills/gooseworks-master/SKILL.md`, {});
-    }
-    catch {
-        // Will use embedded fallback
-    }
-    return { skills, master_skill_md: masterSkillMd };
-}
-//# sourceMappingURL=fetcher.js.map

package/dist/skills/fetcher.js.map

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