@vibeframe/cli 0.115.5 → 0.115.7

package/dist/commands/_shared/edit/jump-cut.d.ts

@@ -52,8 +52,8 @@ export interface JumpCutResult {
 /** Default set of filler words detected by jump-cut. */
 export declare const DEFAULT_FILLER_WORDS: string[];
 /**
- * Transcribe audio with word-level timestamps using Whisper API directly.
- * Uses timestamp_granularities[]=word for filler detection.
+ * Transcribe audio with word-level timestamps (Whisper through the
+ * transcription contract) for filler detection. Throws on failure.
  */
 export declare function transcribeWithWords(audioPath: string, apiKey: string, language?: string): Promise<{
     words: {

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

@@ -0,0 +1,21 @@
+/**
+ * The CLI side of the image contract: open an image provider by name with
+ * the user's key, read input images, and save results. Image commands,
+ * tools, scenes, and builds go through here instead of branching on
+ * provider names.
+ */
+import { type ImageGenerator, type ImageInput } from "@vibeframe/ai-providers";
+/** Env var holding each image provider's key. */
+export declare const IMAGE_PROVIDER_ENV: Readonly<Record<string, string>>;
+/** Display names for spinners and messages. */
+export declare const IMAGE_PROVIDER_LABELS: Readonly<Record<string, string>>;
+/** An image generator for `provider`, with the given key or the configured one. */
+export declare function openImageGenerator(provider: string, apiKey?: string): Promise<ImageGenerator>;
+/** A local image file as contract input. */
+export declare function readImageInput(path: string): Promise<ImageInput>;
+/** Save image bytes to `output` (relative to cwd), converting to the extension's format. */
+export declare function saveImage(output: string, bytes: Uint8Array): Promise<string>;
+/** The catalog label for a model ID, for human output. */
+export declare function imageModelLabel(provider: string, modelId: string): string;
+/** CLI quality words to the contract's: `standard`/`hd` are the old OpenAI names. */
+export declare function contractQuality(quality?: string): "low" | "medium" | "high" | undefined;

package/dist/commands/_shared/openai-image.d.ts

@@ -1,36 +1,10 @@
 /**
  * @module _shared/openai-image
  *
- * Shared OpenAI `generateImage` helper for `vibe ai image` and
- * `vibe generate image`. Both commands had their own near-identical
- * provider initialisation + model-alias parsing + result construction.
- * v0.52.0 added gpt-image-2 wiring to `ai-image.ts` only and
- * `vibe generate image -m 2` silently fell back to gpt-image-1.5 — the
- * duplication guarantees a recurrence next time the OpenAI image flow
- * is touched.
- *
- * Each top-level command keeps its own CLI wiring and output formatting;
- * this helper owns just the API call + label derivation.
- *
- * See issue #58.
+ * OpenAI image model alias resolution, used by image cost estimates.
+ * Generation itself goes through the image contract (`executeImageGenerate`).
  */
-import type { GPTImageModel, ImageResult } from "@vibeframe/ai-providers";
-/** Subset of CLI options consumed by the helper. */
-export interface OpenAIImageHelperOptions {
-    model?: string;
-    size?: string;
-    quality?: string;
-    style?: string;
-    /** Stringified count from commander; parsed inside the helper. */
-    count?: string;
-}
-export interface OpenAIImageHelperResult {
-    result: ImageResult;
-    /** Resolved model id passed to the API. */
-    openaiModel: GPTImageModel;
-    /** Human-friendly label for spinner / success output. */
-    modelLabel: string;
-}
+import type { GPTImageModel } from "@vibeframe/ai-providers";
 /**
  * Resolve the user-supplied model alias to the API id + display label, from
  * the model catalog. Unknown or empty aliases resolve to the default model.
@@ -41,10 +15,3 @@ export declare function resolveOpenAIImageModel(modelAlias?: string): {
     openaiModel: GPTImageModel;
     modelLabel: string;
 };
-/**
- * Run an OpenAI image generation. Caller owns: api-key acquisition,
- * spinner lifecycle, output formatting (JSON vs human), and file save.
- */
-export declare function executeOpenAIImageGenerate(prompt: string, options: OpenAIImageHelperOptions, ctx: {
-    apiKey: string;
-}): Promise<OpenAIImageHelperResult>;

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

@@ -1,3 +1,4 @@
+import { type VideoJob } from "@vibeframe/ai-providers";
 import type { BuildAssetKind } from "./build-cache.js";
 import type { ReviewAction } from "./review-report.js";
 export type JobStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "unknown";
@@ -26,7 +27,10 @@ export interface JobRecord {
     command: string;
     provider: string;
     providerTaskId: string;
+    /** Kling task type; superseded by `providerJob` and kept for older records. */
     providerTaskType?: "text2video" | "image2video";
+    /** The provider's job handle, so a refresh polls exactly the job that was submitted. */
+    providerJob?: VideoJob;
     progress?: number;
     resultUrl?: string;
     beatId?: string;
@@ -60,6 +64,7 @@ export interface CreateJobRecordOptions {
     provider: string;
     providerTaskId: string;
     providerTaskType?: "text2video" | "image2video";
+    providerJob?: VideoJob;
     projectDir?: string;
     workingDirectory?: string;
     command: string;

package/dist/commands/_shared/transcription.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The CLI side of the transcription contract: transcribe an audio file on
+ * disk and get the result shape the commands already use. Every command
+ * that needs a transcript (audio, captions, highlights, jump-cut, scene
+ * narration) goes through here.
+ */
+import { type ProviderErrorKind, type TranscriptGranularity, type TranscriptResult } from "@vibeframe/ai-providers";
+export interface TranscribeFileOptions {
+    apiKey: string;
+    language?: string;
+    granularity?: TranscriptGranularity;
+}
+/** Transcribe `path` with Whisper. Failures come back as `status: "failed"` with an error kind. */
+export declare function transcribeAudioFile(path: string, options: TranscribeFileOptions): Promise<TranscriptResult & {
+    errorKind?: ProviderErrorKind;
+}>;

package/dist/commands/_shared/translate-texts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Translate a list of short texts (subtitle cues, dub segments) with Claude
+ * or OpenAI, in batches, keeping each text's position. Lines come back
+ * tagged `[N]` and are matched by that index, so a skipped or merged line
+ * cannot shift every later translation; anything missing keeps its source
+ * text.
+ */
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
+export interface TranslateTextsOptions {
+    /** Target language name or code ("Korean", "ko"). */
+    targetLanguage: string;
+    sourceLanguage?: string;
+    /** Default: Claude when ANTHROPIC_API_KEY is set, else OpenAI. */
+    provider?: "claude" | "openai";
+    apiKey?: string;
+    /** Texts per request. Default 30. */
+    batchSize?: number;
+}
+export type TranslateTextsResult = {
+    success: true;
+    texts: string[];
+    provider: "claude" | "openai";
+} | {
+    success: false;
+    error: string;
+    errorKind?: ProviderErrorKind;
+};
+/** "ko" → "Korean"; names pass through. */
+export declare function languageName(code: string): string;
+export declare function translateTexts(texts: string[], options: TranslateTextsOptions): Promise<TranslateTextsResult>;

package/dist/commands/_shared/translate-texts.test.d.ts

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

package/dist/commands/_shared/tts-resolve.d.ts

@@ -18,7 +18,7 @@
  * to branch on provider id. All providers already return the same
  * `{ success, audioBuffer, error?, characterCount? }` result.
  */
-import type { KokoroLoadEvent } from "@vibeframe/ai-providers";
+import type { KokoroLoadEvent, ProviderErrorKind } from "@vibeframe/ai-providers";
 /** TTS providers VibeFrame can route to. `"auto"` picks based on key availability. */
 export type TtsProviderName = "auto" | "elevenlabs" | "openai" | "kokoro";
 /** Concrete provider id surfaced in result metadata. Never `"auto"`. */
@@ -33,6 +33,8 @@ export interface TtsCallOptions {
     voice?: string;
     /** Speaking speed multiplier (Kokoro: 0.5–2; ElevenLabs: 0.7–1.2). */
     speed?: number;
+    /** Catalog model ID or alias for the resolved provider. */
+    model?: string;
     /** Cold-start progress callback (Kokoro only — fires on first ~330MB load). */
     onProgress?: (event: KokoroLoadEvent) => void;
 }
@@ -41,7 +43,11 @@ export interface TtsCallResult {
     success: boolean;
     audioBuffer?: Buffer;
     error?: string;
+    /** Why the provider failed (`auth`, `quota`, `invalid-request`, ...). */
+    errorKind?: ProviderErrorKind;
     characterCount?: number;
+    /** The catalog model that spoke it. */
+    model?: string;
 }
 /** Synthesise speech from text. Provider-specific implementation lives behind this. */
 export type TtsCallable = (text: string, options?: TtsCallOptions) => Promise<TtsCallResult>;

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

@@ -0,0 +1,34 @@
+/**
+ * The CLI side of the video job contract: open a provider by name with the
+ * user's key, and turn local files into the image form it takes. Video
+ * executors, job records, and builds go through here instead of branching
+ * on provider names.
+ */
+import { type VideoGenerator, type VideoJob } from "@vibeframe/ai-providers";
+/** Env var holding each video provider's key. */
+export declare const VIDEO_PROVIDER_ENV: Readonly<Record<string, string>>;
+/** `fal` is the old name for `seedance`. */
+export declare function canonicalVideoProvider(provider: string): string;
+/** A video generator for `provider`, with the given key or the configured one. */
+export declare function openVideoGenerator(provider: string, apiKey?: string): Promise<VideoGenerator>;
+/**
+ * A job handle for a bare task ID (a user typed it, or an old job record
+ * predates stored handles). Providers that need more than the ID recover
+ * it themselves: Kling tries both task types, Seedance uses its model's app.
+ */
+export declare function jobFromTaskId(provider: string, taskId: string, opts?: {
+    model?: string;
+    taskType?: string;
+}): VideoJob;
+export declare function mimeTypeForPath(path: string, fallback: string): string;
+/** A local path, URL, or data URI as a URL or data URI (local files are inlined). */
+export declare function fileToUrlOrDataUri(input: string, fallbackMimeType: string): Promise<string>;
+/**
+ * An input image in the form `generator` takes: uploaded to the configured
+ * upload host for URL-only providers, inlined as a data URI otherwise.
+ *
+ * Remote URLs are never fetched here: an inline-only provider gets a usage
+ * error instead, so a tool call cannot make the CLI read an internal URL
+ * and forward its contents to a provider.
+ */
+export declare function videoImageInput(generator: VideoGenerator, input: string): Promise<string>;

package/dist/commands/ai-audio.d.ts

@@ -12,6 +12,7 @@
  *
  * @see MODELS.md for AI model configuration
  */
+import type { ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface TranscribeOptions {
     audioPath: string;
     language?: string;
@@ -29,7 +30,10 @@ export interface TranscribeResult {
     }>;
     detectedLanguage?: string;
     outputPath?: string;
+    /** Subtitle format written to `outputPath` (json, srt, vtt). */
+    format?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeTranscribe(options: TranscribeOptions): Promise<TranscribeResult>;
 export interface IsolateOptions {
@@ -41,6 +45,7 @@ export interface IsolateResult {
     success: boolean;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeIsolate(options: IsolateOptions): Promise<IsolateResult>;
 export interface VoiceCloneOptions {
@@ -56,13 +61,18 @@ export interface VoiceCloneResult {
     voiceId?: string;
     name?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVoiceClone(options: VoiceCloneOptions): Promise<VoiceCloneResult>;
 export interface DubOptions {
     mediaPath: string;
+    /** Target language code or name ("ko", "Spanish"). */
     language: string;
     source?: string;
+    /** Voice for the chosen TTS provider. */
     voice?: string;
+    /** TTS provider: auto (default), elevenlabs, openai, kokoro. */
+    tts?: string;
     analyzeOnly?: boolean;
     output?: string;
 }
@@ -72,8 +82,22 @@ export interface DubResult {
     sourceLanguage?: string;
     targetLanguage?: string;
     segmentCount?: number;
+    /** Each segment's timing with its original and translated text. */
+    segments?: Array<{
+        startTime: number;
+        endTime: number;
+        original: string;
+        translated: string;
+    }>;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
+/**
+ * Dub speech to another language: transcribe (Whisper), translate (Claude,
+ * or OpenAI without an Anthropic key), speak each segment (any TTS
+ * provider), and place each line at its segment's start time, speeding up
+ * lines that would overrun their slot.
+ */
 export declare function executeDub(options: DubOptions): Promise<DubResult>;
 export interface DuckOptions {
     musicPath: string;

package/dist/commands/ai-image.d.ts

@@ -12,48 +12,66 @@
  *
  * @see MODELS.md for AI model configuration
  */
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ImageGenerateOptions {
     prompt: string;
+    /** Default: the configured or first available image provider. */
     provider?: string;
     output?: string;
+    /** Explicit OpenAI size; otherwise the ratio picks one. */
     size?: string;
     ratio?: string;
     quality?: string;
-    style?: string;
+    /** Gemini "1K"/"2K"/"4K", Grok "1k"/"2k". */
+    resolution?: string;
     count?: number;
     model?: string;
     apiKey?: string;
 }
 export interface ImageGenerateResult {
     success: boolean;
+    /** Where the first image was saved. */
     outputPath?: string;
+    /** Every saved image: `out.png`, then `out-2.png`, `out-3.png`, ... */
+    outputPaths?: string[];
     images?: Array<{
-        url?: string;
-        base64?: string;
-        mimeType?: string;
+        base64: string;
+        mimeType: string;
         revisedPrompt?: string;
     }>;
     provider?: string;
     model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeImageGenerate(options: ImageGenerateOptions): Promise<ImageGenerateResult>;
-export interface GeminiEditOptions {
+export interface ImageEditOptions {
     imagePaths: string[];
     prompt: string;
+    /** Default: gemini. */
+    provider?: string;
     output?: string;
     model?: string;
     ratio?: string;
     resolution?: string;
+    quality?: string;
     apiKey?: string;
 }
-export interface GeminiEditResult {
+export interface ImageEditResult {
     success: boolean;
     outputPath?: string;
+    provider?: string;
     model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
-export declare function executeGeminiEdit(options: GeminiEditOptions): Promise<GeminiEditResult>;
+export declare function executeImageEdit(options: ImageEditOptions): Promise<ImageEditResult>;
+/** @deprecated Use `executeImageEdit`; kept for callers that predate other edit providers. */
+export type GeminiEditOptions = Omit<ImageEditOptions, "provider">;
+/** @deprecated Use `executeImageEdit`. */
+export type GeminiEditResult = ImageEditResult;
+/** @deprecated Use `executeImageEdit`. */
+export declare function executeGeminiEdit(options: GeminiEditOptions): Promise<ImageEditResult>;
 export interface ThumbnailBestFrameOptions {
     videoPath: string;
     outputPath: string;

package/dist/commands/ai-video.d.ts

@@ -1,21 +1,21 @@
 /**
  * @module ai-video
- * @description Library functions for video generation, status, cancel, and
- * extension. Powers the manifest tools `generate_video`,
- * `generate_video_status`, `generate_video_cancel`, `generate_video_extend`
- * (the user reaches these via `vibe generate video[-...]`).
- *
- * The legacy `vibe ai video / video-status / video-cancel / kling / kling-status /
- * video-extend` Commander registrations were removed alongside the dead
- * `commands/ai.ts` orchestrator (the `vibe ai *` namespace was never
- * `addCommand`'d to `program`).
+ * @description Video generation, status, cancel, and extension on the video
+ * job contract. Powers the manifest tools `generate_video`,
+ * `generate_video_cancel`, `generate_video_extend`, and job refreshes in
+ * `vibe status`; every provider goes through `VideoGenerator`, so nothing
+ * here branches on provider names.
  *
  * @see MODELS.md for AI model configuration
  */
+import { type ProviderErrorKind, type VideoJob, type VideoJobState } from "@vibeframe/ai-providers";
 export interface VideoGenerateOptions {
     prompt: string;
+    /** Default: the configured or first available video provider. */
     provider?: "grok" | "runway" | "kling" | "veo" | "seedance" | "fal" | "omni";
     image?: string;
+    /** Ending frame for providers that interpolate between two frames. */
+    endImage?: string;
     refImages?: string[];
     refVideos?: string[];
     refAudio?: string[];
@@ -34,21 +34,37 @@ export interface VideoGenerateOptions {
     output?: string;
     wait?: boolean;
     apiKey?: string;
+    /**
+     * Called as soon as the provider accepts the job, before waiting, so the
+     * caller can record it: a crash or timeout mid-wait then leaves a job that
+     * can still be polled and downloaded.
+     */
+    onSubmitted?: (job: VideoJob) => void | Promise<void>;
+    /** Called after every poll while waiting. */
+    onProgress?: (state: VideoJobState) => void;
+    /** Veo only: `allow_all` or `allow_adult`. */
+    personGeneration?: string;
 }
 export interface VideoGenerateResult {
     success: boolean;
     taskId?: string;
+    /** The provider job handle; store it to poll, cancel, or extend later. */
+    job?: VideoJob;
     status?: string;
     videoUrl?: string;
     duration?: number;
     outputPath?: string;
     provider?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoGenerate(options: VideoGenerateOptions): Promise<VideoGenerateResult>;
 export interface VideoStatusOptions {
     taskId: string;
-    provider?: "grok" | "runway" | "kling" | "veo";
+    provider?: string;
+    /** The stored job handle; preferred over `taskId` + `taskType`. */
+    job?: VideoJob;
+    /** Kling task type, for a bare task ID. */
     taskType?: "text2video" | "image2video";
     wait?: boolean;
     output?: string;
@@ -63,20 +79,28 @@ export interface VideoStatusResult {
     duration?: number;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoStatus(options: VideoStatusOptions): Promise<VideoStatusResult>;
 export interface VideoCancelOptions {
     taskId: string;
+    /** Default: runway. */
+    provider?: string;
+    job?: VideoJob;
     apiKey?: string;
 }
 export interface VideoCancelResult {
     success: boolean;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoCancel(options: VideoCancelOptions): Promise<VideoCancelResult>;
 export interface VideoExtendOptions {
+    /** The task ID of the video to extend (Veo: its operation name). */
     videoId: string;
-    provider?: "kling" | "veo";
+    /** Default: kling. */
+    provider?: string;
+    job?: VideoJob;
     prompt?: string;
     duration?: number;
     negative?: string;
@@ -88,10 +112,12 @@ export interface VideoExtendOptions {
 export interface VideoExtendResult {
     success: boolean;
     taskId?: string;
+    job?: VideoJob;
     status?: string;
     videoUrl?: string;
     duration?: number;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoExtend(options: VideoExtendOptions): Promise<VideoExtendResult>;

package/dist/commands/ai-video.network.test.d.ts

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

package/dist/commands/generate/image.d.ts

@@ -1,8 +1,9 @@
 /**
  * @module generate/image
- * @description `vibe generate image` (alias `img`) — multi-provider image
- * generation. OpenAI gpt-image-2.5, Gemini Nano Banana, Grok, Runway. Split
- * out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * @description `vibe generate image` (alias `img`) — image generation on
+ * OpenAI GPT Image, Gemini Nano Banana, or Grok Imagine. Validation,
+ * provider choice, and the dry run live here; generation is
+ * `executeImageGenerate`, the same executor the MCP tool and pipelines use.
  */
 import type { Command } from "commander";
 export declare function registerImageCommand(parent: Command): void;

package/dist/commands/generate/music.d.ts

@@ -5,6 +5,7 @@
  * conditioning). Split out of `generate.ts` in v0.69 (Plan G Phase 2).
  */
 import type { Command } from "commander";
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteMusicOptions {
     prompt: string;
     output?: string;
@@ -12,6 +13,9 @@ export interface ExecuteMusicOptions {
     provider?: "elevenlabs" | "replicate";
     instrumental?: boolean;
     wait?: boolean;
+    /** Replicate MusicGen variant: large, stereo-large, melody-large, stereo-melody-large. */
+    model?: string;
+    apiKey?: string;
 }
 export interface ExecuteMusicResult {
     success: boolean;
@@ -22,6 +26,7 @@ export interface ExecuteMusicResult {
     status?: string;
     audioUrl?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeMusic(options: ExecuteMusicOptions): Promise<ExecuteMusicResult>;
 export declare function registerMusicCommand(parent: Command): void;

package/dist/commands/generate/sound-effect.d.ts

@@ -1,19 +1,25 @@
 /**
  * @module generate/sound-effect
  * @description `vibe generate sound-effect` — ElevenLabs SFX generation.
- * Split out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * The command validates and formats; `executeSoundEffect` (also used by
+ * pipelines and the MCP tool) does the work.
  */
 import type { Command } from "commander";
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteSoundEffectOptions {
     prompt: string;
     output?: string;
+    /** Seconds (0.5-30); the model picks when omitted. */
     duration?: number;
+    /** 0-1, default 0.3. */
     promptInfluence?: number;
+    apiKey?: string;
 }
 export interface ExecuteSoundEffectResult {
     success: boolean;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeSoundEffect(options: ExecuteSoundEffectOptions): Promise<ExecuteSoundEffectResult>;
 export declare function registerSoundEffectCommand(parent: Command): void;

package/dist/commands/generate/speech.d.ts

@@ -1,20 +1,29 @@
 /**
  * @module generate/speech
- * @description `vibe generate speech` (alias `tts`) — ElevenLabs text-to-
- * speech with optional duration-fit post-processing. Split out of
- * `generate.ts` in v0.69 (Plan G Phase 2).
+ * @description `vibe generate narration` (alias `voiceover`) — text to
+ * speech on ElevenLabs, OpenAI, or local Kokoro, through the same TTS
+ * resolver scenes and builds use.
  */
 import type { Command } from "commander";
+import type { ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteSpeechOptions {
     text: string;
     output?: string;
     voice?: string;
+    /** auto (default): ElevenLabs if its key is set, else OpenAI, else local Kokoro. */
+    provider?: string;
+    /** Catalog model ID or alias for the chosen provider. */
+    model?: string;
+    speed?: number;
 }
 export interface ExecuteSpeechResult {
     success: boolean;
     outputPath?: string;
     characterCount?: number;
+    provider?: string;
+    model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeSpeech(options: ExecuteSpeechOptions): Promise<ExecuteSpeechResult>;
 export declare function registerNarrationCommand(parent: Command): void;

package/dist/commands/generate/video-cancel.d.ts

@@ -1,8 +1,7 @@
 /**
  * @module generate/video-cancel
- * @description `vibe generate video-cancel` (hidden) — cancel in-flight Grok
- * or Runway video generation. Split out of `generate.ts` in v0.69 (Plan G
- * Phase 2).
+ * @description `vibe generate video-cancel` (hidden) — cancel an in-flight
+ * video job on a provider with a cancel API (Runway, Seedance, Gemini Omni).
  */
 import type { Command } from "commander";
 export declare function registerVideoCancelCommand(parent: Command): void;

package/dist/commands/generate/video-extend.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module generate/video-extend
- * @description `vibe generate video-extend` (hidden) — extend video duration
- * via Kling or Veo (Gemini). Split out of `generate.ts` in v0.69 (Plan G
- * Phase 2).
+ * @description `vibe generate video-extend` (hidden) — extend a generated
+ * video from its last frame, on any provider that can (Kling, Grok classic,
+ * Gemini Omni, and Veo until 2026-10-22).
  */
 import type { Command } from "commander";
 export declare function registerVideoExtendCommand(parent: Command): void;

package/dist/commands/generate/video.d.ts

@@ -1,9 +1,10 @@
 /**
  * @module generate/video
  * @description `vibe generate video` (alias `vid`) — multi-provider video
- * generation. fal.ai (Seedance 2.0), Grok, Veo (Gemini), Kling, Runway,
- * plus Gemini Omni 1.1 Flash (`-p omni`).
- * Split out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * generation (Seedance via fal.ai, Grok, Kling, Runway, Gemini Omni, and Veo
+ * until 2026-10-22). Validation, provider choice, and the dry run live here;
+ * generation itself is `executeVideoGenerate`, the same executor the MCP
+ * tool and builds use.
  */
 import type { Command } from "commander";
 export declare function registerVideoCommand(parent: Command): void;

package/dist/commands/output.d.ts

@@ -22,6 +22,8 @@ export interface StructuredError {
     retryWith?: string[];
     recoverable?: boolean;
     retryable: boolean;
+    /** The provider error kind (`auth`, `quota`, `likeness`, ...) when a provider call failed. */
+    errorKind?: string;
     /**
      * Structured context carried alongside the failure, so a refusal can hand
      * back the evidence it refused on instead of forcing a second call. Used by
@@ -32,6 +34,11 @@ export interface StructuredError {
 export declare function usageError(msg: string, suggestion?: string): StructuredError;
 export declare function authError(envVar: string, provider: string): StructuredError;
 export declare function apiError(msg: string, retryable?: boolean): StructuredError;
+/**
+ * The structured error for a failed provider call, chosen by its error kind
+ * (`ProviderError.kind`) instead of by matching provider wording.
+ */
+export declare function providerFailure(message: string, kind?: string): StructuredError;
 export declare function notFoundError(path: string): StructuredError;
 export declare function networkError(msg: string): StructuredError;
 export declare function generalError(msg: string, suggestion?: string): StructuredError;