How do I planning-only portable presenter-overlay project author: canonical transcript, typed custody, eight approval-gated planned_not_submitted Higgsfield requests, editable Remotion source and clean validation. Enforces style, density and animation contracts plus downstream motion, QuickTime encoding and hardware-playback QA. No media generation or rendering

the agent that answers this

Visual Treatment Planner — Higgsfield + Remotion. Planning-only portable presenter-overlay project author: canonical transcript, typed custody, eight approval-gated planned_not_submitted Higgsfield requests, editable Remotion source and clean validation. Enforces style, density and animation contracts plus downstream motion, QuickTime encoding and hardware-playback QA. No media generation or rendering.

• Step 1tool

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/presenter-source.json as typed run-bound presenter external-input binding; no other bundle file. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: Inspect only current run-bound presenter_video via authorized local media adapter. Write presenter-source.json typed external-input binding: semantic ID, expected SHA-256, metadata, portable materialization destination. Before stage 1 is done, its declared typed metadata schema carries every observed media-adapter probe value that later stages require as a primary source fact, exactly as observed: durationSeconds, the rational fps numerator and denominator, width, height, pixelFormat and streamCount; never omit, estimate or default one. The metadata object holds exactly these facts and no other field; every other probe observation, such as a frame hash, seek time or time base, stays only in the media-adapter probe receipt and is never copied into the bundle. Never copy source, retain absolute/earlier-run paths, or scan disk; source/hash failure is typed needs-input. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check.

  Your model fills this step
• Step 2tool

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Record only a local preflight receipt outside the bundle; do not mutate the project. The local preflight receipt path is verification/preflight-receipt.json; record only actual checks and their outcomes. Explicit current stage requirements: Preflight current presenter and record resolved paths, versions and availability of ffprobe, transcription runtime, Node, npm, TypeScript and Remotion CLI in machine-readable report; do not invoke dependency/validation/composition commands. Resolve and verify a local Remotion browser executable without launching npm or Remotion: prefer a non-empty REMOTION_BROWSER_EXECUTABLE environment value only when its target is a regular executable file; otherwise, on macOS use /Applications/Google Chrome.app/Contents/MacOS/Google Chrome only when that exact file exists and is a regular executable file. Record the selected path and file identity (resolved target, device/inode, size, modification time and SHA-256) in a local preflight receipt outside the portable bundle. If neither candidate is available, fail early with typed blocker remotion_browser_executable_unavailable and stop before any dependency or project work. The browser is a machine-local prerequisite, never part of the portable bundle; keep the absolute browser path and local receipt out of all packaged files, reports and command evidence. Resolve tool availability/version from existing metadata and authorized read-only inspection; do not run dependency, validation or composition commands. Missing files assigned to later producer stages are expected, not preflight failures. The complete ZIP inventory is stated in stage 11; authored JSON files other than the explicitly fixed portable asset/request projections must have declared versioned schemas implemented by the stage-9 loaders/validators. Do not require an unprovided historical schema. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check.

  Your model fills this step
• Step 3

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/transcript.json, project/transcript.srt, project/transcript.txt, and project/transcript-validation.json; preserve canonical transcript recovery and validation. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: Create canonical transcript.json for complete presenter with ordered typed segments, stable IDs, timing/text, word timestamps/confidence and silences; deterministically assign missing IDs. Derive SRT/TXT only from it; record SHA-256 and presenter binding. Reject duplicate/orphan IDs, unsupported text or incomplete coverage; isolated faster-whisper zero-duration word timestamps are recoverable, not automatically fatal. Preserve canonical segment text, every spoken word, token order, stable IDs, valid word timestamps and valid parent segment bounds exactly: never invent, delete or rewrite spoken words. First validate parent segment timing is finite, positive-duration, monotonic and contained within verified media duration. Only within a valid parent segment, deterministically normalize each zero-duration word using bounded interpolation from nearest valid non-estimated word timestamps and segment bounds. For a maximal contiguous run of k zero-duration tokens in canonical order, set L to the preceding valid word end (or segment start when absent), R to the following valid word start (or segment end when absent), bounded by the parent segment. If L<R and anchors are ordered and valid, assign token j (zero-based) [L+j*(R-L)/k, L+(j+1)*(R-L)/k], without moving valid neighboring words or extending outside the segment; use a fixed documented precision and recheck positive duration, containment and monotonic order after serialization. Mark every repaired token timingEstimated=true and retain its original timestamp pair for audit. Never use another repaired token as an independent anchor. If no positive bounded interval exists, do not force a duration or modify text/segment bounds: retain the unresolved word timing as unavailable for boundary authority and hand off to the stage-4 segment/evidence gate. Record repaired-token count, unresolved-token count, token IDs, original/repaired timing, anchors and method bounded_neighbor_segment_interpolation_v1 in the validation report; record warnings for all estimates/unresolved word timings. Derive all exported transcript text and hashes from the same canonical transcript. Portable transcript evidence: every exported hash must name either a file in the frozen projectBundleContract.files inventory, verified from that file's exact stored bytes, or the already-bound presenter input identity recorded by a different stage. Every exported canonical reference resolves within its declared canonical record collection. Preserve the canonical transcript/SRT/TXT hashes and presenter binding already required above. Raw adapter-result provenance stays in the existing run_media_adapter_operation receipt or work evidence; never add an unbound raw-adapter hash to a portable transcript or validation report, rename it as metadata, or invent a custody identity. Before the stage-3 done heartbeat, read-only check these target bindings across the four stage-3 outputs and correct any unbound target only while stage 3 remains open. Preserve all existing canonical text, timing normalization, original/repaired-token audit, counts, warnings and serialization requirements. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check.

  Your model fills this step
• Step 4decision

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/timing-contract.json; preserve rational FPS, half-open coverage, reference validation, and timing-evidence requirements. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: Using only already-authorized media and transcript evidence, validate canonical transcript/source/composition timing: rational FPS, integer durationFrames, quantization, exact once-only half-open contiguous scene coverage without rounding extension; define canonical reference validator for segment existence, range containment and text agreement. For timing validation, fail only when segment timing is invalid/nonfinite/nonpositive, non-monotonic, outside verified media duration, or a required scene/evidence boundary cannot be established safely. A zero-duration, repaired or unavailable word timestamp alone is not a fatal timing error when segment ranges and narrative timing remain usable. Establish boundaries using valid segment timing plus authorized silence/frame evidence; record the evidence and rationale for each boundary, and never use an estimated word timestamp as the sole authority for a cut. If a word-level boundary lacks trustworthy timing, select a safe evidence-supported boundary within valid segment/composition ranges; do not invent precision. Preserve canonical text, IDs, reference integrity, rational FPS, integer frame quantization and contiguous once-only coverage. Record a warning and continue through stages 5-13 when segment ranges and narrative timing are usable. Carry timingEstimated flags, interpolation method/count and warnings into canonical reference validators and downstream reports so later validators, adversarial review and extracted-ZIP validation apply this same recovery policy rather than reinstating an unconditional zero-duration-word failure. Artifact dependencies are stage-ordered: later producer outputs are not earlier-stage prerequisites. Composition duration must derive from this attempt's verified presenter duration, rational FPS and once-only frame coverage, never an earlier video's fixed frame count. Canonical reference shape (existing timing-contract.v1 consumer contract): timing-contract.json must have a stable non-empty root id, contractVersion='timing-contract.v1', root-level safe-integer fpsNumerator/fpsDenominator/durationFrames equal to the existing verified clock (never a nested clock object as their substitute), and a segments array covering every canonical transcript segment exactly once. Each segment row carries segmentId (the unchanged canonical segment ID), quote (the exact canonical text), startSeconds and endSeconds (the canonical segment start/end in seconds, not invented word timing). IDs use ^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$ and segmentId is unique. Values must be finite, nonnegative, ordered and within the verified source/composition timing under the unchanged stage-4 policy. Keep the existing source/transcript identity and digest, boundary evidence, quantization and warnings; the canonical segments projection is additional required machine-readable structure, not a substitute for any of them. Do not use a boundaries-only or differently named array in place of segments. Later narrative/density documents bind this exact id and SHA-256 of these stored bytes. Finish this document at its own stage; later producers must not rewrite it. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check. Every count, total or restated value in timing-contract.json, including human-readable restatements, must be named for exactly what it counts and computed directly from primary records. timingEstimatedCount counts canonical words with timingEstimated===true only; unresolved/unavailable word timings remain distinct and must never be counted or described as estimated. Preserve their separate counts, audit and warnings in the existing records; do not invent repaired timestamps or discard unavailable timing. Before stage4done, recompute these bindings from the canonical transcript and earlier sealed evidence, and correct this stage’s document while it remains open.

  Decision step
• Step 5

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/narrative-beats.json and project/creative-direction.json; preserve semantic planning, visual support, cadence, and presenter-gap constraints. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: Derive semantic narrative sections, beats, implementation scenes and timed subscenes from complete thoughts/claims/topic shifts/demos/emotional turns; never fixed scene count. Write narrative-beats.json with stable IDs, canonical quotations/ranges and boundary rationale; prefer 6–15 seconds, subdivide or justify over 20 seconds; validate references. Plan meaningful designed visual support over at least 65% of spoken runtime, with meaningful visual changes every 4–8 seconds and no unexplained presenter-only gap longer than 10 seconds. Subscene changes may occur within semantic scenes; do not force narrative cuts to meet cadence. Beats are narrative anchors, not the cadence: for each beat also record the distinct claim-derived points from the canonical transcript (facts, steps, comparisons, quoted terms) that later stages can reveal as successive visual states inside that beat. Each support interval and change must explain how it serves its linked spoken claim; cosmetic pulses, captions alone, a section label alone, and repetitive tile duplication do not count as meaningful support. Designed support is optional per beat and qualifies only when it shows at least two distinct claim-derived elements or an explicit relation between them; fragments, sign-offs, fillers and other non-claim speech stay presenter-only with continuous audio, never receive manufactured nodes or support, and coverage counts only qualifying support. Canonical reference shape (existing narrative-beats.v1 consumer contract): narrative-beats.json must have contractVersion='narrative-beats.v1', a stable root id, timingId equal to the committed timing-contract.json id, timingSha256 computed from that file's exact stored bytes, and beats. Each beat has unique id and unique sceneId, integer startFrame/endFrame within the sealed clock, references and points. references is an array of canonical {segmentId,quote,startSeconds,endSeconds} records copied losslessly from timing-contract.json.segments; IDs are unique within the beat and all four values must match that target exactly. Each point has a unique stable id within its beat and a non-empty unique segmentIds array naming only that beat's references; keep its real claim-derived quotation/meaning and all existing semantic/boundary rationale. Singular segmentId, separate quotes arrays or bare segmentIds may not replace references or points[].segmentIds. All identifiers use ^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$. Preserve all existing canonical transcript bindings and semantic scene decisions. If redundant clock fields are included they equal the committed timing clock. Later producers consume these exact committed reference records and point IDs; they may not rebuild them or edit this document. Enforced narrative timing windows (existing shared timing rule): for each point p in beat b compute earliestPointFrame=max(b.startFrame,min over its own p.segmentIds of ceil(segment.endSeconds*fpsNumerator/fpsDenominator)), using the committed timing clock and canonical segment END, never the segment start or a rounded-down frame. Every point must have earliestPointFrame < b.endFrame. Beats remain ordered, non-overlapping and within the source clock; preserve complete truthful semantic/point coverage, canonical own references and boundary rationale. Point-free filler/sign-off beats remain permitted; never manufacture claims or drop a required point to pass. Before sealing, choose semantic boundaries and own-point mappings that leave legal windows while retaining existing support/cadence/gap requirements; a window pass alone does not prove density satisfiability. Use inspect_deterministic_project_inventory before proposing done and after each correction: its narrative report is feedback, not stage acceptance. The frozen planner_narrative_timing barrier measures captured narrative against sealed timing. A correctable:true refusal leaves this stage open: fix only its uncommitted declared outputs, inspect again and re-propose done; do not fail the run at the first correctable finding. You may adjust this stage's own beat boundaries consistently, but may not edit the committed timing, narration, source facts or any earlier snapshot. If an own point's earliest frame reaches the full source-clock end, or the result is upstream_or_unresolved/unmeasurable, report the exact conflict through the existing help/ending path, never retry unchanged or fabricate an earlier anchor. Existing attempt deadline, checks, Judge and repair allowances stay unchanged. Claim content versus verification notes: every point.text and point.meaning states a claim, comparison, step or term actually supported by that point's own sealed canonical quotation, never an instruction to verify it. Preserve exact quotations and segment bindings. When wording, negation, a name or a number is uncertain, do not guess, correct the transcript, erase the claim or assert external verification: use the exact own canonical quotation as an explicitly attributed speaker claim (for example, 'The presenter says: <exact quotation>') in text/meaning. Keep any concern only in optional point.verification={kind:'asr_wording',segmentIds:[own referenced segment IDs],note:<nonblank concern>}; it is non-display QA metadata, not a claim, point, support element, node, relation, change or reveal. Do not create an extra point for a verification concern. This records uncertainty without claiming the audio has been checked or changing existing truthful coverage. Independent pre-seal semantic review: after the measured timing check is feasible and before proposing this stage done, call review_stage_outputs({}). Desktop derives this stage's frozen criteria and held JSON inputs; never supply criteria or verdicts yourself. Only when repairAvailable is true, use the anchored semanticRepairHandoff to correct within its returned editScope, preserve all passing criteria and sealed inputs, then call review_stage_outputs again for fresh review. Do not propose done until a pass, and then preserve the exact reviewed bytes. A reference-owned finding, stopped progress or unavailable review means Needs you through the existing ending path, never an upstream rewrite or unchanged retry. This uses the existing ledger, finding progress, single attempt deadline and correction rules, not a second budget. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check.

  Your model fills this step
• Step 6decision

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/asset-manifest.json, project/shot-manifest.json, project/style-lock.json, project/visual-density-contract.json, and project/visual-evidence-manifest.json; preserve asset/evidence, style, geometry, density, coverage, cadence and flicker constraints. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Canonical portable-bundle authoring: project/asset-manifest.json has exactly root keys contractVersion='asset-manifest.v1' and assets (an array). Preserve real-source asset entries. Each planned asset has a unique id, requestId, kind='planned_asset', status='planned_not_submitted', and materializeTo='public/media/<safe-name>.mp4'; do not use a path field for planned assets and do not create a file at that future destination. Use stable identities that step 7 will reference exactly. Plan the eight provider-eligible shot ranges to satisfy the existing frozen timing rule without padding, stretching or changing the source narration. Additional creative fields on asset rows remain allowed; do not add root-level fields. These filenames are ZIP-root paths when the existing packaging step packages project/. Explicit current stage requirements: Write distinct shot-manifest.json editorial contract, visual-evidence-manifest.json claim classification, and typed discriminated asset-manifest.json for packaged hashed relative files, planned assets and semantic external inputs. Resolve every ID once; validate references/range/text; no invented/dangling IDs or generated illustrations presented as factual proof. Author schema-versioned machine-readable style-lock.json and visual-density-contract.json with typed canonical scene/transcript references and hashes. style-lock.json fixes presenter_overlay as the architecture, explicit full and inset presenter rectangles/crop/objectPosition/safe regions, palette, typography/font metrics, spacing, diagram vocabulary, overlay opacity/z-order, easing/motion limits, and transition rules. Record reference identity and approval only when actually supplied for this attempt; no historical bundle prefix is retrieval or approval authority. Every scene must retain full and inset presenter geometry, continuous presenter audio, transition continuous_presenter_with_overlay_fade, and fallback presenter_with_section_label. Opaque generic full-screen replacement cards are prohibited by default; any semantically justified exception must carry a scene-specific rationale, canonical evidence and bounded frame interval, retain both presenter geometries and continuous audio, and restore the presenter overlay afterward. visual-density-contract.json records rational FPS, half-open integer-frame spoken intervals from canonical transcript, support intervals only for designed support that qualifies under the stage-5 definition, each with semantic purpose/type/scene IDs and its claim-derived elements or relation, meaningful change events, presenter-only gaps and exceptions, plus thresholds supportRatio>=0.65, targetChangeSeconds=[4,8], maxUnexplainedPresenterOnlyGapSeconds=10. Compute coverage as union(support intersect spoken)/union(spoken), never double-count overlapping overlays or count silence; each presenter-only gap is a maximal run of spoken frames not covered by qualifying support, unexplained unless declared exceptions, each with its own reason and frame range, together cover every frame of it, adjacent exceptions being combined, derived from those frames, never by hand; record numerator, denominator, ratio and gap/cadence violations. Derive meaningful change events inside the committed stage-5 beats, never by reopening them: each event reveals a distinct claim-derived point recorded for its beat as a new visual state, never a cosmetic, caption-only or repeated state, placed so changes land every 4–8 seconds without new narrative cuts. Before committing, compute every change interval from these events in global timeline order, each the half-open frame range from one event to the next event or, for the last event, to the end of the timeline; an interval belongs to the event that opens it and may extend beyond the beat or scene of that event. Justify each remaining out-of-range interval individually with its claim and frame range, never as a blanket exception. No exception can silently waive the 65% minimum. Timing completion requirement: use inspect_deterministic_project_inventory before proposing done and after each correction; its density report is feedback, not stage acceptance. Only the Desktop stage barrier can accept the frozen planner_density_timing check over captured bytes. A timing refusal leaves this stage open: for correctable:true, correct only this stage's declared outputs within the sealed narrative beat and re-propose done; do not treat the first correctable refusal as a failed run. For upstream_or_unresolved or unmeasurable inputs, report the exact conflict through the existing help/ending path; never retry unchanged, edit earlier snapshots, clamp narration anchors or drop required points/support/changes to silence a check. The declared stage-semantic review uses the existing per-stage correction ledger and single attempt deadline; it grants no continuation, paid action, independent model retry or stage-9 preparation authority. Any inspector status other than feasible is not a timing pass. Missing later-stage source files are expected, not stage-6 work. A missing runtime/library/check-support capability is a setup blocker, never permission to bypass timing. Canonical reference shape (existing style-lock.v1 and visual-density-contract.v1 consumer contract): style-lock.json has contractVersion='style-lock.v1', a stable root id, narrativeId equal to committed narrative-beats.json.id and narrativeSha256 computed from that file's exact stored bytes, alongside ALL existing style/geometry/motion requirements. visual-density-contract.json has contractVersion='visual-density-contract.v1', a stable root id, timingId/timingSha256, narrativeId/narrativeSha256 and styleId/styleSha256 binding those three documents' exact IDs and SHA-256 of stored bytes; its fpsNumerator/fpsDenominator/durationFrames equal the sealed timing clock. Write the complete style document before hashing it for density. All IDs use ^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$. Keep supportIntervals and use the canonical array name meaningfulChanges, not meaningfulChangeEvents as a substitute. Each supportIntervals row has unique id, sceneId, beatId, startFrame, endFrame and non-empty unique pointIds from that committed beat; retain the required real support type, purpose and claim-derived elements/relation. Its integer half-open range lies within that beat. Each meaningfulChanges row has unique id, sceneId, beatId, supportId, pointId and integer frame, plus the existing real claim/rationale. supportId names an actual supportIntervals row, pointId belongs to that support's pointIds and the same committed beat, and frame lies inside that support's half-open range. Do not substitute supportIntervalId for supportId. Retain and compute all existing spoken intervals, coverage, gaps, cadence, exception records and thresholds; no obligation or semantic requirement is removed by this structural alignment. Compute every cross-file SHA-256 from exact stored bytes, never a JSON-object digest or a copied literal. Stage-4 and stage-5 documents remain immutable; if their required canonical graph is absent or inconsistent report the existing upstream conflict, never normalize or translate it here. Downstream scene authoring and validators must consume this one canonical reference graph, not invent parallel aliases. Canonical density policy fields: thresholds has exactly {supportRatio:0.65,targetChangeSeconds:[4,8],maxUnexplainedPresenterOnlyGapSeconds:10}, preserving the existing policy values. gapExceptions is an array (empty allowed), each row exactly {startFrame,endFrame,reason}, with a non-empty reason and valid integer half-open range within one scene; split a justified cross-scene range into scene-contained rows without changing its covered frames. cadenceExceptions is an array (empty allowed), each row containing changeId, startFrame, endFrame, reason and optionally claim, no other keys; changeId resolves to meaningfulChanges, the integer range is valid within the full clock, reason and any claim are non-empty, changeId is not duplicated, and the existing one-exception-per-actual-change-interval rule remains. Canonical style field names: presenter.full and presenter.inset each contain x,y,width,height,crop,objectPosition and optional safeRegion; these template keys are exact, safeRegion has exactly x,y,width,height, rectangles are finite positive-size and within the 1920x1080 composition, and any safeRegion is inside its presenter rectangle. crop is cover or contain; objectPosition is a two-percentage string with each percentage from 0 to 100. Keep palette as the declared token-to-color map and typography.fontFamily/fontWeight with the existing font metrics; an existing label-character limit is named typography.maxLabelCharacters, not a newly invented limit. The existing overlay settings use root enterFrames, exitFrames (positive integers whose sum fits each scene), overlayOpacity (greater than 0 and at most 1), and easing (linear, cubic_in_out or cubic_out), not a nested motion object as their substitute. Preserve all other required geometry, palette, typography, overlay, motion, transition and fallback semantics. Existing after-narration timing rule: derive earliestPointFrame for each committed beat point as max(beat.startFrame,min of ceil(own referenced canonical segment.endSeconds*fpsNumerator/fpsDenominator)). A meaningful change.frame is at or after its own linked point's earliestPointFrame. Each support.startFrame is at or after the minimum earliestPointFrame of its linked pointIds. Changes and supports still lie within the sealed beat/support half-open ranges and preserve every existing point, semantic qualification, coverage, cadence, gap and exception requirement. Use segment END, never start, and do not round ceilings down. If all constraints cannot be satisfied within this stage's ownership, report the actual upstream conflict; do not weaken checks or rewrite stage 5. Independent pre-seal semantic review: after the measured timing check is feasible and before proposing this stage done, call review_stage_outputs({}). Desktop derives this stage's frozen criteria and held JSON inputs; never supply criteria, verdicts or owner attribution yourself. A semantic refusal leaves this stage open. Only when repairAvailable is true, use its anchored semanticRepairHandoff to correct inside its returned editScope, preserve all passing criteria and sealed inputs, then call review_stage_outputs again for fresh review. For this stage's semantic correction, do not edit other current-stage outputs outside that editScope. Do not propose done until a pass; after a pass, preserve the exact reviewed bytes and propose done. A reference-owned finding, stopped progress or unavailable review means Needs you through the existing ending path, never an upstream rewrite or unchanged retry. Non-display uncertainty metadata: point.verification is QA context only; never use its note as visual text, a claim, a support element, a new point or a reveal. Preserve the sealed point's attributed quotation/claim and all existing canonical bindings, coverage and timing; do not silently resolve or rewrite uncertain wording. Timing legality is decided only by the frozen measured timing check. Here, 'early' means introducing a later point's content out of semantic order, not a new frame threshold. Do not reject a time accepted by that check, require the complete quotation or last segment to finish first, or invent a minimum display duration. Judge semantic content and support structure, not timing arithmetic. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check. Claim ownership for supports and nodes: an element, node or reveal tagged to a point may state only the claim that point’s own text states, as supported by its canonical quotation. Where adjacent points’ quotations overlap, shared quoted words belong to the point whose text states that claim; never place a later point’s claim in an earlier point’s element or state, and never retag it to fit an opening. An opening built from one point qualifies only with its explicit relation. Before calling review_stage_outputs, and before each re-review, check every element and node against this rule.

  Decision step
• Step 7

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/generated-video-requests.json with exactly eight approval-gated planned_not_submitted requests. No provider call, submission, generation, download, render, or media mutation. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Canonical portable-bundle authoring: project/generated-video-requests.json has exactly root keys contractVersion='project-bundle-requests.v1' and requests (exactly eight items). Each request contains requestId, assetId, provider, model, startFrame, endFrame, fpsNumerator, fpsDenominator, requestedDurationSeconds, and outputRelativePath. Retain the full creative prompt and any required approval/planning row fields. requestId and assetId are unique and exactly match a planned asset's requestId and id; outputRelativePath exactly equals that asset's materializeTo. Destinations are unique, case-insensitively, and no planned asset is orphaned. Use integer source-bound startFrame/endFrame with endFrame>startFrame and the actual project's positive rational FPS. Preserve the frozen provider='higgsfield', model='kling3_0', requestedDurationSeconds=5, minExpectedMediaDurationMs=5040. Every range must satisfy (endFrame-startFrame)*1000*fpsDenominator >= 5040*fpsNumerator, using exact integer arithmetic; at 30/1 FPS this is at least 152 frames, not 150. A requested five-second generation and a 5040ms minimum decoded-media requirement are distinct. Allocate suitable narration-supported ranges during planning; never repair this by padding, stretching, submitting jobs, changing frozen timing or mutating source media. These files must be at the ZIP root under existing packaging, not nested under project/. Explicit current stage requirements: Use Higgsfield documentation only to author generated-video-requests.json containing exactly eight distinct approval-gated Kling 3.0 contracts, each planned_not_submitted and no provider call. Include unique IDs, linked semantic scenes, canonical evidence, frames/settings/prompt/negative translation/continuity/compositing/fallback/provenance; eight is budget, not scene count. Validate references; claim no costs/files/submission. Preserve exactly eight approval-gated planned_not_submitted Higgsfield requests, the typed custody contract and all existing validation. The paid clips are supplementary overlay assets, never the visual-density ceiling. Every request maps to approved style tokens and presenter-safe geometry and has a Remotion-native diagram/overlay fallback that meets the same density contract without paid generation. Do not submit requests or increase their count. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check.

  Generate images and videos via Higgsfield AI through 30+ models including Nano Banana 2, Soul V2, Veo 3.1, Kling 3.0, Seedance 2.0, Flux 2, GPT Image 2, plus...

  --- version: 0.3.0 name: higgsfield-generate description: | Generate images and videos via Higgsfield AI through 30+ models including Nano Banana 2, Soul V2, Veo 3.1, Kling 3.0, Seedance 2.0, Flux 2, GPT Image 2, plus Marketing Studio for…

  Full skill: Higgsfield Generate
• Step 8

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Write only project/compositor-scenes.json and project/animation-plan.json; preserve presenter-overlay architecture, scene references, animation, transitions, geometry, continuous audio, fallback, density, cadence and flicker. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: Write distinct compositor-scenes.json mapping frame boundaries to presenter/B-roll lanes, layout, placement/crop, safe regions, typography/factual layers, motion/easing, transitions, planned slots/fallbacks and evidence. Use/validate exact canonical transcript IDs/ranges/text and preserve duration. Author schema-versioned animation-plan.json linked to style-lock.json, visual-density-contract.json and compositor-scenes.json by IDs and hashes. Each scene explicitly carries presenter.full and presenter.inset geometry, continuous audio source/timeline mapping, continuous_presenter_with_overlay_fade and presenter_with_section_label fallback. Define deterministic integer-frame overlay/diagram keyframes, enter/hold/exit windows, easing, z-order, clipping, glyph-safe text reveals, opacity curves and geometry endpoints; include every transition window and meaningful-change event. Maintain an uninterrupted presenter audio lane exactly once over the source timeline; overlay fades must never restart/mute/duplicate presenter audio or reset presenter source time. Full/inset transitions preserve stable geometry and readable complete glyphs. Build semantic Remotion-native diagrams, callouts, comparisons and progressive explanations for qualifying claims across spoken runtime beyond the eight clips; type every scene state as designed_support or presenter_only, map every designed_support state to exactly one stage-6 support interval whose frame range contains it, with each support interval holding at least one such state and its successive states as the progressive reveals of its change events, verify before the stage-8 done heartbeat, with a read-only python3 check that reads the current project files, including its own open stage-8 outputs, and writes nothing, that every such state and change event lies inside its recorded support interval by id and frame range and that no support interval lacks a state, that the designed_support states of each support interval together cover every frame of it, that scenes tile the source timeline and the states of each scene tile that scene contiguously, that at every scene and state boundary the presenter geometry and audio mapping at the closing frame equal those at the next opening frame, any full/inset change being interpolated inside a declared transition window within one scene, that any overlay node visible on both sides of a boundary keeps the same geometry there, while an overlay absent or at zero opacity on either side may relayout without a visible jump, and that each change event is bound one-to-one to the designed_support state that starts at its frame, whose change id names it and whose revealed points add its linked point, which no earlier state of that scene already shows; an opening state may qualify by showing two points, or one point and its explicit relation, and later events then reveal only points not yet shown; on any mismatch while stage 8 is still open, correct only the current stage-8 outputs within this same authoring window, rerun this whole check, never send the done heartbeat while it fails, and stop the stage only if it cannot pass, and never manufacture nodes or support for presenter_only speech; generic sparse full-screen cards are not the default treatment. Timing completion requirement: use inspect_deterministic_project_inventory before proposing done and after each edit; its source report is feedback, not acceptance. Only the Desktop stage barrier can accept the frozen planner_scene_timing check over captured bytes and sealed timing/narrative/style/density. A correctable:true refusal keeps this stage open for an in-scope correction and a fresh done proposal; do not stop the run at the first correctable refusal. Preserve required point/support/change coverage and all sealed earlier inputs. If the finding is upstream_or_unresolved or inputs are unmeasurable, report it through the existing help/ending path; never silently retime earlier decisions or retry unchanged. Do not claim that a report or typed receipt is a Judge pass or rendered visual proof. The declared stage-semantic review uses the existing per-stage correction ledger and single attempt deadline; it grants no continuation, paid action, independent model retry or stage-9 preparation authority. Any inspector status other than feasible is not a timing pass. Existing source-state timing rule: compute each revealed point's earliestPointFrame from that scene's sealed start and the same minimum own canonical segment-END ceiling. Every revealed point must have earliestPointFrame < state.endFrame; a designed_support state must start at or after the minimum earliestPointFrame of its revealedPointIds. Point-bearing nodes and selected narration anchors still obey the existing after-end reveal rules. These constraints coexist with required support/change coverage, contiguous state/scene tiling, presenter continuity and the unchanged independent label check. Do not move earlier density/beat boundaries here; correct only open stage-8 outputs when permitted, otherwise report the typed upstream conflict. Existing supported compositor-scenes.v1 serialization (author the one shape the scene importer and timing inspector already consume, not a new format): put contractVersion='compositor-scenes.v1', id, timingId, timingSha256, styleId, styleSha256, densityId, densitySha256, width=1920, height=1080, fpsNumerator, fpsDenominator, durationFrames, an audioLane object and a nonempty scenes array at the document ROOT. The three clock fields equal the sealed timing record; dimensions are the existing output composition, not the presenter probe. A nested composition object is not a substitute. IDs are strings matching ^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$; SHA-256 pins are 64 lowercase hexadecimal characters calculated from the exact stored referenced bytes, never invented or reserialized. Root timing/style/density IDs and pins resolve to the committed timing-contract.json, style-lock.json and visual-density-contract.json. The existing narrative/density/style reference graph and clocks must agree. Each scene has a unique id, beatId, integer 0<=startFrame<endFrame<=durationFrames, exact references rows with ONLY {segmentId,quote,startSeconds,endSeconds}, and nonempty states. Scene inventory, id/beatId, bounds and ordered reference rows equal the sealed narrative beats; each reference exactly matches its canonical timing segment, with unique segmentId, nonempty quote and finite 0<=startSeconds<=endSeconds. Each state has its scene-local unique id, kind='designed_support' or 'presenter_only', and integer bounds within the scene. Presenter-only states may omit revealedPointIds/nodes or use empty arrays; never invent support content for them. Designed-support states have unique nonempty own-beat revealedPointIds, supportId, changeId, nonempty relation and nonempty nodes covering every revealed point. The linked support matches scene/beat, contains the state and covers its points; the linked change matches scene/beat/support, occurs at the state's start and names one revealed point. Referenced support/change inventories exactly equal the sealed density inventories. Every node has a state-local unique, scene-stable id, pointId from that state's revealed points, nonempty text, finite x/y/width/height with positive width/height, safe-integer revealFrame inside the scene and safe-integer zIndex. Use text, not label as an alias; keep the same node id bound to the same point across cumulative states. Retained nodes may have a revealFrame before the current state's start; preserve their actual original reveal and all existing after-narration, geometry, continuity and visibility rules. Strings used as text/relation/quote are nonblank and at most16384characters; current importer limits remain16MiB UTF8 JSON/depth32/1000scenes/10000states/100000node occurrences, with no duplicate JSON keys or nonfinite numbers. Update animation-plan's existing compositor ID/exact-byte hash after the final scene write. Inspect again before proposing done; this supplies the existing consumer serialization only, with no new scene_execution_contract block, labels array, check, criterion, allowance or timing/creative relaxation. Independent pre-seal semantic review: after the measured timing check is feasible and before proposing this stage done, call review_stage_outputs({}). Desktop derives this stage's frozen criteria and held JSON inputs; never supply criteria, verdicts or owner attribution yourself. A semantic refusal leaves this stage open. Only when repairAvailable is true, use its anchored semanticRepairHandoff to correct inside its returned editScope, preserve all passing criteria and sealed inputs, then call review_stage_outputs again for fresh review. For this stage's semantic correction, do not edit other current-stage outputs outside that editScope. Do not propose done until a pass; after a pass, preserve the exact reviewed bytes and propose done. A reference-owned finding, stopped progress or unavailable review means Needs you through the existing ending path, never an upstream rewrite or unchanged retry. Non-display uncertainty metadata: point.verification is QA context only; never use its note as visual text, a claim, a support element, a new point or a reveal. Preserve the sealed point's attributed quotation/claim and all existing canonical bindings, coverage and timing; do not silently resolve or rewrite uncertain wording. Timing legality is decided only by the frozen measured timing check. Here, 'early' means introducing a later point's content out of semantic order, not a new frame threshold. Do not reject a time accepted by that check, require the complete quotation or last segment to finish first, or invent a minimum display duration. Judge semantic content and support structure, not timing arithmetic. Animation phase interval contract: for each nonempty designed-support state [S,E), its enter, hold and exit endpoints are integers satisfying S = enter.startFrame <= enter.endFrame <= hold.startFrame <= hold.endFrame <= exit.startFrame <= exit.endFrame = E. The window's state/change identity and outer bounds match that same state. Zero-width phases are allowed and mean instantaneous transitions; they are not invalid ranges and must not cause division by zero or zero-length interpolation. For a short state, shorten or omit transitions to fit these inequalities; for example enter [S,S), hold [S,E), exit [E,E). Never overlap phases, extend a state, move sealed timing, add a minimum display duration, or drop a required point to fit a fade. Include every animation window in the existing mandatory read-only stage-8 whole check before review or done. If it fails while stage 8 is open, correct only stage-8 outputs; if compositor-scenes.json changed, update animation-plan's compositorSha256; rerun that whole check; do not seal a failing animation plan. Before this stage’s done heartbeat, and at a stage with a declared semantic review before calling review_stage_outputs and again before any re-review after a correction, read-only check that every hash, reference, count, total and restated value in this stage’s outputs that are members of the frozen projectBundleContract.files inventory equals its recomputation from the primary records or bound inputs it names, under the existing stage-9 role rules: hashes name declared inventory file bytes or bound input identities, references resolve within their declared collection and scope, and counts/totals are recomputed from the primary records they count. Use only evidence available at this stage; later producer outputs are not prerequisites. Correct only this stage’s owned outputs while it remains open; preserve all existing facts, checks, audit evidence and scope. This is an authoring self-check, not trusted preparation or a new platform check. Claim ownership for supports and nodes: an element, node or reveal tagged to a point may state only the claim that point’s own text states, as supported by its canonical quotation. Where adjacent points’ quotations overlap, shared quoted words belong to the point whose text states that claim; never place a later point’s claim in an earlier point’s element or state, and never retag it to fit an opening. An opening built from one point qualifies only with its explicit relation. Before calling review_stage_outputs, and before each re-review, check every element and node against this rule.

  Best practices for Remotion - Video creation in React

  --- name: remotion-best-practices description: Best practices for Remotion - Video creation in React metadata: tags: remotion, video, react, animation, composition --- ## When to use Use this skills whenever you are dealing with Remotion…

  Full skill: Remotion Best Practices
• Step 9

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Stage-9 authoring/inventory sequence, in this exact order: (1) Before authoring, read-only confirm that the Desktop-preseeded project/ contains package.json, remotion.config.ts, tsconfig.json and an empty reserved node_modules directory. If any static file or reservation is absent, unreadable, or the reservation is nonempty, stop without writing or recreating them. This is only a read-only presence/reservation check; the later Desktop inspector owns frozen-byte and mismatch verification. (2) Write exactly the nine already-owned stage-9 files: project/delivery-qa-contract.json, project/dependency-compatibility.json, project/reference-validator.py, project/validate.py, project/src/PresenterVisualTreatment.tsx, project/src/Root.tsx, project/src/index.ts, project/src/loaders.ts, and project/src/validation-core.ts. Preserve all prior stage outputs. Verify that all nine are present, nonempty regular files without symlinks. Desktop owns platform_static package.json, remotion.config.ts and tsconfig.json. Perform no npm, npx, tsc, Remotion, provider, render, package management, typecheck, discovery or validation command, except this one authored-validator self-run: after the nine files pass these checks and before step (3), run python3 -B project/validate.py project over the currently authored inputs; validate.py must also run reference-validator.py's checks. It must write nothing and must not install, typecheck, discover, render, or create reports, a lockfile or receipts. The stage-11 reports, lockfile and trusted preparation evidence are expected absent; the validators must handle that through an explicit pre-lock mode, never by weakening their post-lock checks. Its result is not preparation evidence. If it fails, treat each reported failure as a diagnostic: make an in-scope correction to only the nine owned stage-9 files, never to prior-stage outputs, original inputs, static files or Desktop-owned checks, and never weaken, remove, skip or special-case a check to make it pass; then rerun it. Rerun only after such a correction, and stop before inventory with the typed self-run failure if a rerun reports any failure an earlier run already reported, or if a failure can only be fixed in a prior-stage output or original input. Reruns are the same pre-lock self-run, never preparation evidence, and grant no preparation repair. Stray-file cleanup, same stage only: as the sole narrow exception to the blanket no-deletion instruction below, if during this attempt’s stage-9 authoring, before inspect_deterministic_project_inventory and before FIRST preparation/lock, this worker itself created an undeclared stray regular file under project/ that is not any declared output and is empty (zero bytes), it may remove only that exact file using unlinkSync and must name it in its stage-9 done heartbeat. Verify it did not pre-exist stage 9 and remains an empty regular file. This never extends to pre-existing or Desktop-preseeded entries, nonempty files, directories, symlinks, prior-stage outputs, original inputs or failed/rejected evidence, and never permits deletion after inventory/preparation/lock. Uncertain ownership means stop rather than delete. No recursive cleanup, renaming or replacement. This is authoring cleanup, not an extra repair grant; all other no-deletion and repair restrictions remain unchanged. (3) Only AFTER all nine files are authored and their presence/nonempty/regular-file/no-symlink checks pass, call inspect_deterministic_project_inventory({}) exactly once. This is the final pre-lock check, never a pre-authoring diagnostic. Require ready:true, zero missing and zero mismatch; otherwise stop with its typed cause and do not call prepare_deterministic_project. (4) Then call prepare_deterministic_project({}) and require its trusted accepted receipt before the stage-9 done heartbeat; consume only the trusted receipts. If and only if the returned measured typecheck/discovery refusal is explicitly retryable under dependencyContract.preparationRepair, or a typed deterministic_project_semantic_contract_failed refusal is explicitly retryable under that same existing preparation ledger, keep stage 9 open, use the actual returned diagnostic, and make scoped same-stage code corrections only while the preparation ledger explicitly authorizes the next repair index to src/PresenterVisualTreatment.tsx, src/Root.tsx, src/index.ts, src/loaders.ts, src/validation-core.ts and reference-validator.py, relative to the existing projectRoot. Desktop preserves the refusal receipt, custody evidence and source captures in the existing preparation ledger; do not save copies or repair reports. Correct only these six already-owned code outputs; do not edit prior-stage data, static files, package/lock/dependencies, Desktop-owned checks, frozen criteria, scope or any other files. A correction to reference-validator.py may change its role classification or comparator only to match the TypeScript validator and the unchanged criterion requirements, never to remove or relax a check; validate.py remains outside repair scope. Then re-call prepare_deterministic_project({}) for fresh Desktop-owned deterministic checks and an independent source Judge against the identical frozen dependencyContract.preparationRepair.semanticReview criterion. Every correction must be freshly prepared and independently reviewed against the identical frozen criteria before the stage-9 done heartbeat. The existing preparation ledger controls the shared measured/semantic progress policy: an initial correctable refusal permits the first correction; each later refused preparation permits another only when at least one additional measured check or frozen criterion passes and no previous pass is lost. Use the returned repairProgress and next repair index, never infer progress from changed prose, lines or source hashes. A no_progress, regression, not_correctable, unavailable preparation/source Judge or needsYou result stops as NeedsYou. No independent model retry or restart outside an explicitly authorized scoped correction. No worker npm or preparation bypass, directory reset or cross-stage repair. Repair exhaustion or needsYou stops as NeedsYou; integrity, authority, custody, install/infrastructure and timeout refusals remain terminal. Stage 10 remains read-only and cannot reopen committed stage 9. This adds only source-semantic binding review, no render, visual or taste Judge criterion and no cross-stage pipeline or budget. Accepted preparation locks outputs as before. No claim that terminal v25 can resume. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: Implement all three new JSON contracts through typed loaders, strict schemas, cross-reference validators and actual manifest-driven Remotion components, not documentation-only promises. Derive overlays, diagrams and transitions deterministically from useCurrentFrame and configured FPS with interpolation/spring as appropriate; no wall-clock timers, CSS autonomous animation or unseeded randomness. Render one continuous presenter audio lane and persistent source-time mapping with stable keys; keep full/inset geometry available in every scene, and implement continuous_presenter_with_overlay_fade plus presenter_with_section_label. Stage 10 will read-only verify these same already-stated requirements, so implement and self-review them here before preparation: meaningful visual/content changes targeted every 4–8 seconds, no unexplained presenter-only gap >10 seconds, and per-scene full/inset geometry actually consumed by the presenter renderer, not merely declared. Cosmetic highlighting, opacity or radius changes alone do not constitute meaningful content-state changes. Implement the machine-readable delivery-qa-contract.json downstream delivery/QA contract and executable checks specifying MP4 H.264 profile High or Main (never High 10/4:4:4), yuv420p 8-bit, limited/tv range BT.709 primaries/transfer/matrix, AAC audio and QuickTime-safe playback. Require an actual color conversion when input differs, not metadata relabeling; hardware playback evidence must reference the final encoded artifact SHA-256. Author these checks without rendering or launching playback in this planning-only agent. The three contracts are style-lock.json, visual-density-contract.json and animation-plan.json. Implement their strict schemas and cross-reference/density/frame-state checks inside the declared loaders.ts, validation-core.ts, reference-validator.py and validate.py, without adding undeclared files. Produce complete typed components consistent with the preseeded TypeScript configuration. Register composition PresenterVisualTreatment at 1920x1080, this verified source's rational FPS, and its source-derived durationFrames. No historical 21320-frame constant. Record the existing frozen exact dependency pins and compatibility metadata; never author or rewrite Desktop-owned package.json, tsconfig.json or remotion.config.ts, and never generate the lockfile yourself. Implement the read-only planning checks described in stages 10, 12 and 13 in these owned files before preparation; do not run extra validation commands beyond the step-(2) authored-validator self-run. Stage-9 final-review self-check, consolidating existing requirements only: before inspect_deterministic_project_inventory and before FIRST preparation/lock, verify that the owned validators and delivery-qa-contract.json already implement, in executable form, every check that stages 12 and 13 will apply read-only after the lock. Stage 12 will “reject sparse designed support, unsupported coverage arithmetic, missing transition windows, wrong presenter architecture, generic opaque card defaults, duplicated tiles/quadrants, partial-glyph reveals and frame-unstable geometry”, and requires the downstream QA contract to require “continuous-motion viewing of the entire final timeline at normal speed plus frame-by-frame inspection of EVERY transition’s entire enter/exit window and adjacent frames”, “timestamped evidence, inspected ranges, expected/observed style-lock values and final artifact SHA-256”, and “independent ffprobe validation of H.264 High/Main, yuv420p 8-bit limited-range BT.709 and AAC, plus actual hardware-accelerated playback on the target Mac in QuickTime or a verified hardware playback path, recording player/device/decoder evidence, duration and observed decode errors/stalls/audio-sync results”. Stage 13 will “inspect only extracted ZIP bytes for path safety, exact inventory/hashes/sizes, imports, schemas, canonical transcript references/text, rational timing/once-only duration coverage, typed presenter binding and eight one-to-one approval-gated planned_not_submitted request/asset/destination identities” and “read-only verify packaged executable style/density/fallback/frame-state/encoding/playback handoff requirements and current trusted preparation evidence”. For these checks, a recorded hash never substitutes for a required value: where a value is required, the strict schema must carry the actual expected and observed value. Path-safety clarification: path-safety checks apply to actual filesystem references, meaning any path that is read, written, imported, bound as an input or emitted as a file location, and they must not treat the validator’s own rejection-pattern string literals as such references; this is not an exemption, and any real local absolute or machine-local path used as a file reference anywhere in the bundle still fails. This self-check adds no new criterion, threshold, file, inventory member, repair grant or budget; if it finds a gap before the lock, correct only the nine owned stage-9 outputs within this same authoring window. This self-check explicitly includes two stage-10 comparisons: every hash or canonical reference that style-lock.json, visual-density-contract.json, animation-plan.json, the eight requests, density support entries and asset scenes link to must be compared by executable validator code, not only stored; and support coverage counts only designed_support states that change visual content and qualify under the stage-5 definition, so caption-only, cosmetic-only and presenter_only states never count as meaningful support; the supported frame set is the union of the evaluated qualifying designed_support state ranges intersected with canonical spoken frames, never the declared support intervals, and support ratio, supported and spoken frame counts and presenter-only gaps are recomputed from that set and compared with their declared values; cadence likewise counts only meaningful change events each bound one-to-one to the evaluated designed_support state that reveals it, whose change id names that event, whose start frame equals its frame and whose revealed points include its point, so a declared event without exactly one such state, or such a state without its event, fails and never counts; presenter_only states remain valid without nodes or support intervals, and each designed_support state lies inside exactly one support interval while each support interval holds at least one designed_support state, and any declared coverage figure must equal the value the validators compute. Generate those comparisons from the strict schemas you author, not by choosing fields by hand: each validator declares one role map keyed by full schema path, never by bare field name, covering every reference, hash, count, total, gap and coverage figure in the documents it parses. loaders.ts parses only the render inputs it consumes; future stage-10/11 report schemas and checks live only in the Python validators as pure functions over explicitly supplied report evidence, applied only when those reports exist, never requiring or creating them earlier. Where both parse a document, every leaf must have the same role, comparator class and target in both validators. Before first preparation, verify that coverage is recomputed from every canonical transcript segment rather than a declared subset, and that an observed non-primary probe field is never classified as a primary source fact: it is metadata unless restated or used to compute timing; compare a restatement to presenter-source and recompute a derived timing. Shared validation core: src/validation-core.ts is the only implementation of every reference, hash-target, recomputation, coverage, gap and cadence comparison and exports the one canonical role-map constant they run from. It is pure dependency-free TypeScript with erasable types only: no imports, Node, DOM or browser API, JSX, file, network or process access, import side effect or hardcoded record value. Its one function takes the raw parsed records plus byte SHA-256 values its caller computed from the exact stored bytes, and returns typed failures and the map projection of path, role, comparator and target. loaders.ts keeps its strict schemas, re-exports that map as its exported role-map constant, asserts completeness against its own schema objects, imports the core extensionlessly and evaluates every predicate through it. validate.py keeps only its structural and report schemas and holds no copy of any role-map row, role, comparator, target or leaf-path list; in each run it hashes the exact stored bytes of every currently present regular file in the frozen projectBundleContract.files inventory, never selecting files by hash-field role, name or suffix, asserts that for every document both validators parse the leaf-path set in the projection the core returns equals the leaf-path set it introspects from its own structural schema, and in both its pre-lock self-run and existing post-lock validation runs the same core as a bounded read-only child of the stage-2 recorded Node with --experimental-strip-types --input-type=module-typescript, importing the absolute core path and passing the raw records and its own byte hashes as JSON on stdin; it installs and writes nothing, uses no network, and any nonzero exit, timeout or failure fails the validation. No comparison or role map exists outside the core and no caller supplies a value the core must compute. loaders.ts builds its comparisons from one exported role-map constant and asserts at module load, by introspecting its own schema objects rather than any hand-maintained leaf list, that every scalar schema leaf has exactly one role-map entry, as identifier, hash, primary source fact, measured metric (including every duration, count, total, gap and coverage figure derived from other records), policy constant or metadata; primary source facts are only the observed stage-1 media-adapter probe values recorded in presenter-source (duration seconds, rational fps, width, height, pixel format and stream count), type- and range-checked, never compared with copied literals or treated as metadata, while durationFrames and every other frame count, duration or timing, including transcript and composition timing, is derived and recomputed from them and other primary records under the existing stage-4 timing rules, and that every identifier, hash and measured-metric entry has a comparison that runs; a missing or unlisted leaf throws. That introspection uses explicitly typed parameters and callbacks under strict mode, never an implicit any; each identifier, hash and measured-metric entry is a compact data row that names one shared comparator function for its class (reference resolution, hash comparison or recomputation), defined once in src/validation-core.ts and called from loaders.ts, and the full schema path of the declared collection or source records it uses, never a per-leaf function or an undeclared or vague target; the coverage assertion proves completeness only, never substituting for those comparisons. The same module-load assertion also throws unless every hash entry that names a project file is checked by exactly one literal-URL byte verification whose expected values are collected from the role-map hash entries naming that file, never from a separately maintained list, and every other hash entry is a custody reference naming its bound input identity. Before inspect_deterministic_project_inventory, review every loaders.ts role-map entry against these role definitions and trace in the code that its named comparator actually executes against its declared target for every instance of that field; a declared comparator name or target string is not execution. If any identifier, hash or derived figure is filed as metadata, or any entry lacks that executed comparison, correct only the owned stage-9 files within this same authoring window. Keep all six edit-scope source files (the five TS files and reference-validator.py) together within 96 KiB (98,304 bytes), leaving headroom for progress-authorized same-stage corrections under the 128 KiB source-Judge limit. Each entry reads its values through a typed accessor over the parsed, schema-validated document, never a generic runtime path walker: arrays of primitive identifiers or hashes stay primitive leaves, parent context comes only from declared object collections, and every union is narrowed by its declared discriminant before member-specific fields are read. Each identifier or identifier array names its target collection, that collection's identity field and the parent scope it must resolve within, never a global pool or fallback field; identity values are unique within that scope. Each SHA-256/hash names its targetFile and value path. A hash of a project file is verified only by SHA-256 of that file's exact stored bytes: the Python validators read it in binary, and loaders.ts reads the same bytes through one literal URL per named project file, such as new URL("../transcript.txt", import.meta.url), never a variable or computed path, then fetch and crypto.subtle.digest, adding no config, dependency or file; calculateMetadata must await every such verification before the composition is accepted, while imported JSON render records stay parsed and compared; never a field against itself, re-serialized JSON or decoded text. A hash of input media outside the project is a custody reference: compare it with the bound input identity recorded by a different stage and never call it byte-verified. Each derived metric, including every count, total, gap and coverage figure, is recomputed from primary records (canonical spoken frames and typed scene, support and timing records), never from another declared summary of the same quantity, and compared only with that recomputation; gaps follow the stage-6 definition; explained status comes only from declared exception records validated against the recomputed frames, never from reasons a validator writes or narration it reads: each record carries its own non-empty declared reason and integer frame range; a gap is explained when the union of declared gap-exception ranges, adjacent or overlapping ranges combined and any range allowed to extend beyond the gap, covers every frame of it; each cadence exception justifies exactly one recomputed out-of-range change interval with that interval's frame range and its claim, as stage 6 requires; a count of validated exception records may be their list length, while recorded gap and cadence violations are recomputed from the frames; each policy constant such as a threshold, target or limit is declared in the schema as its exact contract literal, so any other declared value is rejected, is never annotated or compared as computed, and a metric is checked only against that validated value by the stated inequality, converting seconds to frames through the verified rational fps rather than any hardcoded frame count. Never classify a field by name, suffix or untyped walk; booleans and other metadata stay type-checked, never identities. Metadata is only descriptive content that no record, validator or renderer joins on, looks up, scopes, times or counts by, such as free text, prompts, labels, quotes, style and display values and descriptive flags. A leaf whose value must equal, select or resolve to a value in another record is an identifier at every nesting depth, including element, point, state, change and semantic-key ids, and the one shared reference comparator resolves it only within its declared parent scope. A frame range authored by an earlier stage plan, such as a planned asset range or a declared exception range, is a measured metric checked by its stated containment and inequality against the primary scene, support and timing records, and every restatement of it in another document, such as a request range, is recomputed equal to the record it restates. A value an earlier stage freezes, such as the stage-7 provider, model, requestedDurationSeconds, minExpectedMediaDurationMs and the exactly-eight request count, is a policy constant declared as its schema literal or exact array length and referenced through that validated value, never metadata with a separate copied-literal assertion and never recomputed. Stage-9 typed scene-loader authoring requirement: In src/loaders.ts, parse the complete compositor-scenes document through its existing strict typed schema before exporting scenes; infer Scene from that parsed result. Preserve and narrow supported geometry crop values using schema literals/enums compatible with React.CSSProperties['objectFit'], and have presenter rendering consume only these validated typed scenes. Do not export scenes directly from unparsed JSON. Preserve existing output semantics and all schema, cross-reference and boundary checks. Do not use any, an unchecked cast, ts-ignore, disabled strict mode, suppressed compiler errors or a weaker check to bypass this requirement. Stage-9 future-report schema authoring requirement: Before inspect_deterministic_project_inventory and before preparation locks reference-validator.py/validate.py, declare and implement strict versioned schemas in those existing owned validators for the future stage-11 reports lock-validation.json, project-manifest.json, readiness.json and stage10-validation.json. Declare these schemas during stage-9 authoring before any of those reports exists; their absence before stage 11 is expected and must not require premature report creation. Each report schema must cover its complete root and every nested object/array shape, explicitly specify required and optional fields, supported version discriminators, types and value constraints, and reject unknown fields at every object level, including nested array items. Do not infer a schema from report contents, accept arbitrary dictionaries/unknown payloads, or weaken any existing validation or semantic/cross-reference check. Encode the complete report shapes needed by the unchanged stage-11 authoring obligations so stage 11 can author conforming reports and the frozen validators can validate them once produced, including inventory member roles/sizes/SHA-256, the sole project-manifest self-hash exclusion, actual trusted receipt identities/check outcomes, and separate planning_complete, implementation_contract_ready and render_ready=false. Keep declarations inside the existing owned validator files; add no schema files or inventory members. Preserve all stronger checks and the unchanged producer ownership, lock boundary, six-code-file same-stage correction scope and one shared progress-based correction policy. Animation phase interval contract: for each nonempty designed-support state [S,E), its enter, hold and exit endpoints are integers satisfying S = enter.startFrame <= enter.endFrame <= hold.startFrame <= hold.endFrame <= exit.startFrame <= exit.endFrame = E. The window's state/change identity and outer bounds match that same state. Zero-width phases are allowed and mean instantaneous transitions; they are not invalid ranges and must not cause division by zero or zero-length interpolation. For a short state, shorten or omit transitions to fit these inequalities; for example enter [S,S), hold [S,E), exit [E,E). Never overlap phases, extend a state, move sealed timing, add a minimum display duration, or drop a required point to fit a fade. Apply this exact predicate in the existing stage-9 validators and renderer, including instantaneous-phase handling; do not invent a different phase-duration or ordering requirement. All other existing schema, reference, measured and semantic checks remain mandatory.

  Best practices for Remotion - Video creation in React

  ↳ same skill as step 8 (Remotion Best Practices)

  Full skill: Remotion Best Practices
• Step 10decision

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Only consume and verify the trusted preparation receipt from step 9. Read-only verification: no validation commands or project mutation. The sole added write is verification/preparation-verification.json outside project/, recording actual trusted preparation receipt identity, the checked file hashes, checks and outcomes. It is not a substitute for the trusted preparation receipt and must never fabricate a pass. Preserve typed failure and no-repair behavior. Stage 10 remains read-only and may not reopen committed stage 9; the single scoped measured preparation correction is available only while stage 9 remains open before accepted preparation and its done heartbeat. Explicit current stage requirements: Verify actual trusted preparation evidence rather than expected values: exact pinned dependencies, genuine immutable lockfile/root/installed-entry agreement, accepted typecheck and a discovered PresenterVisualTreatment listing with width 1920, height 1080, this attempt's verified FPS and durationFrames. A self-declaration or exit zero without the required evidence is not proof. Preserve recoverable transcript timing warnings separately from dependency warnings. Read-only compare style/density/animation manifests and executable validation logic: support union coverage >=0.65 including the all-eight-paid-assets-unavailable fallback, meaningful changes targeted every 4–8 seconds, no unexplained presenter-only gap >10 seconds, per-scene full/inset geometry, continuous once-only audio, explicit transitions/fallbacks, glyph-safe opacity/clipping and stable tile identities. Record actual observed checks and missing evidence honestly. Do not re-run preparation, install, typecheck or discovery or mutate project bytes.

  Decision step
• Step 11

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. After accepted step-10 receipt verification, write only project/README.md, project/lock-validation.json, project/project-manifest.json, project/readiness.json, and project/stage10-validation.json, then assemble exact 34-file project-bundle.zip. Preserve inventory, hashes, custody, portability and separate readiness. No npm, npx, tsc, Remotion, renderer or provider commands. Authoring invariant: project/ is an existing Desktop-owned pre-seeded tree. Before authoring inspect its existing entries. Never delete, rename, replace, recursively clear, use rmSync, rm -rf, recursive deletion, or directory replacement against project/ or any descendant; create needed subdirectories only with mkdirSync(..., {recursive:true}) preserving existing entries. Create or overwrite only deterministic authoring-contract files with mode 'stage_output' whose producerStage is this current stage. Never modify mode 'platform_static' files or any scaffold-contract file: they are Desktop-preseeded and digest-pinned. To reset worker-owned output, overwrite that file only, never its containing directory. project/node_modules is a Desktop-reserved dependency root: it must remain empty and completely untouched until Desktop deterministic preparation installs into it; do not create, populate, delete, rename, replace, chmod, or otherwise mutate it. At deterministic freeze/inventory, fail closed on Desktop typed integrity refusals deterministic_project_reserved_dependency_root_missing, deterministic_project_path_missing, deterministic_project_path_unreadable, deterministic_project_scaffold_mismatch, deterministic_project_inventory_mismatch, and deterministic_project_inventory_incomplete; do not recreate any missing reservation or scaffold file and do not repair after refusal. Any media-adapter operation uses run_media_adapter_operation only, never a shell wrapper or shell session. Explicit current stage requirements: The exact ZIP-root inventory is ["README.md","animation-plan.json","asset-manifest.json","compositor-scenes.json","creative-direction.json","delivery-qa-contract.json","dependency-compatibility.json","generated-video-requests.json","lock-validation.json","narrative-beats.json","package-lock.json","package.json","presenter-source.json","project-manifest.json","readiness.json","reference-validator.py","remotion.config.ts","shot-manifest.json","src/PresenterVisualTreatment.tsx","src/Root.tsx","src/index.ts","src/loaders.ts","src/validation-core.ts","stage10-validation.json","style-lock.json","timing-contract.json","transcript-validation.json","transcript.json","transcript.srt","transcript.txt","tsconfig.json","validate.py","visual-density-contract.json","visual-evidence-manifest.json"]. Package these 34 files only, with no project/ prefix. Build a path-sorted inventory of member roles, byte sizes and SHA-256; project-manifest.json is the sole explicitly declared self-hash exclusion, not an excluded ZIP member. ZIP members and declared inventory must match exactly. Exclude node_modules, original presenter bytes, generated media, local absolute paths and local preflight receipts. Portable external-input binding must retain source identity without an old-run or absolute-file dependency. All pre-lock files and the Desktop-generated package-lock.json remain immutable after accepted preparation. Only the five current stage-11 files may be authored here. Record separate planning_complete, implementation_contract_ready and render_ready=false, and actual receipt identities without fabricated evidence.

  Best practices for Remotion - Video creation in React

  ↳ same skill as step 8 (Remotion Best Practices)

  Full skill: Remotion Best Practices
• Step 12decision

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Read-only adversarial review of completed bundle. Emit typed failure with no repair on failure. Preserve checks for planning-only scope, eight requests, presenter-overlay style, support arithmetic, cadence, transitions, generic-card ban, duplicated tiles, glyph clipping, geometry and downstream motion/encoding/hardware handoff. No validation command or project/bundle mutation. The sole added write is verification/adversarial-review.json outside project/, recording the actual candidate ZIP identity, SHA-256, byte size, checks and outcomes. The output named reviewed_project_bundle is this review receipt, not a replacement ZIP. Failures remain typed failures; never fabricate a pass. Explicit current stage requirements: Adversarial review must explicitly reject sparse designed support, unsupported coverage arithmetic, missing transition windows, wrong presenter architecture, generic opaque card defaults, duplicated tiles/quadrants, partial-glyph reveals and frame-unstable geometry. The downstream QA contract MUST require continuous-motion viewing of the entire final timeline at normal speed plus frame-by-frame inspection of EVERY transition's entire enter/exit window and adjacent frames. Sampled stills or a contact sheet cannot prove motion. Require timestamped evidence, inspected ranges, expected/observed style-lock values and final artifact SHA-256, rejecting flicker, partial-glyph flashes, duplicated tiles/quadrants, unstable geometry, sparse coverage and deviation from approved presenter-overlay style. Require independent ffprobe validation of H.264 High/Main, yuv420p 8-bit limited-range BT.709 and AAC, plus actual hardware-accelerated playback on the target Mac in QuickTime or a verified hardware playback path, recording player/device/decoder evidence, duration and observed decode errors/stalls/audio-sync results. Software decode alone cannot count as a hardware test. Missing playback access/evidence means downstream delivery remains unverified, never a fabricated pass. Planner only authors/verifies this executable handoff contract; it does not render, generate or test media playback.

  Decision step
• Step 13decision

  Hard barrier: require accepted preceding done heartbeat and accepted current-stage heartbeat; on completion record done heartbeat with stepClassification and SHA-256 checkpointDigest and wait for ok:true. Planning-only. The explicit requirements in this complete current chain and its frozen input, bundle, dependency, authoring, lifecycle and Manager bindings are authoritative. There is no requirement to retrieve a historical version, old bundle or previous run. Preserve all currently supplied Manager selection, disclosure and handling obligations; never invent learned rules, grants or receipts. Exactly eight provider requests remain planned_not_submitted and approval-gated; no paid generation, provider submission, rendering or Compositor launch. No direct npm, npx, package-manager, tsc or Remotion execution: only the existing Desktop-owned preparation call at stage 9 may prepare dependencies and run its frozen checks. Read-only extracted-bundle verification of paths, inventory, hashes, trusted receipts and references only. Do not run npm, npx, tsc, typecheck, Remotion discovery, rendering, providers, commands or repairs. On success declare and settle artifact under current terminal semantics; on failure typed-block. Preserve planning_complete and implementation_contract_ready while render_ready=false. After all existing checks actually pass, write only verification/extracted-bundle-verification.json outside project/ and a distinct byte-identical copy project-bundle-validated.zip of the original step-11 project-bundle.zip. Record checked receipt identities, actual checks and outcomes, original/copy SHA-256 and byte sizes, and require equality. Never rebuild the ZIP or modify the original or project/. Declare the copied ZIP as project_bundle only after successful verification; the review receipt is not the ZIP. Do not execute additional verification commands or perform repairs. Explicit current stage requirements: Independently inspect only extracted ZIP bytes for path safety, exact inventory/hashes/sizes, imports, schemas, canonical transcript references/text, rational timing/once-only duration coverage, typed presenter binding and eight one-to-one approval-gated planned_not_submitted request/asset/destination identities. Import verification resolves package specifiers against existing evidence only, using the extracted ZIP bytes and the trusted receipts already required. For a bare module specifier in a packaged.ts or.tsx file, the package root is its first path segment, or its first two segments when the first begins with @; that root, never the full specifier, is compared with the declared dependencies and devDependencies of the packaged package.json. A remaining subpath of a declared root is valid when its importing file is a platform_static file whose bytes equal the frozen scaffold contract, or a src/ file inside the frozen tsconfig include whose exact bytes, per the existing inventory/hash and trusted-preparation checks, the accepted stage-9 preparation typechecked under that tsconfig's Bundler package-exports resolution with the packaged package-lock.json; a subpath with neither evidence fails, and no specifier, package or subpath is accepted by name or list. Relative specifiers and packaged Python imports keep their existing checks. Read-only verify packaged executable style/density/fallback/frame-state/encoding/playback handoff requirements and current trusted preparation evidence. Preserve the no-extra-validation-command and no-repair rules: no second clean install, typecheck, composition discovery or preparation. Report planned visual-support percentage, change cadence and longest unexplained presenter-only gap as planning metrics; downstream continuous-motion/encoding/hardware-playback remains not_run until a real rendered artifact provides evidence. Rendering evidence is not required for otherwise valid planning-only completion, and planning readiness is never finished-video QA. After the accepted stage-13 done heartbeat and required artifact declarations, use the authenticated current-request terminal path exactly once for completed planning output, without a hold solely because generation/rendering remains gated. Require accepted completion intent and subsequent Desktop settlement; worker intent alone is not verified delivery. Call learned-decision handling only for the exact actually supplied decision set; never an empty fabricated set. Preserve all current competence-handling and artifact-bound terminal gates.

  Decision step

common questions

1. v84Oct 17manual

   Clarify point claim ownership across overlapping quotations for stage6 supports and stage8 nodes; all other contracts unchanged.

2. v83Oct 17manual

   Check producer evidence bindings before seal and derive timing counts from canonical flags; all other contracts unchanged.

3. v82Oct 17manual

   Clarify portable hash targets and existing audit preservation at stage3; all other contracts unchanged.

4. v81Oct 17manual

   Freeze matching animation phase interval semantics at stage8 authoring/self-check and stage9 validation/rendering.

5. v80Oct 17manual

   Bind stage 6/8 semantic review to frozen measured timing and declare stage 6 upstream narrative feasibility.

6. v79Oct 17manual

   Declare existing stage6 creative direction input; preserve all other contracts.

7. v78Oct 17manual

   Declare existing stage5 creative direction as JSON; all other contracts unchanged.

8. v77Oct 17manual

   Add canonical-claim uncertainty handling and stage-5 semantic review; align stage-6 support-intent review with existing stage-8 opening and progressive-reveal rules.

9. v76Oct 17manual

   Stages 6 and 8 only: add reviewed pre-seal semantic review contracts and exact label replacements; preserve all other stages and contracts.

10. v75Oct 17manual

    Declare the existing scene importer serialization at stage8; preserve all checks and repair semantics.

11. v74Oct 17manual

    Enforce narrative timing windows before stage5 seals; preserve all existing checks, scope and allowances.

12. v73Oct 17manual

    Canonical reference shapes at stage4/5/6 producers only; preserve all checks and authority.

13. v72Oct 16manual

    v71 to v72: exact stage6 density and stage8 scene timing requirements/checks; all other steps/contracts unchanged.

14. v71Oct 11manual

    v70 → v71: append the exact evidence-based package-root/subpath verification text in stage 13 only; preserve all other label bytes, stage fields and frozen contracts.

15. v70Oct 11manual

    Split unchanged aggregate obligations into five source-anchored criteria.

16. v69Oct 11manual

    Reviewed definition correction (c9301ef9e101eb14a1ce59a947c971319ca50d42ff9df33444f15c52cdaa60b0)

17. v68Oct 10manual

    v67 → v68: one exact stage-9 replacement for inventory-wide byte hashing and schema-introspected core projection equality; preserve all other stage labels and frozen contracts.

18. v67Oct 10manual

    v66 → v67: two exact stage-8/9 replacements for full support-interval state coverage and state-derived support metrics; preserve the other eleven labels and all frozen contracts.

19. v66Oct 10manual

    v65 → v66: one exact stage-1 substitution closes canonical metadata to six primary facts; other probe evidence stays in the existing receipt. All other labels and frozen contracts unchanged.

20. v65Oct 10manual

    v64 → v65: exactly two stage-8 text substitutions requiring the executed read-only producer check and scene/state boundary continuity; preserve all other stage labels and frozen contracts.

21. v64Oct 10manual

    Replace exactly one stage 6 sentence to define global half-open cadence intervals through the final timeline tail; preserve all other v63 text and contracts.

22. v63Oct 10manual

    v62 → v63: add one shared validation core with exact stage-9 and stage-11 edits and stage-9 file ownership; preserve all other frozen fields and semantic criteria.

23. v62Oct 10manual

    v61 → v62: exactly two stage-9 label substring replacements for pre-lock self-validation authoring iterations; all other steps and frozen fields unchanged.

24. v61Oct 10manual

    v60 → v61: five exact stage-9 replacements and append existing stage-9 reference-validator.py as fifth same-stage repair editScope member; preserve all other frozen fields and three semantic criteria.

25. v60Oct 10manual

    Opt in to same-stage-preparation-repair.v2 cumulative-pass-vector.v1 with exactly four authorized stage-9 label replacements; preserve all other frozen contracts and criteria.

26. v59Oct 10manual

    v58 → v59: one exact stage-9 label replacement enforcing role-map hash verification completeness and executed comparator review before authoring lock; all other stages and frozen contracts preserved.

27. v58Oct 10manual

    v57 → v58: exact stage-8 label replacement requiring one-to-one novel-point change states and correction only while stage 8 remains open; all other stages and contracts preserved.

28. v57Oct 10manual

    v56 to v57: two exact replacements for stage-9 cadence event/state binding and loader primary facts/derived durationFrames. Preserve all other stages, criteria and frozen contracts.

29. v56Oct 10manual

    v55 to v56: exactly one stage-1 label replacement clarifying complete observed media-adapter primary source metadata; preserve all other stages, semantic criteria and frozen contracts.

30. v55Oct 10manual

    v54 to v55: one stage-9 class-level role clarification for scoped identifiers, authored versus derived timings, and frozen policy literals; all other stages, criteria and contracts preserved.

31. v54Oct 10manual

    v53 → v54: two exact stage-8/9 replacements for support interval containment and progressive reveals; preserve all other stage bytes, three criteria and frozen contracts.

32. v53Oct 10manual

    v52 → v53: exactly two literal replacements clarifying observed primary source facts and recomputed derived timing; all other contracts preserved.

33. v52Oct 10manual

    v51 → v52: exactly one stage-9 literal replacement for compact shared-comparator data rows and 96 KiB authoring headroom; preserve all other stages, criteria and frozen contracts.

34. v51Oct 10manual

    v50 stage 9 only: exact literal replacement requiring typed schema introspection and explicit comparator bindings; all other stages and contracts unchanged.

35. v50Oct 10manual

    v49 → v50: one exact stage-9 replacement for declared exception validation and recomputed gap/cadence violations; all other stage text, three criteria and frozen contracts preserved.

36. v49Oct 10manual

    v48 → v49: two exact stage-9 replacements for schema-introspected role coverage and validated policy literals/rational fps; all other text, criteria and contracts preserved.

37. v48Oct 10manual

    v47 → v48: replace exactly one unique stage-6 phrase to clarify joint adjacent per-exception frame coverage; preserve all other stage text, three criteria and frozen contracts.

38. v47Oct 10manual

    v46 → v47: replace exactly one unique stage-9 instruction with the authorized typed-accessor sentence; preserve all other stage text, criteria and frozen contracts.

39. v46Oct 10manual

    v45 → v46: apply exactly two unique literal replacements in stage 5 and stage 6; preserve all other stage text, criteria and frozen contracts.

40. v45Oct 10manual

    v44 → v45: apply exactly five unique literal replacements in stage 6, stage 9 and loader_predicate_without_enrichment criterion; preserve all other stage text and typed contracts.

41. v44Oct 10manual

    v43 → v44: replace exactly one specified stage-9 role-map passage; preserve all other stage text, criteria, inputs, task signature, scope, repair limit and permissions.

42. v43Oct 10manual

    v42 → v43: exact unique stage-label replacements in stages 5, 6, 8 and 9 only; preserve all other text and contracts.

43. v42Oct 10manual

    v41 → v42: exact unique stage-9 role-map replacement only; all other stages and typed contracts preserved.

44. v41Oct 10manual

    v41: apply only four exact replacements in stage 9 and loader_predicate_without_enrichment; preserve all other v40 contracts.

45. v40Oct 10manual

    Append exact enumerable-completeness requirements to the loader semantic criterion and stage 9; preserve all other v39 contracts.

46. v39Oct 10manual

    Append two source-only semantic review criteria for loader predicates and meaningful renderer support; preserve all v38 steps and contracts.

47. v38Oct 10manual

    Clarify existing pre-lock executable reference comparisons and meaningful density arithmetic; preserve all Planner contracts.

48. v37Oct 10manual

    Append exact stage-9 final-review self-check; preserve all other v36 wording and contracts.

49. v36Oct 10manual

    v36: insert only stage-9 narrow same-attempt empty stray-file cleanup and self-review reminders; preserve all v35 fields and contracts.

50. v35Oct 10manual

    Declare strict versioned complete future stage-11 report schemas during stage-9 authoring before validator lock; preserve all other v34 contracts.

51. v34Oct 9manual

    Add frozen source-semantic Judge review to existing one-correction stage9 preparation policy.

52. v33Oct 9manual

    Allow one scoped same-stage code correction after measured preparation refusal; preserve all other Planner contracts.

53. v32Oct 9manual

    Preserve validated scene geometry types through the generated loader; keep all Planner checks and contracts unchanged.

54. v31Oct 6manual

    Make inherited planning requirements explicit; preserve v30 dataflow, ownership, preparation, counting, bundle and terminal gates.

55. v30Oct 6manual

    Count the canonical requests collection at Planner step 7; preserve all other steps and contracts.

56. v29Oct 6manual

    Specify canonical planned-asset and provider-request JSON and preserve frozen timing; only steps 6 and 7 change.

57. v28Oct 4manual

    Add concrete lifecycle output files, truthful verification receipts, and a byte-identical final ZIP copy; preserve planning and bundle contracts.

58. v27Sep 23manual

    Add exact structured deterministic project ownership to Planner v26. No media generation, rendering, or paid provider calls.

59. v26Sep 23manual

    Change only stage 9: read-only scaffold/reservation check, author and check all eight owned files, then one final inventory inspection and one trusted preparation receipt before done.

60. v25Sep 21manual

    Preserve v24; add non-destructive Desktop project-tree, stage-output ownership, node_modules reservation and typed integrity guards.

61. v24Sep 17manual

    v24 deterministic project authoring with exact ownership and receipt-only preparation.

62. v23Sep 16manual

    Add the canonical deterministic Remotion project scaffold to the portable Planner bundle.

63. v22Sep 16manual

    Freeze the deterministic Remotion project dependency and preparation contract

64. v21Sep 15manual

    Added explicit forward stage-dataflow seams and made fresh project/lock authoring unambiguous.

65. v20Sep 15manual

    Compile the canonical 5.04-second Planner bundle handoff.

66. v19Sep 10manual

    Preserve v18; add presenter-overlay style lock, ≥65% visual support, 4–8s cadence, typed animation plan and downstream motion/QuickTime hardware QA.

67. v18Sep 9manual

    v18: only terminal close changes; validated bundle completes unheld and downstream rendering is proposed.

68. v17Sep 9manual

    v17: change only terminal completion/approval and Desktop settlement semantics; omit empty learning handling. Preserve all 13 stages and existing contracts.

69. v16Sep 9manual

    v16: change only stages 2, 10 and 13 for verified external browser discovery and extracted-ZIP identity checks; preserve all other v15 stages and the input contract.

70. v15Sep 9manual

    Preserve v14; pin Remotion 4.0.419/zod 3.22.3 before one lockfile; verify root/installed versions and actual 1920x1080, 30 fps, 21320-frame discovery; fail dependency-version warnings.

71. v14Sep 9manual

    Recover zero-duration words with audited bounded interpolation; use segment/evidence timing gates and preserve all v13 barriers and delivery contracts.

72. v13Sep 9manual

    v13: hard per-stage heartbeat barriers; isolate npm to stage 9, verification to stage 10, and assembly to stage 11 after proof.

73. v12Sep 8manual

    Republish the hardened Planner under the compiler-owned execution policy and require one authenticated terminal settlement after complete artifact declaration.

74. v11Sep 8manual

    Require reproducible clean-install proof and complete artifact coverage before a Planner bundle can be delivered.

75. v10Sep 8manual

    v10 canonical transcript, clean-install proof, functional portable Remotion source, and independent bundle validation.

76. v9Sep 8manual

    Fix v8 audit: complete portable Remotion project, semantic timed scenes, exactly eight requests, typed assets/source bindings and independent validation; preserve inputs and planning-only scope.

77. v8Sep 8manual

    Replace fixed counts with semantic, budget-aware planning; add distinct contracts, evidence/asset states and canonical bundle verification; preserve custody, local transcription and skill bindings.

78. v7Aug 26manual

    Manager L1: require executable Higgsfield and Remotion procedures, semantic scene data, 62-scene coverage, eight authorized Kling requests, and an independent bundle gate.

79. v6Aug 24generated

    added range-safe presenter-video inspection and transcription

80. v5Aug 20manual

    reconciled active outcome capability input authority

81. v4Aug 17manual

    Add the canonical V1 outcome capability, exact presenter_video input identity, and validated project_bundle ZIP handoff.

82. v3Aug 16manual

    Make the planner provider-neutral and emit typed, immutable orchestration handoff artifacts.

83. v2Aug 6manual

    Lock to local planning-only: no media generation/rendering, no Runway/HeyGen credentials; local-tools preflight replaces the paid-service preflight.

84. v1Aug 6generated

    auto-generated from "From one raw presenter video, auto-transcribe it, map narrative beats, assign ea"

Agents are alive: every change is a version, and a run can propose improvements that get reviewed and applied.

related agents

• dailybuilder

  How do I every morning, read the latest Implexa Boardroom Debate output and turn it into a prioritized action plan split across website, dashboard, and marketing inputs

  Boardroom Debate → Daily Action Plan

• weeklybuilder

  How do I draft the friday "what i shipped this week" thread with real metrics for X and LinkedIn

  build-in-public weekly thread

• weekdaybuilder

  How do I scan reddit, hacker news, X, and changelogs for product mentions, competitor moves, and buying-intent threads worth a reply

  competitor and mentions digest

• dailybuilder

  How do I find relevant Hacker News threads every day and draft comments to reply with?

  Daily Hacker News comment drafts