@mevdragon/vidfarm-devcli 0.20.6 → 0.20.9

package/dist/src/devcli/clips.js

@@ -12,20 +12,25 @@ import { homedir } from "node:os";
 import { parseArgs } from "node:util";
 import { createInterface } from "node:readline/promises";
 import { createIdV7 } from "../lib/ids.js";
-import { buildEffectiveGuidance, ClipModelClient, DEFAULT_CLIP_ASPECT, DEFAULT_CLIP_DURATION_BAND, detectLocalAgent, detectScenes, effectiveHuntDurationSec, estimateScanCostFromScenes, fitScenesToDurationBand, formatCostEstimate, hasFfmpeg, LocalAgentClipClient, normalizeAspect, normalizeCropFocus, normalizeWindows, parseClipHuntPrompt, parseTimeRanges, probeVideo, resolveDurationBand, resolveTargetClipCount, scanVideo, searchClips } from "../services/clip-curation/index.js";
+import { buildEffectiveGuidance, buildPrivateUserNotesGuidance, ClipModelClient, DEFAULT_CLIP_ASPECT, DEFAULT_CLIP_DURATION_BAND, detectLocalAgent, detectScenes, effectiveHuntDurationSec, estimateScanCostFromScenes, fitScenesToDurationBand, formatCostEstimate, hasFfmpeg, LocalAgentClipClient, normalizeAspect, normalizeCropFocus, normalizeWindows, parseClipHuntPrompt, parseTimeRanges, probeVideo, resolveDurationBand, resolveTargetClipCount, scanVideo, searchClips } from "../services/clip-curation/index.js";
 import { ClipStore } from "./clip-store.js";
 export const CLIPS_HELP = `vidfarm raws — build & search a local raws library (local ffmpeg + local agent by default)
 
   raws scan <video-path>           Mine a long-form video into tagged, searchable raws
-    --provider <p>                 agent | gemini | openai | openrouter
+    --provider <p>                 agent | gemini | openai | openrouter | nvidia
                                    Default: agent when a local claude/codex CLI is installed
                                    (your subscription, no API key), else gemini.
+                                   nvidia = lite, clipping-first key (minimax-m3); no audio/embeddings.
     --agent claude|codex           Which local agent CLI to use for --provider agent (default: auto)
     --tier flash|flash-lite        Gemini tier (default: flash-lite; ignored for openai/openrouter/agent)
     --prompt "<guidance>"          Reshape clipping toward your goal: an LLM pass
                                    keeps/drops/merges scenes, and tags are biased to it.
                                    Inline hints are honored too: "between 12:30 and 15:45",
                                    "30 sec clips", "vertical", "no captions".
+    --notes "<private notes>"      Store private owner notes as user_notes on derived raws
+                                   and feed them into decomposition/categorization. Explicit
+                                   private shot-kind hints like "content_type: demo" or
+                                   "category: talking_head" are honored and stay owner-only.
     --range "MM:SS-MM:SS"          Only hunt inside this source range (repeatable / comma-separated)
     --duration <sec>               Target raw length as a SOFT band (10→5-20s, 30→20-40s, …)
     --aspect <a>                   Crop raws to 9:16 | 16:9 | 4:3 | 1:1 (or vertical/horizontal/square)
@@ -49,8 +54,8 @@ export const CLIPS_HELP = `vidfarm raws — build & search a local raws library
     --threshold <0..1>             Scene-cut sensitivity (default 0.3; lower = more cuts)
     --min-scene <sec>              Merge scenes shorter than this (default 0.6)
     --max-scene <sec>              Split scenes longer than this (default 8; --duration overrides)
-    --gemini-key / --openai-key / --openrouter-key <key>   Provider key (or *_API_KEY env)
-    --embed-provider gemini|openai --embed-key <key>       Embeddings for agent/openrouter scans
+    --gemini-key / --openai-key / --openrouter-key / --nvidia-key <key>   Provider key (or *_API_KEY env)
+    --embed-provider gemini|openai --embed-key <key>       Embeddings for agent/openrouter/nvidia scans
     --home <dir>                   Library dir (default: ~/.vidfarm or VIDFARM_HOME)
 
   raws list                        List raws in the library
@@ -152,12 +157,15 @@ async function runScan(argv) {
             "gemini-key": { type: "string" },
             "openai-key": { type: "string" },
             "openrouter-key": { type: "string" },
+            "nvidia-key": { type: "string" },
             "embed-provider": { type: "string" },
             "embed-key": { type: "string" },
+            notes: { type: "string" },
             home: { type: "string" }
         }
     });
     // ── Hunt spec: explicit flags win; inline prompt hints fill the gaps ──────
+    const userNotes = values.notes?.trim() || undefined;
     const guidancePromptRaw = values.prompt?.trim() || undefined;
     const parsedPrompt = parseClipHuntPrompt(guidancePromptRaw);
     const rawWindows = values.range?.length
@@ -179,7 +187,10 @@ async function runScan(argv) {
     const cropFocus = normalizeCropFocus(values["crop-focus"]);
     const avoidText = values["allow-text"] ? false : (Boolean(values["no-text"]) || parsedPrompt.avoid_text || true);
     const maxClips = values["max-clips"] ? Math.max(1, Math.round(Number(values["max-clips"]))) : parsedPrompt.max_clips ?? undefined;
-    const guidance = buildEffectiveGuidance({ contentPrompt: guidancePromptRaw, avoidText }) || undefined;
+    const guidance = buildEffectiveGuidance({
+        contentPrompt: [guidancePromptRaw, buildPrivateUserNotesGuidance(userNotes)].filter(Boolean).join("\n"),
+        avoidText
+    }) || undefined;
     // ── BACKUP path: run the hunt on the deployed pipeline (--cloud) ──────────
     if (values.cloud) {
         const apiProvider = values.provider && !["agent", "local", "local-agent"].includes(values.provider)
@@ -193,6 +204,7 @@ async function runScan(argv) {
             tracer: values.tracer,
             folder: values.folder,
             prompt: guidancePromptRaw,
+            userNotes,
             provider: apiProvider,
             windows: rawWindows,
             durationBand,
@@ -337,6 +349,7 @@ async function runScan(argv) {
         framesPerScene,
         includeAudio,
         guidancePrompt: guidance,
+        userNotes,
         refineSegmentation: !values["no-refine"],
         reencodeClips: true,
         audioOnly: Boolean(values["audio-only"]),
@@ -459,6 +472,7 @@ async function runScanCloud(input) {
         body: JSON.stringify({
             ...(input.sourceUrl ? { source_url: input.sourceUrl } : { temp_file_id: tempFileId, filename: fileName }),
             prompt: input.prompt ?? "",
+            ...(input.userNotes ? { user_notes: input.userNotes } : {}),
             ...(input.provider ? { provider: input.provider } : {}),
             ...(input.tracer ? { tracer: input.tracer } : {}),
             ...(input.folder ? { folder_path: input.folder } : {}),
@@ -935,9 +949,9 @@ async function runExport(argv) {
 function normalizeProvider(value) {
     if (value === undefined || value === "gemini")
         return "gemini";
-    if (value === "openai" || value === "openrouter")
+    if (value === "openai" || value === "openrouter" || value === "nvidia")
         return value;
-    throw new Error(`--provider must be gemini | openai | openrouter (got "${value}")`);
+    throw new Error(`--provider must be gemini | openai | openrouter | nvidia (got "${value}")`);
 }
 // Parse a comma-separated --content-type flag into lowercase shot-KIND tags for
 // the tags.content_type filter (talking_head, b_roll, product_shot, …).
@@ -961,12 +975,14 @@ function defaultEmbedModelForEstimate(provider) {
 const ENV_KEYS = {
     gemini: ["GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
     openai: ["OPENAI_API_KEY"],
-    openrouter: ["OPENROUTER_API_KEY"]
+    openrouter: ["OPENROUTER_API_KEY"],
+    nvidia: ["NVIDIA_API_KEY"]
 };
 const CONFIG_KEYS = {
     gemini: "gemini_api_key",
     openai: "openai_api_key",
-    openrouter: "openrouter_api_key"
+    openrouter: "openrouter_api_key",
+    nvidia: "nvidia_api_key"
 };
 /** Resolve a provider key: --<provider>-key flag → *_API_KEY env → ~/.vidfarm/config.json. */
 function resolveProviderKey(provider, flags, opts = {}) {
@@ -997,15 +1013,16 @@ function resolveProviderKey(provider, flags, opts = {}) {
 }
 /**
  * Embedding config for a scan. gemini/openai embed with their own key; openrouter
- * can't embed, so pair it with a gemini/openai key via --embed-provider/--embed-key
- * (or GEMINI_API_KEY/OPENAI_API_KEY env). Returns null → semantic search disabled.
+ * and nvidia can't embed, so pair them with a gemini/openai key via
+ * --embed-provider/--embed-key (or GEMINI_API_KEY/OPENAI_API_KEY env). Returns
+ * null → semantic search disabled (structured-only library).
  */
 function resolveEmbeddingConfig(provider, apiKey, flags) {
     if (provider === "gemini")
         return { provider: "gemini", apiKey };
     if (provider === "openai")
         return { provider: "openai", apiKey };
-    // openrouter → look for an explicit embed provider, else any gemini/openai key.
+    // openrouter / nvidia → look for an explicit embed provider, else any gemini/openai key.
     const explicit = flags["embed-provider"]?.trim();
     const tryProvider = (p) => {
         const key = flags["embed-key"]?.trim() || resolveProviderKey(p, flags, { optional: true });

package/dist/src/devcli/doctor.js

@@ -133,10 +133,10 @@ export async function runDoctorCommand(argv) {
     const apiKey = parsed.values["api-key"] ?? process.env.VIDFARM_API_KEY;
     if (apiKey) {
         const who = await fetchWhoami(String(parsed.values.host).replace(/\/+$/, ""), apiKey);
-        add("vidfarm auth", who.ok ? "ok" : "warn", who.detail);
+        add("vidfarm auth", who.ok ? "ok" : "warn", who.ok ? who.detail : `${who.detail} — serve will fall back to local browse mode`);
     }
     else {
-        add("vidfarm auth", "warn", "VIDFARM_API_KEY not set — cloud commands need it (local serve/lint/stills/speech engines work without it)");
+        add("vidfarm auth", "warn", "VIDFARM_API_KEY not set — serve will fall back to local browse mode; cloud catalog/bulk routes need it");
     }
     // 6. Provider keys in env (BYOK local-first engines).
     const presentKeys = PROVIDER_KEY_ENV_VARS.filter((name) => process.env[name]?.trim());

package/dist/src/devcli/local-backend.js

@@ -17,6 +17,47 @@
 // drivers correctly — exactly the discipline `runServeCommand` follows.
 import path from "node:path";
 import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/**
+ * Thrown when a local / `serve` command is invoked in the PUBLISHED CLI, which
+ * ships as a cloud client only — the in-process backend (`app.js` et al.) is
+ * deliberately excluded from the npm tarball so the server is never open-sourced.
+ * A full source checkout (where `app.js` sits next to the CLI on disk) still runs
+ * local mode; the published package degrades to this friendly error instead.
+ */
+export class LocalModeUnavailableError extends Error {
+    constructor() {
+        super("Local / serve mode isn't available in the published Vidfarm CLI — it would require the full backend. " +
+            "Use cloud mode (the default): drop --local/--both, or pass --cloud. " +
+            "(Local mode is available when running the CLI from a full source checkout.)");
+        this.name = "LocalModeUnavailableError";
+    }
+}
+/** True only when the in-process backend (`app.js`) is present next to the CLI
+ *  on disk — i.e. a full source/dist checkout, never the published npm package. */
+export function localBackendAvailable() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url)); // dist/src/devcli
+        return existsSync(path.join(here, "..", "app.js"));
+    }
+    catch {
+        return false;
+    }
+}
+/** Wrap a dynamic import of a backend module so an absent file (published CLI)
+ *  surfaces as a clean LocalModeUnavailableError, not a raw ERR_MODULE_NOT_FOUND. */
+export async function importBackendModule(loader) {
+    try {
+        return await loader();
+    }
+    catch (error) {
+        if (error && typeof error === "object" && error.code === "ERR_MODULE_NOT_FOUND") {
+            throw new LocalModeUnavailableError();
+        }
+        throw error;
+    }
+}
 /** The durable per-user local home. Everything the local backend persists lives
  *  under here: records + storage at `<home>/data`, legacy clips at
  *  `<home>/clips.db`, provider config at `<home>/config.json`. */
@@ -75,9 +116,12 @@ export async function withLocalBackend(opts = {}) {
         "vidfarm-local-dev-key";
     process.env.VIDFARM_API_KEY = apiKey;
     // Dynamic imports AFTER env is set, so config.ts binds the local drivers.
-    const { ServerlessAuthService } = await import("../services/serverless-auth.js");
+    // Wrapped so the published (cloud-only) CLI — which ships without these backend
+    // modules — fails with a friendly LocalModeUnavailableError instead of a raw
+    // module-not-found stack trace.
+    const { ServerlessAuthService } = await importBackendModule(() => import("../services/serverless-auth.js"));
     const customer = await new ServerlessAuthService().authenticate(apiKey);
-    const appMod = await import("../app.js");
+    const appMod = await importBackendModule(() => import("../app.js"));
     const app = appMod.default;
     cached = { app, apiKey, ownerId: customer.id, home };
     return cached;

package/dist/src/services/clip-curation/cost.js

@@ -13,7 +13,9 @@ const MODEL_PRICING = {
     "gemini-2.5-flash": { input: envPrice("VIDFARM_PRICE_FLASH_INPUT", 0.3), output: envPrice("VIDFARM_PRICE_FLASH_OUTPUT", 2.5) },
     // OpenRouter adds a small markup over Google's list price.
     "google/gemini-2.5-flash": { input: envPrice("VIDFARM_PRICE_OR_FLASH_INPUT", 0.315), output: envPrice("VIDFARM_PRICE_OR_FLASH_OUTPUT", 2.625) },
-    "gpt-5.4-nano": { input: envPrice("VIDFARM_PRICE_GPT5_NANO_INPUT", 0.05), output: envPrice("VIDFARM_PRICE_GPT5_NANO_OUTPUT", 0.4) }
+    "gpt-5.4-nano": { input: envPrice("VIDFARM_PRICE_GPT5_NANO_INPUT", 0.05), output: envPrice("VIDFARM_PRICE_GPT5_NANO_OUTPUT", 0.4) },
+    // Nvidia lite clipping model (minimaxai/minimax-m3) — approximate, env-overridable.
+    "minimaxai/minimax-m3": { input: envPrice("VIDFARM_PRICE_NVIDIA_MINIMAX_INPUT", 0.15), output: envPrice("VIDFARM_PRICE_NVIDIA_MINIMAX_OUTPUT", 0.6) }
 };
 const DEFAULT_TAG_PRICING = { input: 0.15, output: 0.6 };
 const EMBED_PRICING = {
@@ -61,6 +63,8 @@ function defaultTagModel(provider, tier) {
         return "gpt-5.4-nano";
     if (provider === "openrouter")
         return "google/gemini-2.5-flash";
+    if (provider === "nvidia")
+        return "minimaxai/minimax-m3";
     return tier === "flash" ? "gemini-2.5-flash" : "gemini-2.5-flash-lite";
 }
 function compute(input) {

package/dist/src/services/clip-curation/gemini.js

@@ -21,6 +21,8 @@ function resolveTagModel(provider, tier) {
             return process.env.VIDFARM_CLIP_TAG_MODEL_OPENAI ?? "gpt-5.4-nano";
         case "openrouter":
             return process.env.VIDFARM_CLIP_TAG_MODEL_OPENROUTER ?? "google/gemini-2.5-flash";
+        case "nvidia":
+            return process.env.VIDFARM_CLIP_TAG_MODEL_NVIDIA ?? "minimaxai/minimax-m3";
         case "gemini":
         default:
             return tier === "flash"
@@ -281,6 +283,14 @@ function buildLanguageModel(provider, apiKey, modelId, publicBaseUrl) {
                 baseURL: "https://openrouter.ai/api/v1",
                 headers: { "HTTP-Referer": publicBaseUrl ?? "https://vidfarm.cc", "X-Title": "Vidfarm Clips" }
             }).chatModel(modelId);
+        case "nvidia":
+            // Lite, clipping-first key — OpenAI-compatible multimodal chat (frames in,
+            // no audio). No embeddings API (handled by resolveEmbeddingConfig).
+            return createOpenAICompatible({
+                name: "nvidia",
+                apiKey,
+                baseURL: "https://integrate.api.nvidia.com/v1"
+            }).chatModel(modelId);
         case "gemini":
         default:
             return createGoogleGenerativeAI({ apiKey })(modelId);
@@ -302,8 +312,8 @@ function resolveEmbeddingConfig(provider, apiKey, explicit) {
         return { provider: "openai", apiKey };
     return null; // openrouter: no embeddings unless an explicit config is given
 }
-/** The document text embedded for a clip: description + transcript + salient tags. */
-export function buildClipEmbeddingText(tags, description) {
+/** The document text embedded for a clip: description + transcript + salient tags + private owner notes. */
+export function buildClipEmbeddingText(tags, description, userNotes) {
     const parts = [];
     if (description)
         parts.push(description);
@@ -322,6 +332,8 @@ export function buildClipEmbeddingText(tags, description) {
     ];
     if (tagBits.length)
         parts.push(tagBits.join(", "));
+    if (userNotes?.trim())
+        parts.push(`Owner notes: ${userNotes.trim()}`);
     return parts.join("\n").trim() || "video clip";
 }
 export function buildTaggingPrompt(transcript, version, hasAudio = false, guidancePrompt) {

package/dist/src/services/clip-curation/hunt.js

@@ -6,6 +6,7 @@
 // NEVER GhostCut on the long-form source). Shared by devcli (local), the Hono
 // API, and the cloud scan Lambda so every surface parses and normalizes
 // identically. All helpers are pure/deterministic — no AI calls here.
+import { ACTIVE_TAXONOMY_VERSION, getTaxonomy } from "./taxonomy.js";
 // ── Unspecified-prompt defaults ─────────────────────────────────────────────
 // When a user imports a source video without saying what they want, we bias
 // toward the short-form product default: a handful of DISTINCT, vertical,
@@ -293,6 +294,61 @@ export function buildEffectiveGuidance(input) {
         parts.push(AVOID_TEXT_GUIDANCE);
     return parts.join("\n");
 }
+function canonicalizeContentTypeHint(value) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/^#/, "")
+        .replace(/[\s-]+/g, "_");
+    if (!normalized)
+        return null;
+    if (normalized === "broll")
+        return "b_roll";
+    return normalized;
+}
+export function extractUserContentTypeHints(notes, version = ACTIVE_TAXONOMY_VERSION) {
+    const text = String(notes ?? "").trim();
+    if (!text)
+        return [];
+    const allowed = new Set(getTaxonomy(version).categories.content_type.map((value) => canonicalizeContentTypeHint(value)));
+    const found = new Set();
+    const capture = (value) => {
+        const normalized = canonicalizeContentTypeHint(value);
+        if (normalized && allowed.has(normalized))
+            found.add(normalized);
+    };
+    for (const match of text.matchAll(/\b(?:content[_\s-]*type|category|tag)s?\s*[:=]\s*([^\n.;]+)/gi)) {
+        const raw = String(match[1] ?? "");
+        for (const piece of raw.split(/[,/|]+|\band\b/gi))
+            capture(piece);
+    }
+    for (const match of text.matchAll(/\b#?(talking[\s_-]*head|b[\s_-]*roll|product[\s_-]*shot|screen[\s_-]*recording|demo|reaction|interview|establishing|lifestyle|text[\s_-]*graphic)\b/gi)) {
+        capture(String(match[1] ?? ""));
+    }
+    return [...found];
+}
+export function applyUserContentTypeHints(tags, notes, version = ACTIVE_TAXONOMY_VERSION) {
+    const hinted = extractUserContentTypeHints(notes, version);
+    if (!hinted.length)
+        return tags;
+    return {
+        ...tags,
+        content_type: [...new Set([...(tags.content_type ?? []), ...hinted])]
+    };
+}
+export function buildPrivateUserNotesGuidance(notes, version = ACTIVE_TAXONOMY_VERSION) {
+    const text = String(notes ?? "").trim();
+    if (!text)
+        return "";
+    const hinted = extractUserContentTypeHints(text, version);
+    const parts = [
+        `Private owner notes for this raw: "${text}". Use them to bias categorization and description, but stay truthful to the footage.`
+    ];
+    if (hinted.length) {
+        parts.push(`If the footage supports it, include these owner-requested private content_type tags: ${hinted.join(", ")}.`);
+    }
+    return parts.join("\n");
+}
 /**
  * Deterministically extract structured hints from a free-form hunt prompt:
  * "please only hunt for clips between 12:30 and 15:45", "short 10 sec clips",

package/dist/src/services/clip-curation/index.js

@@ -6,7 +6,7 @@ export { ACTIVE_TAXONOMY_VERSION, MULTI_VALUE_CATEGORIES, getTaxonomy, sanitizeT
 export { BUILTIN_PRESETS, findBuiltinPreset } from "./presets.js";
 export { ClipModelClient, ClipGeminiClient, ClipEmbeddingClient, EMBEDDING_DIM, EMBEDDING_MODEL, EMBEDDING_MODELS, TAG_MODEL_BY_TIER, buildClipEmbeddingText, buildQueryPrompt, buildTaggingPrompt, normalize } from "./gemini.js";
 export { LocalAgentClipClient, detectLocalAgent, extractJsonObject } from "./local-agent.js";
-export { AVOID_TEXT_GUIDANCE, DEFAULT_CLIP_ASPECT, DEFAULT_CLIP_DURATION_BAND, DEFAULT_CLIPS_PER_10_MIN, applyHuntSpecDefaults, buildEffectiveGuidance, capScenesEvenlyToCount, cropFilterFor, effectiveHuntDurationSec, fitScenesToDurationBand, normalizeAspect, normalizeCropFocus, normalizeHuntSpec, normalizeWindows, parseClipHuntPrompt, parseTimecode, parseTimeRanges, resolveDurationBand, resolveTargetClipCount } from "./hunt.js";
+export { AVOID_TEXT_GUIDANCE, DEFAULT_CLIP_ASPECT, DEFAULT_CLIP_DURATION_BAND, DEFAULT_CLIPS_PER_10_MIN, applyHuntSpecDefaults, applyUserContentTypeHints, buildEffectiveGuidance, buildPrivateUserNotesGuidance, capScenesEvenlyToCount, cropFilterFor, effectiveHuntDurationSec, extractUserContentTypeHints, fitScenesToDurationBand, normalizeAspect, normalizeCropFocus, normalizeHuntSpec, normalizeWindows, parseClipHuntPrompt, parseTimecode, parseTimeRanges, resolveDurationBand, resolveTargetClipCount } from "./hunt.js";
 export { detectScenes, extractAudioClip, extractClip, extractKeyframes, extractSceneAudio, extractThumbnail, extractWaveformThumbnail, hasFfmpeg, probeVideo, resolveFfmpeg, resolveFfprobe } from "./ffmpeg.js";
 export { cosineSimilarity, matchesCriteria, rankHits, scoreClip, searchClips, structuredMatchRatio } from "./query.js";
 export { estimateScanCostFromDuration, estimateScanCostFromScenes, formatCostEstimate } from "./cost.js";

package/dist/src/services/clip-curation/scan.js

@@ -9,7 +9,7 @@ import { createIdV7 } from "../../lib/ids.js";
 import { ACTIVE_TAXONOMY_VERSION } from "./taxonomy.js";
 import { buildClipEmbeddingText } from "./gemini.js";
 import { detectScenes, extractAudioClip, extractClip, extractKeyframes, extractSceneAudio, extractThumbnail, extractWaveformThumbnail, probeVideo } from "./ffmpeg.js";
-import { capScenesEvenlyToCount, cropFilterFor, fitScenesToDurationBand, normalizeWindows } from "./hunt.js";
+import { applyUserContentTypeHints, capScenesEvenlyToCount, cropFilterFor, fitScenesToDurationBand, normalizeWindows } from "./hunt.js";
 import { refineScenesWithGuidance } from "./refine.js";
 /** Turn one scene into a Clip. Throws only on unrecoverable extraction failure. */
 export async function processSceneToClip(input) {
@@ -46,6 +46,7 @@ export async function processSceneToClip(input) {
         scene,
         guidancePrompt: ctx.guidancePrompt
     });
+    const tags = applyUserContentTypeHints(tagResult.tags, ctx.userNotes, ctx.client.taxonomyVersion ?? ACTIVE_TAXONOMY_VERSION);
     // 4. Cut the clip + thumbnail. Audio-only hunts emit an .m4a (no video) with a
     //    waveform PNG thumbnail; ordinary hunts emit an .mp4 cropped to the target
     //    aspect when requested.
@@ -77,7 +78,7 @@ export async function processSceneToClip(input) {
     // 5. Embed the document text for semantic search (skipped when the client can't embed).
     let embedding;
     if (ctx.client.canEmbed) {
-        const embedText = buildClipEmbeddingText(tagResult.tags, tagResult.description);
+        const embedText = buildClipEmbeddingText(tags, tagResult.description, ctx.userNotes);
         [embedding] = await ctx.client.embedDocuments([embedText]);
     }
     const clip = {
@@ -89,7 +90,7 @@ export async function processSceneToClip(input) {
         duration_sec: scene.duration_sec,
         file_path: ctx.clipStoredPath ? ctx.clipStoredPath(clipId, clipLocal) : clipLocal,
         thumbnail_path: ctx.thumbStoredPath ? ctx.thumbStoredPath(clipId, thumbLocal) : thumbLocal,
-        tags: tagResult.tags,
+        tags,
         description: tagResult.description,
         embedding,
         taxonomy_version: ctx.client.taxonomyVersion ?? ACTIVE_TAXONOMY_VERSION,
@@ -98,6 +99,7 @@ export async function processSceneToClip(input) {
         embedding_model: ctx.client.embeddingModelId ?? undefined,
         aspect: !audioOnly && cropFilter && ctx.crop ? ctx.crop.aspect : undefined,
         media_kind: audioOnly ? "audio" : undefined,
+        user_notes: ctx.userNotes?.trim() || undefined,
         owner_id: input.ownerId,
         created_at: new Date().toISOString()
     };

package/package.json

@@ -1,26 +1,44 @@
 {
   "name": "@mevdragon/vidfarm-devcli",
-  "version": "0.20.6",
+  "version": "0.20.9",
   "description": "Local bridge for the Vidfarm Trackpad Editor. `vidfarm serve <template_id>` boots the FULL editor on localhost (disk-backed records/storage, free in-process render); edit composition.html on disk (Claude Code, Codex, etc.) and the browser live-morphs it.",
   "type": "module",
   "bin": {
     "vidfarm": "dist/src/cli.js",
     "vidfarm-devcli": "dist/src/cli.js"
   },
+  "//files": "PUBLISHED = CLOUD-ONLY CLI. Ships ONLY the CLI's static import closure (backend-free) + shared client utils + skills/docs. The full backend (dist/src/app.js, editor-chat, serverless-*, reskin/, landing/homepage, services/hyperframes|providers|storage|ghostcut|upstream, infra) is INTENTIONALLY EXCLUDED so the server is never open-sourced. `prepack` runs scripts/check-devcli-pack-safe.mjs which HARD-FAILS if any backend file leaks in or a needed CLI file is missing. Do not broaden these globs without re-running that guard.",
   "files": [
-    "dist/src/**/*.js",
-    "dist/src/**/*.json",
-    "demo/dist/**",
-    "public/assets/**",
-    "src/assets/**",
+    "dist/src/cli.js",
+    "dist/src/devcli/captions.js",
+    "dist/src/devcli/clip-store.js",
+    "dist/src/devcli/clips.js",
+    "dist/src/devcli/composition-edit.js",
+    "dist/src/devcli/doctor.js",
+    "dist/src/devcli/hyperframes-cli.js",
+    "dist/src/devcli/local-backend.js",
+    "dist/src/devcli/skills.js",
+    "dist/src/devcli/speech.js",
+    "dist/src/devcli/stills.js",
+    "dist/src/devcli/telemetry.js",
+    "dist/src/devcli/timeline-edit.js",
+    "dist/src/devcli/transitions.js",
+    "dist/src/hyperframes/composition.js",
+    "dist/src/lib/**/*.js",
+    "dist/src/services/captions.js",
+    "dist/src/services/composition-lint.js",
+    "dist/src/services/provider-errors.js",
+    "dist/src/services/speech.js",
+    "dist/src/services/clip-curation/**/*.js",
+    "dist/src/services/clip-curation/**/*.json",
     ".agents/skills/**",
     "README.md",
     "SKILL.director.md",
-    "SKILL.platform.md",
-    "!readme.secret.md"
+    "!readme.secret.md",
+    "!**/*.secret.*"
   ],
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
   "repository": {
     "type": "git",
@@ -48,7 +66,8 @@
     "cdk:deploy:staging-serverless": "npm run build && dotenv -e .env.staging -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-serverless-staging.js'",
     "cdk:deploy:staging-serverless:hotswap": "npm run build && dotenv -e .env.staging -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-serverless-staging.js' --hotswap-fallback --require-approval never",
     "cdk:deploy:prod-serverless:hotswap": "npm run build && dotenv -e .env.production -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-prod.js' --hotswap-fallback --require-approval never",
-    "prepack": "npm run build"
+    "prepack": "npm run build && node scripts/check-devcli-pack-safe.mjs",
+    "check:pack-safe": "node scripts/check-devcli-pack-safe.mjs"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.79",
@@ -96,6 +115,7 @@
     "aws-cdk-lib": "^2.196.0",
     "constructs": "^10.4.2",
     "dotenv-cli": "^11.0.0",
+    "react-grab": "^0.1.48",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "zustand": "^5.0.13"