@vibeframe/cli 0.106.8 → 0.107.1

package/dist/commands/_shared/compose-prompts.d.ts

@@ -38,8 +38,15 @@ export interface ComposePromptsBeat {
     heading: string;
     /** Path the agent should write the composition to (relative to projectDir). */
     outputPath: string;
-    /** Beat duration in seconds (from cues or `### Beat duration` subsection), if known. */
+    /** Storyboard beat duration in seconds (the MINIMUM — see finalDurationSec). */
     duration?: number;
+    /**
+     * Narration-synced FINAL beat duration in seconds — the storyboard duration
+     * stretched to cover generated narration audio. Use THIS for
+     * `data-duration` and timeline anchors when present; using the storyboard
+     * `duration` produces scenes that end early and render black tails.
+     */
+    finalDurationSec?: number;
     /** Per-beat YAML cues parsed from the leading code block of the body. */
     cues?: Record<string, unknown>;
     /** Beat body markdown (with the leading `\`\`\`yaml` cue block stripped). */

package/dist/commands/_shared/compose-scenes-skills.d.ts

@@ -62,6 +62,15 @@ export interface ComposeBeatContext {
      * Tests pass a temp dir.
      */
     cacheDir?: string;
+    /**
+     * Narration-synced FINAL beat duration in seconds. The root timeline
+     * stretches each beat to cover its generated narration
+     * (see resolveSyncedBeatDuration in root-sync.ts); when set, the prompt
+     * pins `data-duration` and every timeline anchor to this exact value so the
+     * scene cannot end early and render a black tail. The storyboard cue
+     * duration is then only the minimum and is annotated as superseded.
+     */
+    finalDurationSec?: number;
 }
 export interface ComposeBeatResult {
     /** Generated HTML (from cache or fresh API call). */
@@ -86,7 +95,7 @@ export interface ComposeBeatResult {
 /** Build the system prompt — skill bundle + DESIGN.md hard-gate. */
 export declare function buildSystemPrompt(ctx: Pick<ComposeBeatContext, "skillBundle" | "designMd">): string;
 /** Build the user prompt — instructions + storyboard global + beat body. */
-export declare function buildUserPrompt(ctx: Pick<ComposeBeatContext, "beat" | "storyboardGlobal" | "retryFeedback">): string;
+export declare function buildUserPrompt(ctx: Pick<ComposeBeatContext, "beat" | "storyboardGlobal" | "retryFeedback" | "finalDurationSec">): string;
 /**
  * Compute the sha256 cache key for a (provider, model, system, user) tuple.
  * Provider id is folded in so switching `--composer` doesn't serve cached

package/dist/commands/_shared/root-sync.d.ts

@@ -37,3 +37,22 @@ export declare function syncRootComposition(opts: {
     rootRel?: string;
 }): Promise<RootSyncPlan>;
 export declare function loadProjectRootSyncBeats(projectDir: string): Promise<RootSyncBeatInput[]>;
+/**
+ * Canonical FINAL beat duration: the storyboard duration acts as a minimum
+ * that gets stretched to cover the generated narration audio (+0.5s pad).
+ * This is the duration the root timeline allocates per beat — and therefore
+ * the duration scenes must be composed at (data-duration + timeline anchors),
+ * or they go dark for the stretched tail.
+ */
+export declare function resolveSyncedBeatDuration(opts: {
+    projectDir: string;
+    beatDuration?: number;
+    narrationPath?: string;
+    sceneDurationSec?: number;
+}): Promise<number>;
+/**
+ * Final narration-synced duration per beat for a project on disk. Reads
+ * STORYBOARD.md + build-report.json + narration asset fallbacks via
+ * {@link loadProjectRootSyncBeats}.
+ */
+export declare function resolveProjectBeatDurations(projectDir: string): Promise<Map<string, number>>;

package/dist/commands/_shared/scene-lint.d.ts

@@ -70,8 +70,19 @@ export declare function discoverSceneFiles(opts: {
     subs: string[];
 }>;
 /**
- * Drop findings that producer's lint emits as inverse-rules for sub-comp
- * files. Other findings pass through unchanged.
+ * IEEE float noise threshold for clip-overlap findings. Authored timeline
+ * values are exact to 2dp, but the producer computes each clip's end as
+ * `start + duration` in binary floats — e.g. 8.26 + 10.98 =
+ * 19.240000000000002, which it then flags as "overlapping" a clip starting
+ * at 19.24. Anything under 5ms is float noise, not a real overlap.
+ */
+export declare const OVERLAP_EPSILON_SEC = 0.005;
+/** True for overlapping_clips_same_track findings whose overlap is float noise. */
+export declare function isEpsilonOverlapFinding(finding: LintFinding): boolean;
+/**
+ * Drop known false positives: float-epsilon clip overlaps (all files) and
+ * the producer findings that are inverse-rules for sub-comp files. Other
+ * findings pass through unchanged.
  */
 export declare function filterSubCompFalsePositives(findings: LintFinding[], isSubComposition: boolean): LintFinding[];
 /**

package/dist/commands/_shared/status-jobs.d.ts

@@ -1,6 +1,15 @@
 import type { BuildAssetKind } from "./build-cache.js";
 export type JobStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "unknown";
-export type JobType = "generate-video" | "generate-music";
+/**
+ * `generate-video` / `generate-music` are provider-backed jobs refreshed by
+ * polling the provider. `build` / `render` are LOCAL jobs: long-running MCP
+ * tool calls promoted to the background inside the MCP server process — their
+ * records are updated in-process, so refresh just reads the file (plus orphan
+ * detection when the owning process died).
+ */
+export type JobType = "generate-video" | "generate-music" | "build" | "render";
+/** Local in-process jobs (see {@link JobType}). */
+export declare function isLocalJob(record: Pick<JobRecord, "jobType">): boolean;
 export type ProjectWorkflowStatus = "empty" | "ready" | "running" | "needs-author" | "failed" | "done" | "warn";
 export type ProjectCurrentStage = "init" | "assets" | "compose" | "sync" | "render" | "review" | "done";
 export interface JobRecord {
@@ -31,6 +40,16 @@ export interface JobRecord {
     error?: string;
     promptPreview?: string;
     retryWith: string[];
+    /** Owning process id — local jobs only; used for orphan detection. */
+    pid?: number;
+    /** Last liveness write by the owning process — local jobs only. */
+    heartbeatAt?: string;
+    /** Current pipeline stage label (e.g. "compose", "render") — local jobs. */
+    stage?: string;
+    /** Latest human-readable progress message — local jobs. */
+    message?: string;
+    /** Full tool result data, written when a local job completes. */
+    resultPayload?: Record<string, unknown>;
 }
 export interface CreateJobRecordOptions {
     id?: string;
@@ -56,6 +75,10 @@ export interface CreateJobRecordOptions {
     canonicalPath?: string;
     metadataPath?: string;
     error?: string;
+    pid?: number;
+    heartbeatAt?: string;
+    stage?: string;
+    message?: string;
 }
 export interface RefreshJobOptions {
     wait?: boolean;
@@ -166,6 +189,8 @@ export interface JobResult {
     outputPath?: string;
     cachePath?: string;
     error?: string;
+    /** Full tool result data for completed local build/render jobs. */
+    payload?: Record<string, unknown>;
 }
 export interface ProjectBeatReadiness {
     total: number;

package/dist/commands/_shared/sub-comp-duration-sync.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module _shared/sub-comp-duration-sync
+ *
+ * Propagate narration-synced beat durations INTO sub-composition HTML.
+ *
+ * The root sync (root-sync.ts) stretches each beat's clip window in
+ * index.html to `max(storyboard duration, narration + 0.5s)` — but scenes
+ * composed before the narration existed still carry the storyboard duration
+ * in their own markup: the composition root's `data-duration`, end-aligned
+ * inner `.clip` windows, and GSAP timeline anchor constants like
+ * `const DUR = 7;`. The runtime then ends the scene early and the stretched
+ * tail renders BLACK.
+ *
+ * The compose stage now pins prompts to the final duration
+ * (ComposeBeatContext.finalDurationSec), so fresh scenes are born correct.
+ * This module is the REPAIR path for already-composed scenes. It is
+ * deliberately surgical:
+ *
+ *   1. Composition root `data-duration`   — always rewritten (attribute).
+ *   2. End-aligned `.clip` `data-duration` — rewritten when start+duration
+ *      lands on the OLD beat end (±0.01s); other clips are untouched.
+ *   3. GSAP anchor const                  — rewritten only when exactly one
+ *      `const NAME = <oldDur>;` exists and NAME is referenced in a timeline
+ *      call. Anything ambiguous emits a SCENE_TIMELINE_DURATION_OUT_OF_SYNC
+ *      warning for the host agent instead of risking a bad code edit.
+ */
+import type { ReviewIssue } from "./review-report.js";
+import { type RootSyncBeatInput } from "./root-sync.js";
+export declare const SUB_COMP_SYNC_FIX_CODES: {
+    readonly rootDuration: "scene_duration_synced";
+    readonly clipDurations: "scene_clip_durations_synced";
+    readonly timelineConst: "scene_timeline_const_synced";
+};
+export interface SubCompDurationSyncOutcome {
+    oldDurationSec?: number;
+    newDurationSec: number;
+    changed: boolean;
+    nextHtml?: string;
+    fixCodes: string[];
+    issues: ReviewIssue[];
+}
+export interface SubCompDurationSyncFileResult extends SubCompDurationSyncOutcome {
+    /** Project-relative path, e.g. "compositions/scene-hook.html". */
+    file: string;
+    beatId: string;
+}
+/**
+ * Pure core: rewrite one sub-composition's internal durations to
+ * `newDurationSec`. Returns `changed: false` when the scene already matches
+ * (±0.01s) or its root duration can't be located.
+ */
+export declare function syncSubCompositionDurationHtml(html: string, beatId: string, newDurationSec: number, fileRel?: string): SubCompDurationSyncOutcome;
+/** I/O wrapper: plan duration sync for every beat's composition file. */
+export declare function createSubCompDurationSyncPlans(opts: {
+    projectDir: string;
+    beats: RootSyncBeatInput[];
+}): Promise<SubCompDurationSyncFileResult[]>;

package/dist/commands/_shared/sub-comp-duration-sync.test.d.ts

@@ -0,0 +1 @@
+export {};