feedeas 0.1.0-alpha.15 → 0.1.0-alpha.18

package/dist/cli/index.js

@@ -1,11 +1,5 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -92,14 +86,14 @@ var init_playwright_installer = __esm({
 });
 
 // src/cli/index.ts
-import { Command as Command14 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/cli/commands/record.ts
 import { Command } from "commander";
 import { chromium } from "playwright-core";
 import { spawn as spawn4, spawnSync } from "child_process";
-import fs5 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/services/ffprobe.ts
@@ -165,10 +159,91 @@ var FFprobeService = class {
   }
 };
 
+// src/cli/services/assets/resolver.ts
+import fs2 from "node:fs";
+import path from "node:path";
+function looksLikeScheme(uri) {
+  return /^[a-z][a-z0-9+.-]*:/.test(uri);
+}
+var RelativeFsResolver = class {
+  supports(uri) {
+    if (!uri) return false;
+    if (uri.startsWith("http://") || uri.startsWith("https://") || uri.startsWith("data:")) return false;
+    if (uri.startsWith("gcp://")) return false;
+    return !looksLikeScheme(uri) || uri.startsWith("file://") || uri.startsWith("/") || uri.startsWith("./") || uri.startsWith("../");
+  }
+  resolve(uri, rootPath) {
+    if (uri.startsWith("file://")) {
+      const localPath2 = decodeURIComponent(new URL(uri).pathname);
+      return { type: "local", uri, localPath: localPath2 };
+    }
+    const localPath = path.isAbsolute(uri) ? uri : path.resolve(rootPath, uri);
+    return { type: "local", uri, localPath };
+  }
+};
+var HttpResolver = class {
+  supports(uri) {
+    return uri.startsWith("http://") || uri.startsWith("https://");
+  }
+  resolve(uri) {
+    return { type: "remote", uri, remoteUrl: uri };
+  }
+};
+var GcpResolver = class {
+  supports(uri) {
+    return uri.startsWith("gcp://");
+  }
+  resolve(uri) {
+    return {
+      type: "unsupported",
+      uri,
+      reason: "gcp:// resolver is configured as a scaffold. Add a concrete GCP resolver integration to enable this scheme."
+    };
+  }
+};
+var AssetResolverRegistry = class {
+  constructor(resolvers) {
+    this.resolvers = resolvers;
+  }
+  resolve(uri, rootPath) {
+    const resolver = this.resolvers.find((entry) => entry.supports(uri));
+    if (!resolver) {
+      return {
+        type: "unsupported",
+        uri,
+        reason: `Unsupported URI scheme for asset: ${uri}`
+      };
+    }
+    return resolver.resolve(uri, rootPath);
+  }
+  assertUsable(uri, rootPath) {
+    const resolved = this.resolve(uri, rootPath);
+    if (resolved.type === "unsupported") {
+      return { ok: false, reason: resolved.reason };
+    }
+    if (resolved.type === "local" && !fs2.existsSync(resolved.localPath)) {
+      return { ok: false, reason: `Asset not found at ${resolved.localPath}` };
+    }
+    return { ok: true };
+  }
+};
+function createDefaultAssetResolverRegistry() {
+  return new AssetResolverRegistry([
+    new HttpResolver(),
+    new GcpResolver(),
+    new RelativeFsResolver()
+  ]);
+}
+function toBrowserAssetUrl(uri) {
+  if (!uri) return "";
+  if (uri.startsWith("http://") || uri.startsWith("https://") || uri.startsWith("data:")) return uri;
+  return `/api/v1/assets/content?uri=${encodeURIComponent(uri)}`;
+}
+
 // src/cli/services/scene-resolver.ts
-import path from "path";
 var SceneResolver = class {
   static async resolve(scene, projectRoot) {
+    const assetRegistry2 = createDefaultAssetResolverRegistry();
     const resolvedScene = JSON.parse(JSON.stringify(scene));
     const entities = resolvedScene.entities;
     for (const entity of entities) {
@@ -176,9 +251,13 @@ var SceneResolver = class {
         if (entity.type === "audio" || entity.type === "video") {
           if (entity.src) {
             try {
-              const assetPath = path.resolve(projectRoot, entity.src);
-              const metadata = await FFprobeService.getMetadata(assetPath);
-              entity.duration = metadata.duration;
+              const resolved = assetRegistry2.resolve(entity.src, projectRoot);
+              if (resolved.type === "local") {
+                const metadata = await FFprobeService.getMetadata(resolved.localPath);
+                entity.duration = metadata.duration;
+              } else {
+                entity.duration = 5;
+              }
             } catch (e) {
               console.warn(`\u26A0\uFE0F  Could not resolve auto duration for ${entity.src}: ${e}`);
               entity.duration = 5;
@@ -253,13 +332,13 @@ import { cors } from "hono/cors";
 // src/cli/server/api.ts
 import { Hono } from "hono";
 import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
+import { join, dirname, relative } from "node:path";
 import { existsSync } from "node:fs";
 
 // src/cli/server/cli-runner.ts
 import { spawn as spawn2 } from "child_process";
 import path2 from "path";
-import fs2 from "fs";
+import fs3 from "fs";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path2.dirname(__filename);
@@ -269,7 +348,7 @@ async function runCliCommand(args, cwd) {
   let spawnArgs;
   if (isCompiled) {
     const binPath = path2.resolve(__dirname, "../../../bin/feedeas.js");
-    if (!fs2.existsSync(binPath)) {
+    if (!fs3.existsSync(binPath)) {
       throw new Error(`Could not find compiled CLI binary at ${binPath}`);
     }
     command = "node";
@@ -342,6 +421,60 @@ ${stderrData || stdoutData}`));
 
 // src/cli/services/taste.ts
 import path3 from "node:path";
+var SAMPLE_SCENE_HEADER = "## Sample Scene (Starter)";
+var DEFAULT_SAMPLE_SCENE_JSON = {
+  meta: {
+    width: 1080,
+    height: 1350,
+    duration: 5
+  },
+  entities: [
+    {
+      id: "text-1",
+      type: "text",
+      name: "Hook",
+      text: "Your Hook Goes Here",
+      startTime: 0,
+      duration: 5,
+      visible: true,
+      x: 540,
+      y: 520,
+      fontSize: 72,
+      fontFamily: "Inter, system-ui",
+      fontWeight: "bold",
+      color: "#ffffff",
+      bgColor: "transparent",
+      maxWidth: 880,
+      lineHeight: 1.2,
+      padding: 0,
+      textAlign: "center",
+      enter: { type: "scale", duration: 0.4 }
+    }
+  ]
+};
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isValidSampleScene(value) {
+  if (!isObject(value)) return false;
+  if (!isObject(value.meta)) return false;
+  if (!Array.isArray(value.entities)) return false;
+  return value.entities.length > 0;
+}
+function formatSampleSceneSection(scene) {
+  const normalized = isValidSampleScene(scene) ? scene : DEFAULT_SAMPLE_SCENE_JSON;
+  const json = JSON.stringify(normalized, null, 2);
+  return `${SAMPLE_SCENE_HEADER}
+Use this as a copy-ready baseline and adapt per concept.
+
+\`\`\`json
+${json}
+\`\`\``;
+}
+var SAMPLE_SCENE_SECTION = formatSampleSceneSection(DEFAULT_SAMPLE_SCENE_JSON);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var DEFAULT_TASTE_FILE_CONTENT = `# Taste File v1
 ## Brand Identity
 Describe brand voice, tone, and core promise.
@@ -367,6 +500,8 @@ Describe visual and narrative constraints.
 ## Freshness Rules
 State how each new idea should stay fresh.
 
+${SAMPLE_SCENE_SECTION}
+
 ## Generation Instructions
 Give concrete instructions for generating content ideas.
 `;
@@ -425,6 +560,28 @@ function safeResolveFromCwd(relativePath) {
   }
   return fullPath;
 }
+function ensureSampleSceneSection(content, sampleScene) {
+  const current = (content || "").trim();
+  if (!current) return DEFAULT_TASTE_FILE_CONTENT;
+  const section = formatSampleSceneSection(sampleScene);
+  if (current.includes(SAMPLE_SCENE_HEADER)) {
+    const escapedHeader = escapeRegExp(SAMPLE_SCENE_HEADER);
+    return current.replace(
+      new RegExp(`${escapedHeader}[\\s\\S]*?(?=\\n##\\s|$)`),
+      section
+    ).trimEnd() + "\n";
+  }
+  const generationHeader = "## Generation Instructions";
+  if (current.includes(generationHeader)) {
+    return current.replace(generationHeader, `${section}
+
+${generationHeader}`).trimEnd() + "\n";
+  }
+  return `${current}
+
+${section}
+`;
+}
 function parseListValue(value) {
   const trimmed = value.trim();
   if (!trimmed) return [];
@@ -641,6 +798,115 @@ function extractJson(text) {
   }
   throw new Error("Could not parse JSON from model response");
 }
+function tryExtractJson(text) {
+  try {
+    return extractJson(text);
+  } catch {
+    return null;
+  }
+}
+function tryExtractLooseJson(text) {
+  const cleaned = (text || "").trim();
+  if (!cleaned) return null;
+  const withoutPrefix = cleaned.startsWith("json") ? cleaned.replace(/^json\s*/i, "").trim() : cleaned;
+  const candidate = tryExtractJson(withoutPrefix);
+  if (candidate) return candidate;
+  const firstBrace = withoutPrefix.indexOf("{");
+  const lastBrace = withoutPrefix.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    const slice = withoutPrefix.slice(firstBrace, lastBrace + 1);
+    try {
+      return JSON.parse(slice);
+    } catch {
+      return null;
+    }
+  }
+  if (withoutPrefix.startsWith('"') && withoutPrefix.endsWith('"')) {
+    try {
+      const parsed = JSON.parse(withoutPrefix);
+      if (typeof parsed === "string") {
+        return tryExtractLooseJson(parsed);
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function extractReplyFromRaw(raw) {
+  const match = raw.match(/"reply"\s*:\s*([\s\S]*?)(?:,"proposedTasteContent"|,"sampleScene"|,"citationIds"|,"askUser"|}\s*$)/i);
+  if (!match?.[1]) return void 0;
+  let value = match[1].trim();
+  if (value.startsWith('"')) {
+    const endQuote = value.lastIndexOf('"');
+    if (endQuote > 0) {
+      value = value.slice(1, endQuote);
+    }
+    value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
+  }
+  return value.trim() || void 0;
+}
+function extractProposedTasteContentFromRaw(raw) {
+  const fenced = raw.match(/```(?:md|markdown)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]?.includes("# Taste File")) {
+    return fenced[1].trim();
+  }
+  const jsonBlock = raw.match(/\{[\s\S]*\}/);
+  if (jsonBlock?.[0]) {
+    try {
+      const parsed = JSON.parse(jsonBlock[0]);
+      if (parsed && typeof parsed.proposedTasteContent === "string") {
+        return parsed.proposedTasteContent.trim();
+      }
+    } catch {
+    }
+  }
+  const fieldMatch = raw.match(/"proposedTasteContent"\s*:\s*([\s\S]*?)(?:,"citationIds"|,"sampleScene"|,"askUser"|}\s*$)/i);
+  if (fieldMatch?.[1]) {
+    let value = fieldMatch[1].trim();
+    if (value.startsWith("```")) {
+      const fencedValue = value.match(/```(?:md|markdown|json)?\s*([\s\S]*?)```/i);
+      if (fencedValue?.[1]) {
+        return fencedValue[1].trim();
+      }
+    }
+    if (value.startsWith('"')) {
+      const endQuote = value.lastIndexOf('"');
+      if (endQuote > 0) {
+        value = value.slice(1, endQuote);
+      }
+      value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
+    }
+    if (value.includes("# Taste File")) {
+      const markerIndex = value.indexOf("# Taste File");
+      return value.slice(markerIndex).trim();
+    }
+    return value.trim() || void 0;
+  }
+  const marker = "# Taste File";
+  const idx = raw.indexOf(marker);
+  if (idx === -1) return void 0;
+  const candidate = raw.slice(idx).trim();
+  return candidate.length > marker.length ? candidate : void 0;
+}
+function normalizeProposedTasteContent(content) {
+  const trimmed = (content || "").trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "string") {
+        return parsed.trim();
+      }
+    } catch {
+    }
+  }
+  if (!trimmed.includes("\n") && trimmed.includes("\\n")) {
+    return trimmed.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').trim();
+  }
+  return trimmed;
+}
 function coerceString(value) {
   if (value == null) return "";
   if (typeof value === "string") return value.trim();
@@ -667,6 +933,140 @@ function coerceStringArray(value) {
   }
   return coerceString(value).split(/[,\n]/g).map((item) => item.trim()).filter(Boolean);
 }
+function normalizedId(prefix, idx) {
+  return `${prefix}_${Date.now()}_${idx + 1}`;
+}
+function normalizeBullets(value) {
+  const arr = coerceStringArray(value).map((item) => item.replace(/^[-*]\s*/, "").trim()).filter(Boolean);
+  if (arr.length >= 3) return arr.slice(0, 5);
+  const fallback = [...arr];
+  const defaults = [
+    "Opening hook scene and visual direction",
+    "Main beat that demonstrates the core value",
+    "Closing beat with CTA or payoff"
+  ];
+  for (const item of defaults) {
+    if (fallback.length >= 3) break;
+    fallback.push(item);
+  }
+  return fallback.slice(0, 5);
+}
+function extractPlanCard(value, idx) {
+  const objectValue = typeof value === "object" && value !== null ? value : {};
+  const title = coerceString(
+    objectValue.title || objectValue.name || objectValue.idea || objectValue.heading || `Plan ${idx + 1}`
+  ) || `Plan ${idx + 1}`;
+  const bullets = normalizeBullets(
+    objectValue.bullets || objectValue.plannedScenes || objectValue.scenes || objectValue.points || objectValue.items
+  ).map((text, bulletIdx) => ({
+    id: `${normalizedId("bullet", idx)}_${bulletIdx + 1}`,
+    text
+  }));
+  return {
+    id: normalizedId("card", idx),
+    title,
+    bullets,
+    freshnessScore: void 0
+  };
+}
+function parsePlanCardsFromModel(raw, count) {
+  let parsed = null;
+  try {
+    parsed = extractJson(raw);
+  } catch {
+  }
+  const source = parsed?.cards || parsed?.ideas || parsed?.plans || parsed;
+  const list = Array.isArray(source) ? source : [source].filter(Boolean);
+  const cards = list.map((item, idx) => extractPlanCard(item, idx)).filter((item) => item.title && item.bullets.length >= 3);
+  if (cards.length >= count) return cards.slice(0, count);
+  const padded = [...cards];
+  while (padded.length < count) {
+    const idx = padded.length;
+    padded.push(extractPlanCard({ title: `Plan ${idx + 1}`, bullets: [] }, idx));
+  }
+  return padded;
+}
+function parseFollowupPromptsFromModel(raw, bulletId, defaultCount = 4) {
+  let parsed = null;
+  try {
+    parsed = extractJson(raw);
+  } catch {
+  }
+  const source = parsed?.prompts || parsed?.images || parsed?.variants || parsed;
+  const values = Array.isArray(source) ? source : source ? [source] : [];
+  const prompts = values.map((value) => {
+    const item = typeof value === "object" && value !== null ? value : {};
+    return {
+      prompt: coerceString(item.prompt || item.text || value),
+      style: coerceString(item.style || item.look),
+      shotType: coerceString(item.shotType || item.shot_type || item.shot),
+      negativePrompt: coerceString(item.negativePrompt || item.negative_prompt || item.negative)
+    };
+  }).filter((item) => item.prompt);
+  const normalized = prompts.length > 0 ? prompts.slice(0, 6) : [{
+    prompt: coerceString(raw) || "Cinematic portrait scene matching the selected bullet with clear subject and composition.",
+    style: "",
+    shotType: "medium",
+    negativePrompt: "blurry, overexposed, cluttered frame"
+  }];
+  while (normalized.length < Math.min(defaultCount, 6)) {
+    normalized.push({
+      prompt: `${normalized[0].prompt} (variant ${normalized.length + 1})`,
+      style: normalized[0].style,
+      shotType: normalized[0].shotType,
+      negativePrompt: normalized[0].negativePrompt
+    });
+  }
+  return {
+    bulletId,
+    prompts: normalized.slice(0, 6)
+  };
+}
+function normalizeAskUser(source, maxPrompts = 3) {
+  if (!source) return void 0;
+  const entries = Array.isArray(source) ? source : [source];
+  const prompts = entries.map((entry, promptIndex) => {
+    const record = typeof entry === "object" && entry !== null ? entry : {};
+    const prompt = coerceString(record.prompt || record.question || record.title);
+    if (!prompt) return null;
+    const id = coerceString(record.id) || `ask_${Date.now()}_${promptIndex}`;
+    const helper = coerceString(record.helper);
+    const allowFreeText = Boolean(record.allowFreeText ?? record.allow_free_text);
+    const maxSelectionsRaw = Number(record.maxSelections ?? record.max_selections);
+    const maxSelections = Number.isFinite(maxSelectionsRaw) && maxSelectionsRaw > 0 ? maxSelectionsRaw : void 0;
+    const optionSource = Array.isArray(record.options) ? record.options : Array.isArray(record.choices) ? record.choices : [];
+    const options = optionSource.map((opt, optionIndex) => {
+      const optRecord = typeof opt === "object" && opt !== null ? opt : {};
+      const label = coerceString(optRecord.label || optRecord.title || optRecord.text || optRecord.value);
+      const value = coerceString(optRecord.value || optRecord.label || optRecord.text || label);
+      if (!label && !value) return null;
+      const imagePrompt = coerceString(optRecord.imagePrompt || optRecord.image_prompt);
+      const imageUrl = coerceString(optRecord.imageUrl || optRecord.image_url);
+      const imageUri = coerceString(optRecord.imageUri || optRecord.image_uri);
+      const type = coerceString(optRecord.type) === "image" || imagePrompt || imageUrl || imageUri ? "image" : "text";
+      return {
+        id: coerceString(optRecord.id) || `${id}_opt_${optionIndex}`,
+        label: label || value,
+        value: value || label,
+        type,
+        imagePrompt: imagePrompt || void 0,
+        imageUrl: imageUrl || void 0,
+        imageUri: imageUri || void 0
+      };
+    }).filter(Boolean);
+    if (options.length === 0) return null;
+    return {
+      id,
+      prompt,
+      helper: helper || void 0,
+      options: options.slice(0, 6),
+      allowFreeText,
+      maxSelections
+    };
+  }).filter(Boolean);
+  if (prompts.length === 0) return void 0;
+  return prompts.slice(0, Math.min(maxPrompts, 3));
+}
 async function callGeminiText(prompt, apiKey, model = "gemini-2.5-flash") {
   const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
   const response = await fetch(`${endpoint}?key=${apiKey}`, {
@@ -691,11 +1091,31 @@ async function callGeminiText(prompt, apiKey, model = "gemini-2.5-flash") {
 }
 async function runTasteChat(params) {
   const sampleMemories = params.memories.slice(0, 10).map((m) => `${m.id}: ${m.title}`).join("\n");
+  const history = (params.chatHistory || []).slice(-8).map((entry) => `${entry.role === "user" ? "User" : "Assistant"}: ${entry.text}`).join("\n");
+  const askUserCount = Number(params.askUserCount || 0);
+  const askUserMax = Number(params.askUserMax || 3);
+  const interactionCount = Number(params.interactionCount || 0);
+  const interactionMin = Number(params.interactionMin || 3);
+  const interactionMax = Number(params.interactionMax || 6);
   const prompt = [
     "You are a taste-file assistant for social content strategy.",
     "Given user message and taste file, respond with practical guidance.",
+    "When offering choices, include AskUser prompts with clickable options; otherwise ask open questions in reply.",
+    "Prefer text choices. Use image choices only when visual style or theme selection is best.",
+    `You have used ${askUserCount}/${askUserMax} AskUser interactions. If count >= max, draft proposedTasteContent now.`,
+    `You have used ${interactionCount}/${interactionMax} total interactions. Do not draft before ${interactionMin} unless user explicitly asks.`,
+    "Do NOT draft proposedTasteContent before the limit unless the user explicitly asks for a rewrite or a draft.",
+    "If you are NOT drafting, do NOT include proposedTasteContent and do NOT include raw JSON in reply.",
     "If rewrite is needed, return full updated taste markdown in proposedTasteContent.",
-    'Return strict JSON: {"reply": "...", "proposedTasteContent": "... optional ...", "citationIds": ["mem_id"]}',
+    "Taste files are reusable generators, NOT one-off idea drafts or simulations.",
+    "When drafting proposedTasteContent, do NOT include specific content ideas, scripts, or single-topic writeups.",
+    "Instead, define reusable guidance: brand voice, audience, focus areas, negatives, content formats, style constraints, freshness rules, and explicit generation instructions.",
+    "Generation Instructions must be procedural and reusable: define step-by-step idea generation, required output format, and hook/delivery constraints.",
+    "If rewrite is needed, also return sampleScene as a valid feedeas scene JSON object (with meta + entities).",
+    'Return strict JSON: {"reply": "...", "proposedTasteContent": "... optional ...", "sampleScene": {... optional ...}, "citationIds": ["mem_id"], "askUser": [{"id":"...","prompt":"...","helper":"... optional","allowFreeText":true,"maxSelections":1,"options":[{"id":"...","label":"...","value":"...","type":"text|image","imagePrompt":"... optional"}]}]}',
+    "",
+    `Chat history:
+${history || "(none)"}`,
     "",
     `User message:
 ${params.message}`,
@@ -707,14 +1127,41 @@ ${params.tasteContent}`,
 ${sampleMemories || "(none)"}`
   ].join("\n");
   const raw = await callGeminiText(prompt, params.apiKey, params.model);
-  const parsed = extractJson(raw);
+  const userRequestedRewrite = /\b(rewrite|draft|update|apply|revise|refresh|create\s+the\s+taste|generate\s+the\s+taste)\b/i.test(params.message);
+  const allowDraft = userRequestedRewrite || interactionCount >= interactionMax || askUserCount >= askUserMax && interactionCount >= interactionMin;
+  const parsed = tryExtractJson(raw) ?? tryExtractLooseJson(raw);
+  if (!parsed) {
+    const recovered = allowDraft ? extractProposedTasteContentFromRaw(raw) : void 0;
+    const normalized = recovered ? normalizeProposedTasteContent(recovered) : void 0;
+    const extractedReply = extractReplyFromRaw(raw);
+    const fallbackReply = extractedReply || coerceString(raw);
+    const reply = normalized ? "Drafted a rewrite. Review and apply if it looks right." : fallbackReply.trim().startsWith("{") || fallbackReply.includes('"proposedTasteContent"') ? "Got it. To narrow this down, what specific angle or constraint should I prioritize next?" : fallbackReply;
+    return {
+      reply,
+      proposedTasteContent: normalized ? ensureSampleSceneSection(normalized) : void 0,
+      citations: []
+    };
+  }
   const citationIds = Array.isArray(parsed.citationIds) ? parsed.citationIds : [];
   const citationMap = new Map(params.memories.map((m) => [m.id, m.title]));
   const citations = citationIds.filter((id) => citationMap.has(id)).map((id) => ({ memoryId: id, title: citationMap.get(id) || id }));
+  const sampleScene = parsed.sampleScene;
+  const askUser = askUserCount >= askUserMax ? void 0 : normalizeAskUser(parsed.askUser || parsed.ask_user, askUserMax);
+  const proposedTasteContent = allowDraft && parsed.proposedTasteContent ? ensureSampleSceneSection(normalizeProposedTasteContent(coerceString(parsed.proposedTasteContent)), sampleScene) : (() => {
+    if (!allowDraft) return void 0;
+    const recovered = extractProposedTasteContentFromRaw(raw);
+    const normalized = recovered ? normalizeProposedTasteContent(recovered) : void 0;
+    return normalized ? ensureSampleSceneSection(normalized, sampleScene) : void 0;
+  })();
+  const sanitizedProposed = proposedTasteContent?.trim().startsWith("{") && proposedTasteContent.includes('"reply"') ? (() => {
+    const recovered = extractProposedTasteContentFromRaw(proposedTasteContent);
+    return recovered ? normalizeProposedTasteContent(recovered) : proposedTasteContent;
+  })() : proposedTasteContent;
   return {
     reply: coerceString(parsed.reply || raw),
-    proposedTasteContent: parsed.proposedTasteContent ? coerceString(parsed.proposedTasteContent) : void 0,
-    citations
+    proposedTasteContent: sanitizedProposed,
+    citations,
+    askUser
   };
 }
 async function generateIdea(tasteContent, memories, apiKey, model) {
@@ -732,16 +1179,133 @@ ${tasteContent}`,
 ${recent || "(none)"}`
   ].join("\n");
   const raw = await callGeminiText(prompt, apiKey, model);
-  const parsed = extractJson(raw);
+  const parsed = tryExtractJson(raw) || {};
   return {
     title: coerceString(parsed.title || "Untitled idea"),
     format: coerceString(parsed.format || "daily-reel") || "daily-reel",
     tags: coerceStringArray(parsed.tags),
     freshnessTerms: coerceStringArray(parsed.freshnessTerms || parsed.freshness_terms),
-    summary: coerceString(parsed.summary),
-    content: coerceString(parsed.content)
+    summary: coerceString(parsed.summary || raw.split("\n").slice(0, 2).join(" ").slice(0, 220)),
+    content: coerceString(parsed.content || raw)
+  };
+}
+async function generatePlanCard(tasteContent, memories, apiKey, model) {
+  const recent = memories.slice(0, 20).map((m) => `- ${m.title}: ${m.summary}`).join("\n");
+  const prompt = [
+    "Generate one simple simulation card from this taste file.",
+    "Keep it coach-like and steerable.",
+    "Return strict JSON with keys: title, bullets (array of 3 to 5 concise planned scenes).",
+    "",
+    `Taste file:
+${tasteContent}`,
+    "",
+    `Recent ideas:
+${recent || "(none)"}`
+  ].join("\n");
+  const raw = await callGeminiText(prompt, apiKey, model);
+  return parsePlanCardsFromModel(raw, 1)[0];
+}
+function computePlanCardOverlap(candidate, existing) {
+  const candidateText = `${candidate.title} ${candidate.bullets.map((b) => b.text).join(" ")}`;
+  const candidateTokens = tokenize(candidateText);
+  let maxScore = 0;
+  for (const prev of existing) {
+    const prevText = `${prev.title} ${prev.bullets.map((b) => b.text).join(" ")}`;
+    const prevTokens = tokenize(prevText);
+    maxScore = Math.max(maxScore, jaccard(candidateTokens, prevTokens));
+  }
+  return maxScore;
+}
+async function simulatePlanCards(params) {
+  const model = params.model || "gemini-2.5-flash";
+  const existingCards = params.memories.slice(0, 40).map((memory, idx) => ({
+    id: `mem_card_${idx + 1}`,
+    title: memory.title,
+    bullets: normalizeBullets(memory.summary || memory.content).map((text, bulletIdx) => ({
+      id: `mem_bullet_${idx + 1}_${bulletIdx + 1}`,
+      text
+    }))
+  }));
+  const cards = [];
+  const rejected = [];
+  const targetCount = Math.max(1, params.count);
+  const threshold = 0.6;
+  const generateWithChecks = async () => {
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      const candidate = await generatePlanCard(params.tasteContent, params.memories, params.apiKey, model);
+      const overlap = computePlanCardOverlap(candidate, [...existingCards, ...cards]);
+      if (overlap <= threshold) {
+        candidate.freshnessScore = Number((1 - overlap).toFixed(3));
+        return candidate;
+      }
+      rejected.push({
+        title: candidate.title,
+        reason: "overlap too high",
+        overlapScore: Number(overlap.toFixed(3))
+      });
+    }
+    return null;
+  };
+  if (params.mode === "parallel") {
+    const generated = await Promise.all(
+      Array.from({ length: targetCount }, () => generatePlanCard(params.tasteContent, params.memories, params.apiKey, model))
+    );
+    for (const candidate of generated) {
+      const overlap = computePlanCardOverlap(candidate, [...existingCards, ...cards]);
+      if (overlap <= threshold) {
+        candidate.freshnessScore = Number((1 - overlap).toFixed(3));
+        cards.push(candidate);
+      } else {
+        rejected.push({
+          title: candidate.title,
+          reason: "parallel overlap filter",
+          overlapScore: Number(overlap.toFixed(3))
+        });
+      }
+    }
+  }
+  while (cards.length < targetCount) {
+    const card = await generateWithChecks();
+    if (!card) break;
+    cards.push(card);
+  }
+  return {
+    ideas: [],
+    planCards: cards.slice(0, targetCount),
+    rejected,
+    mode: params.mode,
+    stats: {
+      requested: targetCount,
+      accepted: cards.length,
+      rejected: rejected.length
+    }
   };
 }
+async function generateBulletFollowupPrompts(params) {
+  const model = params.model || "gemini-2.5-flash";
+  const target = Math.max(3, Math.min(6, params.count || 4));
+  const memoryHints = params.memories.slice(0, 10).map((m) => `- ${m.title}: ${m.summary}`).join("\n");
+  const prompt = [
+    "Generate image prompt variants for a selected planned scene bullet.",
+    "Return strict JSON with key prompts (array of objects).",
+    "Each object keys: prompt, style, shotType, negativePrompt.",
+    `Return ${target} to 6 variants.`,
+    "",
+    `Taste file:
+${params.tasteContent}`,
+    "",
+    `Card title:
+${params.cardTitle}`,
+    "",
+    `Selected bullet:
+${params.bulletText}`,
+    "",
+    `Memory hints:
+${memoryHints || "(none)"}`
+  ].join("\n");
+  const raw = await callGeminiText(prompt, params.apiKey, model);
+  return parseFollowupPromptsFromModel(raw, params.bulletId, target);
+}
 async function simulateIdeas(params) {
   const model = params.model || "gemini-2.5-flash";
   const existing = [...params.memories];
@@ -801,7 +1365,7 @@ async function simulateIdeas(params) {
 }
 
 // src/cli/services/taste-store.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import path4 from "node:path";
 import { createHash } from "node:crypto";
 var DEFAULT_SUGGESTIONS_FILE_CONTENT = "# Taste Suggestions v1\n";
@@ -925,45 +1489,46 @@ var MarkdownTasteStore = class {
   }
   async ensureWorkspace() {
     const { tastePath, memoryPath, suggestionsPath } = this.resolveAll();
-    fs3.mkdirSync(path4.dirname(tastePath), { recursive: true });
-    fs3.mkdirSync(path4.dirname(memoryPath), { recursive: true });
-    fs3.mkdirSync(path4.dirname(suggestionsPath), { recursive: true });
-    if (!fs3.existsSync(tastePath)) {
-      fs3.writeFileSync(tastePath, DEFAULT_TASTE_FILE_CONTENT, "utf-8");
+    fs4.mkdirSync(path4.dirname(tastePath), { recursive: true });
+    fs4.mkdirSync(path4.dirname(memoryPath), { recursive: true });
+    fs4.mkdirSync(path4.dirname(suggestionsPath), { recursive: true });
+    if (!fs4.existsSync(tastePath)) {
+      fs4.writeFileSync(tastePath, DEFAULT_TASTE_FILE_CONTENT, "utf-8");
     }
-    if (!fs3.existsSync(memoryPath)) {
-      fs3.writeFileSync(memoryPath, DEFAULT_MEMORY_FILE_CONTENT, "utf-8");
+    if (!fs4.existsSync(memoryPath)) {
+      fs4.writeFileSync(memoryPath, DEFAULT_MEMORY_FILE_CONTENT, "utf-8");
     }
-    if (!fs3.existsSync(suggestionsPath)) {
-      fs3.writeFileSync(suggestionsPath, DEFAULT_SUGGESTIONS_FILE_CONTENT, "utf-8");
+    if (!fs4.existsSync(suggestionsPath)) {
+      fs4.writeFileSync(suggestionsPath, DEFAULT_SUGGESTIONS_FILE_CONTENT, "utf-8");
     }
   }
   async readTaste() {
     await this.ensureWorkspace();
     const { tastePath } = this.resolveAll();
-    const content = fs3.readFileSync(tastePath, "utf-8");
+    const content = fs4.readFileSync(tastePath, "utf-8");
     return { content, version: hashContent(content) };
   }
   async writeTaste(content, expectedVersion) {
     await this.ensureWorkspace();
     const { tastePath } = this.resolveAll();
-    const current = fs3.existsSync(tastePath) ? fs3.readFileSync(tastePath, "utf-8") : "";
+    const current = fs4.existsSync(tastePath) ? fs4.readFileSync(tastePath, "utf-8") : "";
     const currentVersion = hashContent(current);
     if (expectedVersion && expectedVersion !== currentVersion) {
       throw new Error("Taste file changed since proposal creation. Re-run suggest before apply.");
     }
-    fs3.writeFileSync(tastePath, content, "utf-8");
-    return { version: hashContent(content) };
+    const normalized = ensureSampleSceneSection(content);
+    fs4.writeFileSync(tastePath, normalized, "utf-8");
+    return { version: hashContent(normalized) };
   }
   async appendMemory(entry) {
     await this.ensureWorkspace();
     const { memoryPath } = this.resolveAll();
-    const current = fs3.existsSync(memoryPath) ? fs3.readFileSync(memoryPath, "utf-8") : "";
+    const current = fs4.existsSync(memoryPath) ? fs4.readFileSync(memoryPath, "utf-8") : "";
     const id = buildId("mem");
     const markdown = `${(current || DEFAULT_MEMORY_FILE_CONTENT).trimEnd()}
 
 ${formatMemoryEntry(entry, id)}`;
-    fs3.writeFileSync(memoryPath, markdown, "utf-8");
+    fs4.writeFileSync(memoryPath, markdown, "utf-8");
     const parsed = parseTasteMemoryMarkdown(markdown).find((item) => item.id === id);
     if (!parsed) {
       throw new Error("Failed to append memory entry");
@@ -973,14 +1538,14 @@ ${formatMemoryEntry(entry, id)}`;
   async queryMemory(options) {
     await this.ensureWorkspace();
     const { memoryPath } = this.resolveAll();
-    const content = fs3.existsSync(memoryPath) ? fs3.readFileSync(memoryPath, "utf-8") : "";
+    const content = fs4.existsSync(memoryPath) ? fs4.readFileSync(memoryPath, "utf-8") : "";
     const items = parseTasteMemoryMarkdown(content);
     return queryMemoryItems(items, options);
   }
   async appendSuggestion(suggestion) {
     await this.ensureWorkspace();
     const { suggestionsPath } = this.resolveAll();
-    const current = fs3.existsSync(suggestionsPath) ? fs3.readFileSync(suggestionsPath, "utf-8") : "";
+    const current = fs4.existsSync(suggestionsPath) ? fs4.readFileSync(suggestionsPath, "utf-8") : "";
     const entry = {
       id: buildId("sug"),
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -997,13 +1562,13 @@ ${formatMemoryEntry(entry, id)}`;
     };
     const existing = parseSuggestionMarkdown(current);
     const markdown = formatSuggestionsMarkdown([...existing, entry]);
-    fs3.writeFileSync(suggestionsPath, markdown, "utf-8");
+    fs4.writeFileSync(suggestionsPath, markdown, "utf-8");
     return entry;
   }
   async listSuggestions(status) {
     await this.ensureWorkspace();
     const { suggestionsPath } = this.resolveAll();
-    const current = fs3.existsSync(suggestionsPath) ? fs3.readFileSync(suggestionsPath, "utf-8") : "";
+    const current = fs4.existsSync(suggestionsPath) ? fs4.readFileSync(suggestionsPath, "utf-8") : "";
     const entries = parseSuggestionMarkdown(current).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
     if (!status) {
       return entries;
@@ -1013,7 +1578,7 @@ ${formatMemoryEntry(entry, id)}`;
   async updateSuggestionStatus(id, status, metadata) {
     await this.ensureWorkspace();
     const { suggestionsPath } = this.resolveAll();
-    const current = fs3.existsSync(suggestionsPath) ? fs3.readFileSync(suggestionsPath, "utf-8") : "";
+    const current = fs4.existsSync(suggestionsPath) ? fs4.readFileSync(suggestionsPath, "utf-8") : "";
     const entries = parseSuggestionMarkdown(current);
     const idx = entries.findIndex((entry) => entry.id === id);
     if (idx === -1) {
@@ -1028,7 +1593,7 @@ ${formatMemoryEntry(entry, id)}`;
       reviewNote: metadata?.reviewNote
     };
     entries[idx] = updated;
-    fs3.writeFileSync(suggestionsPath, formatSuggestionsMarkdown(entries), "utf-8");
+    fs4.writeFileSync(suggestionsPath, formatSuggestionsMarkdown(entries), "utf-8");
     return updated;
   }
 };
@@ -1081,9 +1646,216 @@ function createTasteStore(params) {
   return new MarkdownTasteStore(paths);
 }
 
+// src/cli/services/scenes/file-store.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { randomUUID } from "node:crypto";
+
+// src/cli/services/scenes/types.ts
+var NotFoundError = class extends Error {
+};
+var ConflictError = class extends Error {
+};
+
+// src/cli/services/scenes/file-store.ts
+var DEFAULT_SCENE = {
+  meta: {
+    width: 1080,
+    height: 1920,
+    duration: 10
+  },
+  entities: []
+};
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function getStorePath(cwd) {
+  return path5.resolve(cwd, ".feedeas/store.json");
+}
+function ensureStore(pathname) {
+  const dir = path5.dirname(pathname);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  if (!fs5.existsSync(pathname)) {
+    const initial = { projects: [], scenes: [] };
+    fs5.writeFileSync(pathname, JSON.stringify(initial, null, 2), "utf-8");
+    return initial;
+  }
+  const parsed = JSON.parse(fs5.readFileSync(pathname, "utf-8"));
+  return {
+    projects: parsed.projects || [],
+    scenes: parsed.scenes || []
+  };
+}
+function saveStore(pathname, data) {
+  fs5.writeFileSync(pathname, JSON.stringify(data, null, 2), "utf-8");
+}
+var FileProjectStore = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  load() {
+    return ensureStore(getStorePath(this.cwd));
+  }
+  save(data) {
+    saveStore(getStorePath(this.cwd), data);
+  }
+  async createProject(input) {
+    const data = this.load();
+    const now = nowIso();
+    const project = {
+      id: randomUUID(),
+      name: input.name,
+      defaultSceneId: null,
+      rootPath: input.rootPath || this.cwd,
+      ownerId: input.ownerId || null,
+      createdAt: now,
+      updatedAt: now
+    };
+    data.projects.push(project);
+    this.save(data);
+    return project;
+  }
+  async listProjects() {
+    const data = this.load();
+    return [...data.projects].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async getProject(projectId) {
+    const data = this.load();
+    return data.projects.find((p) => p.id === projectId) || null;
+  }
+  async updateProject(projectId, updates) {
+    const data = this.load();
+    const idx = data.projects.findIndex((p) => p.id === projectId);
+    if (idx === -1) {
+      throw new NotFoundError(`Project not found: ${projectId}`);
+    }
+    const next = {
+      ...data.projects[idx],
+      ...updates,
+      updatedAt: nowIso()
+    };
+    data.projects[idx] = next;
+    this.save(data);
+    return next;
+  }
+};
+var FileSceneStore = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  load() {
+    return ensureStore(getStorePath(this.cwd));
+  }
+  save(data) {
+    saveStore(getStorePath(this.cwd), data);
+  }
+  ensureProject(data, projectId) {
+    const found = data.projects.some((p) => p.id === projectId);
+    if (!found) {
+      throw new NotFoundError(`Project not found: ${projectId}`);
+    }
+  }
+  async listScenes(projectId) {
+    const data = this.load();
+    this.ensureProject(data, projectId);
+    return data.scenes.filter((s) => s.projectId === projectId).sort((a, b) => a.orderIndex - b.orderIndex || a.createdAt.localeCompare(b.createdAt));
+  }
+  async getScene(projectId, sceneId) {
+    const data = this.load();
+    this.ensureProject(data, projectId);
+    return data.scenes.find((s) => s.projectId === projectId && s.id === sceneId) || null;
+  }
+  async createScene(projectId, input) {
+    const data = this.load();
+    this.ensureProject(data, projectId);
+    const projectScenes = data.scenes.filter((s) => s.projectId === projectId);
+    const nextOrder = input.orderIndex ?? projectScenes.length;
+    const now = nowIso();
+    const record = {
+      id: randomUUID(),
+      projectId,
+      name: input.name || `Scene ${projectScenes.length + 1}`,
+      orderIndex: nextOrder,
+      version: 1,
+      meta: input.scene?.meta || DEFAULT_SCENE.meta,
+      entities: input.scene?.entities || DEFAULT_SCENE.entities,
+      createdAt: now,
+      updatedAt: now
+    };
+    data.scenes.push(record);
+    const projectIdx = data.projects.findIndex((p) => p.id === projectId);
+    if (projectIdx >= 0 && !data.projects[projectIdx].defaultSceneId) {
+      data.projects[projectIdx] = {
+        ...data.projects[projectIdx],
+        defaultSceneId: record.id,
+        updatedAt: now
+      };
+    }
+    this.save(data);
+    return record;
+  }
+  async updateScene(projectId, sceneId, updates, expectedVersion) {
+    const data = this.load();
+    this.ensureProject(data, projectId);
+    const idx = data.scenes.findIndex((s) => s.projectId === projectId && s.id === sceneId);
+    if (idx === -1) {
+      throw new NotFoundError(`Scene not found: ${sceneId}`);
+    }
+    const current = data.scenes[idx];
+    if (typeof expectedVersion === "number" && current.version !== expectedVersion) {
+      throw new ConflictError(`Version conflict for scene ${sceneId}`);
+    }
+    const next = {
+      ...current,
+      name: updates.name ?? current.name,
+      meta: updates.meta ?? current.meta,
+      entities: updates.entities ?? current.entities,
+      version: current.version + 1,
+      updatedAt: nowIso()
+    };
+    data.scenes[idx] = next;
+    this.save(data);
+    return next;
+  }
+  async deleteScene(projectId, sceneId) {
+    const data = this.load();
+    this.ensureProject(data, projectId);
+    const before = data.scenes.length;
+    data.scenes = data.scenes.filter((s) => !(s.projectId === projectId && s.id === sceneId));
+    if (data.scenes.length === before) {
+      throw new NotFoundError(`Scene not found: ${sceneId}`);
+    }
+    const projectIdx = data.projects.findIndex((p) => p.id === projectId);
+    if (projectIdx >= 0 && data.projects[projectIdx].defaultSceneId === sceneId) {
+      const replacement = data.scenes.find((s) => s.projectId === projectId)?.id || null;
+      data.projects[projectIdx] = {
+        ...data.projects[projectIdx],
+        defaultSceneId: replacement,
+        updatedAt: nowIso()
+      };
+    }
+    this.save(data);
+  }
+};
+
+// src/cli/services/scenes/store-factory.ts
+function normalizeSceneStorageBackend(value) {
+  return "file";
+}
+function createSceneStoreBundle(backendInput) {
+  normalizeSceneStorageBackend(backendInput);
+  const cwd = process.cwd();
+  const projects = new FileProjectStore(cwd);
+  const scenes = new FileSceneStore(cwd);
+  return { projects, scenes };
+}
+
 // src/cli/server/api.ts
 var api = new Hono();
 var resolveSafePath = (relativePath) => safeResolveFromCwd(relativePath);
+var assetRegistry = createDefaultAssetResolverRegistry();
 function createStoreFromBody(body) {
   return createTasteStore({
     backend: body.storage ? String(body.storage) : void 0,
@@ -1092,7 +1864,16 @@ function createStoreFromBody(body) {
     suggestionsFilePath: body.suggestionsFilePath ? String(body.suggestionsFilePath) : "taste/suggestions.md"
   });
 }
-api.get("/fs/list", async (c) => {
+async function getProjectRoot(projectId) {
+  if (!projectId) return process.cwd();
+  const bundle = createSceneStoreBundle();
+  const project = await bundle.projects.getProject(projectId);
+  if (!project) {
+    throw new NotFoundError(`Project not found: ${projectId}`);
+  }
+  return project.rootPath;
+}
+api.get("/v1/files/list", async (c) => {
   const cwd = process.cwd();
   try {
     const files = await readdir(cwd, { withFileTypes: true });
@@ -1106,36 +1887,23 @@ api.get("/fs/list", async (c) => {
     return c.json({ error: e.message }, 500);
   }
 });
-api.get("/fs/read", async (c) => {
-  const path19 = c.req.query("path");
-  if (!path19) return c.json({ error: "Path required" }, 400);
+api.get("/v1/files/read", async (c) => {
+  const filePath = c.req.query("path");
+  if (!filePath) return c.json({ error: "Path required" }, 400);
   try {
-    const fullPath = resolveSafePath(path19);
+    const fullPath = resolveSafePath(filePath);
     const content = await readFile(fullPath, "utf-8");
-    if (path19.endsWith(".json")) {
-      try {
-        const json = JSON.parse(content);
-        if (json.meta && Array.isArray(json.entities)) {
-          console.debug(`[API] Resolving scene: ${path19}`);
-          const resolved = await SceneResolver.resolve(json, process.cwd());
-          return c.json({ content: JSON.stringify(resolved, null, 2) });
-        }
-      } catch (e) {
-        console.error(`[API] Scene resolution failed for ${path19}:`, e.message);
-      }
-    }
     return c.json({ content });
   } catch (e) {
-    console.error(`[API] Error reading file ${path19}:`, e.message, e.stack);
     return c.json({ error: e.message }, 500);
   }
 });
-api.post("/fs/write", async (c) => {
+api.post("/v1/files/write", async (c) => {
   const body = await c.req.json();
-  const { path: path19, content } = body;
-  if (!path19 || content === void 0) return c.json({ error: "Path and content required" }, 400);
+  const { path: path22, content } = body;
+  if (!path22 || content === void 0) return c.json({ error: "Path and content required" }, 400);
   try {
-    const fullPath = resolveSafePath(path19);
+    const fullPath = resolveSafePath(path22);
     const dir = dirname(fullPath);
     if (!existsSync(dir)) {
       await mkdir(dir, { recursive: true });
@@ -1146,14 +1914,139 @@ api.post("/fs/write", async (c) => {
     return c.json({ error: e.message }, 500);
   }
 });
-api.post("/fs/upload", async (c) => {
+api.post("/v1/projects", async (c) => {
+  try {
+    const body = await c.req.json();
+    const bundle = createSceneStoreBundle(body.storage ? String(body.storage) : void 0);
+    const project = await bundle.projects.createProject({
+      name: body.name ? String(body.name) : "Untitled Project",
+      rootPath: body.rootPath ? String(body.rootPath) : process.cwd(),
+      ownerId: body.ownerId ? String(body.ownerId) : null
+    });
+    const defaultScene = await bundle.scenes.createScene(project.id, {
+      name: body.defaultSceneName ? String(body.defaultSceneName) : "Scene 1"
+    });
+    const updated = await bundle.projects.updateProject(project.id, { defaultSceneId: defaultScene.id });
+    return c.json({ project: updated, defaultScene }, 201);
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.get("/v1/projects", async (c) => {
+  try {
+    const bundle = createSceneStoreBundle();
+    const projects = await bundle.projects.listProjects();
+    return c.json({ projects });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.get("/v1/projects/:projectId", async (c) => {
+  try {
+    const projectId = c.req.param("projectId");
+    const bundle = createSceneStoreBundle();
+    const project = await bundle.projects.getProject(projectId);
+    if (!project) return c.json({ error: "Project not found" }, 404);
+    return c.json({ project });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.get("/v1/projects/:projectId/scenes", async (c) => {
+  try {
+    const projectId = c.req.param("projectId");
+    const bundle = createSceneStoreBundle();
+    const scenes = await bundle.scenes.listScenes(projectId);
+    return c.json({ scenes });
+  } catch (e) {
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/v1/projects/:projectId/scenes", async (c) => {
+  try {
+    const projectId = c.req.param("projectId");
+    const body = await c.req.json();
+    const bundle = createSceneStoreBundle(body.storage ? String(body.storage) : void 0);
+    const scene = await bundle.scenes.createScene(projectId, {
+      name: body.name ? String(body.name) : void 0,
+      orderIndex: body.orderIndex !== void 0 ? Number(body.orderIndex) : void 0,
+      scene: body.scene
+    });
+    return c.json({ scene }, 201);
+  } catch (e) {
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.get("/v1/projects/:projectId/scenes/:sceneId", async (c) => {
+  try {
+    const { projectId, sceneId } = c.req.param();
+    const bundle = createSceneStoreBundle();
+    const scene = await bundle.scenes.getScene(projectId, sceneId);
+    if (!scene) return c.json({ error: "Scene not found" }, 404);
+    const resolved = await SceneResolver.resolve(
+      {
+        meta: scene.meta,
+        entities: scene.entities
+      },
+      (await bundle.projects.getProject(projectId))?.rootPath || process.cwd()
+    );
+    return c.json({
+      scene: {
+        ...scene,
+        meta: resolved.meta,
+        entities: resolved.entities
+      }
+    });
+  } catch (e) {
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.put("/v1/projects/:projectId/scenes/:sceneId", async (c) => {
+  try {
+    const { projectId, sceneId } = c.req.param();
+    const body = await c.req.json();
+    const bundle = createSceneStoreBundle(body.storage ? String(body.storage) : void 0);
+    const scene = await bundle.scenes.updateScene(
+      projectId,
+      sceneId,
+      {
+        name: body.name ? String(body.name) : void 0,
+        meta: body.meta,
+        entities: body.entities
+      },
+      body.version !== void 0 ? Number(body.version) : void 0
+    );
+    return c.json({ scene });
+  } catch (e) {
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    if (e instanceof ConflictError || e?.name === "ConflictError") return c.json({ error: e.message }, 409);
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.delete("/v1/projects/:projectId/scenes/:sceneId", async (c) => {
+  try {
+    const { projectId, sceneId } = c.req.param();
+    const bundle = createSceneStoreBundle();
+    await bundle.scenes.deleteScene(projectId, sceneId);
+    return c.body(null, 204);
+  } catch (e) {
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/v1/assets/upload", async (c) => {
   try {
     const body = await c.req.parseBody();
     const file = body.file;
     if (!file || !(file instanceof File)) {
       return c.json({ error: "File required" }, 400);
     }
-    const assetsDir = join(process.cwd(), "assets");
+    const projectId = body.projectId ? String(body.projectId) : null;
+    const rootPath = await getProjectRoot(projectId);
+    const assetsDir = join(rootPath, "assets");
     if (!existsSync(assetsDir)) {
       await mkdir(assetsDir, { recursive: true });
     }
@@ -1161,57 +2054,58 @@ api.post("/fs/upload", async (c) => {
     const filePath = join(assetsDir, fileName);
     const bytes = Buffer.from(await file.arrayBuffer());
     await writeFile(filePath, bytes);
+    const uri = `assets/${fileName}`;
     return c.json({
       success: true,
-      path: `assets/${fileName}`,
-      url: `/api/fs/assets/assets/${fileName}`
+      uri,
+      url: `/api/v1/assets/content?uri=${encodeURIComponent(uri)}${projectId ? `&projectId=${encodeURIComponent(projectId)}` : ""}`
     });
   } catch (e) {
-    console.error(e);
     return c.json({ error: e.message }, 500);
   }
 });
-api.get("/fs/assets/*", async (c) => {
-  const reqPath = c.req.path;
-  const marker = "/fs/assets/";
-  const index = reqPath.lastIndexOf(marker);
-  const relativePath = reqPath.substring(index + marker.length);
-  if (relativePath.includes("..")) {
-    console.error(`[Asset Server] Blocked directory traversal attempt: ${relativePath}`);
-    return c.json({ error: "Invalid path" }, 403);
-  }
-  let fullPath = "";
+api.get("/v1/assets/content", async (c) => {
   try {
-    fullPath = resolveSafePath(relativePath);
-  } catch {
-    return c.json({ error: "Invalid path" }, 403);
-  }
-  if (!existsSync(fullPath)) {
-    try {
-      fullPath = resolveSafePath(join("assets", relativePath));
-    } catch {
-      return c.json({ error: "Invalid path" }, 403);
+    const uri = c.req.query("uri");
+    const projectId = c.req.query("projectId");
+    if (!uri) return c.json({ error: "uri is required" }, 400);
+    const rootPath = await getProjectRoot(projectId || null);
+    const resolved = assetRegistry.resolve(uri, rootPath);
+    if (resolved.type === "unsupported") {
+      return c.json({ error: resolved.reason }, 400);
+    }
+    if (resolved.type === "remote") {
+      const response = await fetch(resolved.remoteUrl);
+      if (!response.ok) {
+        return c.json({ error: `Failed to fetch remote asset: ${response.status}` }, 502);
+      }
+      const bytes = await response.arrayBuffer();
+      const contentType = response.headers.get("content-type") || "application/octet-stream";
+      return new Response(bytes, {
+        headers: {
+          "Content-Type": contentType,
+          "Cache-Control": "public, max-age=300"
+        }
+      });
     }
-  }
-  if (!existsSync(fullPath)) {
-    console.error(`[Asset Server] File not found: ${fullPath}`);
-    return c.notFound();
-  }
-  const ext = fullPath.split(".").pop()?.toLowerCase();
-  const mimeTypes = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    svg: "image/svg+xml",
-    mp3: "audio/mpeg",
-    mp4: "video/mp4",
-    webm: "video/webm"
-  };
-  const mimeType = mimeTypes[ext || ""] || "application/octet-stream";
-  try {
-    const file = await readFile(fullPath);
+    if (!existsSync(resolved.localPath)) {
+      return c.json({ error: `Asset not found at ${resolved.localPath}` }, 404);
+    }
+    const ext = resolved.localPath.split(".").pop()?.toLowerCase();
+    const mimeTypes = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      wav: "audio/wav"
+    };
+    const mimeType = mimeTypes[ext || ""] || "application/octet-stream";
+    const file = await readFile(resolved.localPath);
     return new Response(file, {
       headers: {
         "Content-Type": mimeType,
@@ -1219,8 +2113,22 @@ api.get("/fs/assets/*", async (c) => {
       }
     });
   } catch (e) {
-    console.error(`[Asset Server] Error serving ${fullPath}:`, e.message);
-    return c.notFound();
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/v1/assets/resolve", async (c) => {
+  try {
+    const body = await c.req.json();
+    const uri = String(body.uri || "").trim();
+    const projectId = body.projectId ? String(body.projectId) : null;
+    if (!uri) return c.json({ error: "uri is required" }, 400);
+    const rootPath = await getProjectRoot(projectId);
+    const resolved = assetRegistry.resolve(uri, rootPath);
+    return c.json({ resolved });
+  } catch (e) {
+    if (e instanceof NotFoundError) return c.json({ error: e.message }, 404);
+    return c.json({ error: e.message }, 500);
   }
 });
 api.post("/taste/chat", async (c) => {
@@ -1229,6 +2137,15 @@ api.post("/taste/chat", async (c) => {
     const message = String(body.message || "").trim();
     const model = body.model ? String(body.model) : void 0;
     const apiKey = body.apiKey || process.env.GEMINI_API_KEY;
+    const chatHistory = Array.isArray(body.chatHistory) ? body.chatHistory.map((entry) => ({
+      role: entry.role === "assistant" ? "assistant" : "user",
+      text: String(entry.text || "")
+    })) : void 0;
+    const askUserCount = body.askUserCount ? Number(body.askUserCount) : void 0;
+    const askUserMax = body.askUserMax ? Number(body.askUserMax) : void 0;
+    const interactionCount = body.interactionCount ? Number(body.interactionCount) : void 0;
+    const interactionMin = body.interactionMin ? Number(body.interactionMin) : void 0;
+    const interactionMax = body.interactionMax ? Number(body.interactionMax) : void 0;
     if (!message) return c.json({ error: "message is required" }, 400);
     if (!apiKey) return c.json({ error: "Missing GEMINI_API_KEY" }, 400);
     const store = createStoreFromBody(body);
@@ -1240,13 +2157,47 @@ api.post("/taste/chat", async (c) => {
       tasteContent: body.tasteContent ? String(body.tasteContent) : taste.content,
       memories,
       apiKey: String(apiKey),
-      model
+      model,
+      chatHistory,
+      askUserCount,
+      askUserMax,
+      interactionCount,
+      interactionMin,
+      interactionMax
     });
     return c.json(result);
   } catch (e) {
     return c.json({ error: e.message }, 500);
   }
 });
+api.post("/taste/askuser/imagine", async (c) => {
+  try {
+    const body = await c.req.json();
+    const options = Array.isArray(body.options) ? body.options : [];
+    if (options.length === 0) return c.json({ error: "options array is required" }, 400);
+    const results = [];
+    const now = Date.now();
+    for (let i = 0; i < options.length; i++) {
+      const entry = options[i] || {};
+      const optionId = String(entry.optionId || "").trim();
+      const prompt = String(entry.prompt || "").trim();
+      const aspectRatio = String(entry.aspectRatio || "9:16");
+      if (!optionId || !prompt) continue;
+      const safeId = optionId.replace(/[^a-zA-Z0-9_-]/g, "-");
+      const fileName = `askuser/${now}_${safeId}.png`;
+      const args = ["imagine", prompt, "--aspect-ratio", aspectRatio, "-o", fileName, "--json"];
+      const output = await runCliCommand(args, process.cwd());
+      const files = Array.isArray(output.files) ? output.files : [];
+      const first = files[0] ? String(files[0]) : "";
+      if (!first) continue;
+      const uri = relative(process.cwd(), first).replace(/\\/g, "/");
+      results.push({ optionId, uri, url: toBrowserAssetUrl(uri) });
+    }
+    return c.json({ results });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
 api.post("/taste/simulate", async (c) => {
   try {
     const body = await c.req.json();
@@ -1268,14 +2219,53 @@ api.post("/taste/simulate", async (c) => {
       apiKey: String(apiKey),
       model
     });
-    let appendedIds = [];
+    const planResult = await simulatePlanCards({
+      tasteContent: body.tasteContent ? String(body.tasteContent) : taste.content,
+      memories,
+      count,
+      mode,
+      apiKey: String(apiKey),
+      model
+    });
+    const appendedIds = [];
     if (saveToMemory && result.ideas.length > 0) {
       for (const idea of result.ideas) {
         const saved = await store.appendMemory({ ...idea, status: "generated" });
         appendedIds.push(saved.id);
       }
     }
-    return c.json({ ...result, appendedIds });
+    return c.json({ ...result, planCards: planResult.planCards || [], appendedIds });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/taste/simulate/followup", async (c) => {
+  try {
+    const body = await c.req.json();
+    const cardTitle = String(body.cardTitle || "").trim();
+    const bulletText = String(body.bulletText || "").trim();
+    const bulletId = String(body.bulletId || "").trim() || `bullet_${Date.now()}`;
+    const model = body.model ? String(body.model) : void 0;
+    const apiKey = body.apiKey || process.env.GEMINI_API_KEY;
+    const count = Math.max(3, Math.min(6, Number(body.count || 4)));
+    if (!cardTitle) return c.json({ error: "cardTitle is required" }, 400);
+    if (!bulletText) return c.json({ error: "bulletText is required" }, 400);
+    if (!apiKey) return c.json({ error: "Missing GEMINI_API_KEY" }, 400);
+    const store = createStoreFromBody(body);
+    await store.ensureWorkspace();
+    const taste = await store.readTaste();
+    const memories = body.memoryContent ? parseTasteMemoryMarkdown(String(body.memoryContent)).slice(0, 40) : await store.queryMemory({ limit: 40 });
+    const result = await generateBulletFollowupPrompts({
+      tasteContent: body.tasteContent ? String(body.tasteContent) : taste.content,
+      memories,
+      cardTitle,
+      bulletText,
+      bulletId,
+      apiKey: String(apiKey),
+      model,
+      count
+    });
+    return c.json(result);
   } catch (e) {
     return c.json({ error: e.message }, 500);
   }
@@ -1410,21 +2400,20 @@ api.post("/cli/run", async (c) => {
     const result = await runCliCommand(args, cwd);
     return c.json(result);
   } catch (e) {
-    console.error("[API] /cli/run error:", e.message);
     return c.json({ error: e.message }, 500);
   }
 });
 var api_default = api;
 
 // src/cli/server/index.ts
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import fs4 from "fs";
+import fs6 from "fs";
 var app = new Hono2();
 app.use("/*", cors());
 app.route("/api", api_default);
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path5.dirname(__filename2);
+var __dirname2 = path6.dirname(__filename2);
 var createServer = (staticRoot) => {
   const app2 = new Hono2();
   app2.use("/*", cors());
@@ -1455,10 +2444,10 @@ var createServer = (staticRoot) => {
   };
   app2.get("/*", async (c) => {
     const requestPath = c.req.path === "/" ? "/index.html" : c.req.path;
-    const filePath = path5.join(staticRoot, requestPath);
+    const filePath = path6.join(staticRoot, requestPath);
     try {
-      if (fs4.existsSync(filePath)) {
-        const file = await fs4.promises.readFile(filePath);
+      if (fs6.existsSync(filePath)) {
+        const file = await fs6.promises.readFile(filePath);
         const mimeType = getMimeType(filePath);
         return new Response(file, {
           headers: {
@@ -1470,9 +2459,9 @@ var createServer = (staticRoot) => {
     }
     if (!requestPath.includes(".")) {
       try {
-        const indexPath = path5.join(staticRoot, "index.html");
-        if (fs4.existsSync(indexPath)) {
-          const indexFile = await fs4.promises.readFile(indexPath);
+        const indexPath = path6.join(staticRoot, "index.html");
+        if (fs6.existsSync(indexPath)) {
+          const indexFile = await fs6.promises.readFile(indexPath);
           return new Response(indexFile, {
             headers: {
               "Content-Type": "text/html"
@@ -1499,9 +2488,150 @@ function startServer(app2, port) {
   };
 }
 
+// src/cli/services/scenes/api-client.ts
+function normalizeApiBaseUrl(input) {
+  const base = (input || process.env.FEEDEAS_API_URL || "http://localhost:3331").replace(/\/$/, "");
+  if (base.endsWith("/api/v1")) return base;
+  if (base.endsWith("/api")) return `${base}/v1`;
+  return `${base}/api/v1`;
+}
+async function readJson(res) {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(data.error || `API request failed (${res.status})`);
+  }
+  return data;
+}
+var SceneApiClient = class {
+  baseUrl;
+  constructor(apiBaseUrl) {
+    this.baseUrl = normalizeApiBaseUrl(apiBaseUrl);
+  }
+  async createProject(input) {
+    const res = await fetch(`${this.baseUrl}/projects`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+    return readJson(res);
+  }
+  async listProjects() {
+    const res = await fetch(`${this.baseUrl}/projects`);
+    const data = await readJson(res);
+    return data.projects || [];
+  }
+  async getProject(projectId) {
+    const res = await fetch(`${this.baseUrl}/projects/${encodeURIComponent(projectId)}`);
+    if (res.status === 404) return null;
+    const data = await readJson(res);
+    return data.project || null;
+  }
+  async listScenes(projectId) {
+    const res = await fetch(`${this.baseUrl}/projects/${encodeURIComponent(projectId)}/scenes`);
+    const data = await readJson(res);
+    return data.scenes || [];
+  }
+  async createScene(projectId, input) {
+    const res = await fetch(`${this.baseUrl}/projects/${encodeURIComponent(projectId)}/scenes`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+    const data = await readJson(res);
+    return data.scene;
+  }
+  async getScene(projectId, sceneId) {
+    const res = await fetch(`${this.baseUrl}/projects/${encodeURIComponent(projectId)}/scenes/${encodeURIComponent(sceneId)}`);
+    if (res.status === 404) return null;
+    const data = await readJson(res);
+    return data.scene || null;
+  }
+  async updateScene(projectId, sceneId, input) {
+    const res = await fetch(`${this.baseUrl}/projects/${encodeURIComponent(projectId)}/scenes/${encodeURIComponent(sceneId)}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+    const data = await readJson(res);
+    return data.scene;
+  }
+  async deleteScene(projectId, sceneId) {
+    const res = await fetch(`${this.baseUrl}/projects/${encodeURIComponent(projectId)}/scenes/${encodeURIComponent(sceneId)}`, {
+      method: "DELETE"
+    });
+    if (!res.ok && res.status !== 204) {
+      const data = await res.json().catch(() => ({}));
+      throw new Error(data.error || `Delete scene failed (${res.status})`);
+    }
+  }
+  async resolveAsset(uri, projectId) {
+    const res = await fetch(`${this.baseUrl}/assets/resolve`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ uri, projectId })
+    });
+    const data = await readJson(res);
+    return data.resolved;
+  }
+  assetContentUrl(uri, projectId) {
+    const q = new URLSearchParams({ uri });
+    if (projectId) q.set("projectId", projectId);
+    return `${this.baseUrl}/assets/content?${q.toString()}`;
+  }
+};
+
+// src/cli/services/scenes/flow-state.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+function sessionPath(cwd) {
+  return path7.resolve(cwd, ".feedeas/session.json");
+}
+function ensureDir(filePath) {
+  const dir = path7.dirname(filePath);
+  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+}
+function readFlowState(cwd = process.cwd()) {
+  const file = sessionPath(cwd);
+  if (!fs7.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs7.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeFlowState(updates, cwd = process.cwd()) {
+  const existing = readFlowState(cwd) || { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const next = {
+    ...existing,
+    ...updates,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const file = sessionPath(cwd);
+  ensureDir(file);
+  fs7.writeFileSync(file, JSON.stringify(next, null, 2), "utf-8");
+  return next;
+}
+function resolveProjectId(explicit) {
+  if (explicit) return explicit;
+  const state = readFlowState();
+  if (state?.projectId) return state.projectId;
+  throw new Error("Missing project ID. Pass --project-id or set flow state by running project create / scene use.");
+}
+function resolveSceneId(explicit) {
+  if (explicit) return explicit;
+  const state = readFlowState();
+  if (state?.sceneId) return state.sceneId;
+  throw new Error("Missing scene ID. Pass --scene-id or set flow state by running scene create/import/use.");
+}
+function resolveApiUrl(explicit) {
+  if (explicit) return explicit;
+  const state = readFlowState();
+  return state?.apiUrl;
+}
+
 // src/cli/commands/record.ts
 var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path6.dirname(__filename3);
+var __dirname3 = path8.dirname(__filename3);
 function formatBytes(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -1510,21 +2640,21 @@ function formatBytes(bytes) {
   return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
 }
 function getMissingUiAssets(staticRoot) {
-  const indexPath = path6.join(staticRoot, "index.html");
-  if (!fs5.existsSync(indexPath)) {
+  const indexPath = path8.join(staticRoot, "index.html");
+  if (!fs8.existsSync(indexPath)) {
     return {
       missingFiles: [indexPath],
       expectedUrls: []
     };
   }
-  const indexHtml = fs5.readFileSync(indexPath, "utf-8");
+  const indexHtml = fs8.readFileSync(indexPath, "utf-8");
   const assetMatches = Array.from(indexHtml.matchAll(/(?:src|href)=["'](\/assets\/[^"']+)["']/g));
   const assetPaths = [...new Set(assetMatches.map((match) => match[1]))];
   const missingFiles = [];
   const expectedUrls = [];
   for (const assetPath of assetPaths) {
-    const localPath = path6.join(staticRoot, assetPath.replace(/^\//, ""));
-    if (!fs5.existsSync(localPath)) {
+    const localPath = path8.join(staticRoot, assetPath.replace(/^\//, ""));
+    if (!fs8.existsSync(localPath)) {
       missingFiles.push(localPath);
       expectedUrls.push(assetPath);
     }
@@ -1612,21 +2742,28 @@ async function ensurePlaywrightReadyOrExit() {
     process.exit(1);
   }
 }
-var recordCommand = new Command("record").description("Record the project to a video file with audio").option("-o, --output <path>", "Output file path", "output.mp4").option("-u, --url <url>", "URL of the running server", "http://localhost:3331").option("-w, --width <number>", "Viewport width", "1920").option("-h, --height <number>", "Viewport height", "1080").option("-f, --fps <number>", "Frames per second", "30").option("--project <path>", "Path to project file", "scene_1.json").option("--dry-run", "Validate scene and show estimates without rendering").option("--debug", "Enable verbose logging (FFmpeg, browser console)").action(async (options) => {
-  const { output, url, width, height, fps, project: projectOption, debug, dryRun } = options;
-  const projectPath = path6.resolve(process.cwd(), projectOption);
-  if (!fs5.existsSync(projectPath)) {
-    console.error(`Project file not found at ${projectPath}`);
+var recordCommand = new Command("record").description("Record the project to a video file with audio").option("-o, --output <path>", "Output file path", "output.mp4").option("-u, --url <url>", "URL of the running server", "http://localhost:3331").option("-w, --width <number>", "Viewport width", "1920").option("-h, --height <number>", "Viewport height", "1080").option("-f, --fps <number>", "Frames per second", "30").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").option("--api-url <url>", "API base URL for scene/project metadata").option("--dry-run", "Validate scene and show estimates without rendering").option("--debug", "Enable verbose logging (FFmpeg, browser console)").action(async (options) => {
+  const { output, url, width, height, fps, debug, dryRun } = options;
+  const projectId = resolveProjectId(options.projectId);
+  const sceneId = resolveSceneId(options.sceneId);
+  const apiUrl = resolveApiUrl(options.apiUrl);
+  const apiClient = apiUrl ? new SceneApiClient(apiUrl) : null;
+  const localBundle = createSceneStoreBundle("file");
+  const assetRegistry2 = createDefaultAssetResolverRegistry();
+  const projectRecord = apiClient ? await apiClient.getProject(projectId) : await localBundle.projects.getProject(projectId);
+  if (!projectRecord) {
+    console.error(`Project not found: ${projectId}`);
     process.exit(1);
   }
-  const projectDir = path6.dirname(projectPath);
-  process.chdir(projectDir);
-  console.log(`Working in project directory: ${projectDir}`);
   let project;
   try {
-    const rawProject = JSON.parse(fs5.readFileSync(projectPath, "utf-8"));
-    const resolvedCwd = process.cwd();
-    project = await SceneResolver.resolve(rawProject, resolvedCwd);
+    const sceneRecord = apiClient ? await apiClient.getScene(projectId, sceneId) : await localBundle.scenes.getScene(projectId, sceneId);
+    if (!sceneRecord) {
+      console.error(`Scene not found: ${sceneId}`);
+      process.exit(1);
+    }
+    const rawProject = { meta: sceneRecord.meta, entities: sceneRecord.entities };
+    project = await SceneResolver.resolve(rawProject, projectRecord.rootPath || process.cwd());
   } catch (e) {
     console.error(`Error loading project: ${e.message}`);
     process.exit(1);
@@ -1639,18 +2776,24 @@ var recordCommand = new Command("record").description("Record the project to a v
   const imageEntities = state.entities.filter((e) => e.type === "image" && e.src);
   const allAssets = [...audioEntities, ...imageEntities];
   const missingAssets = [];
-  allAssets.forEach((entity) => {
-    if (!entity.src) return;
-    let assetPath = "";
-    if (entity.src.startsWith("/")) {
-      assetPath = entity.src;
+  for (const entity of allAssets) {
+    if (!entity.src) continue;
+    if (apiClient) {
+      try {
+        const resolved = await apiClient.resolveAsset(entity.src, projectId);
+        if (resolved.type === "unsupported") {
+          missingAssets.push(entity.src);
+        }
+      } catch {
+        missingAssets.push(entity.src);
+      }
     } else {
-      assetPath = path6.resolve(process.cwd(), entity.src);
-    }
-    if (!fs5.existsSync(assetPath)) {
-      missingAssets.push(entity.src);
+      const validity = assetRegistry2.assertUsable(entity.src, projectRecord.rootPath || process.cwd());
+      if (!validity.ok) {
+        missingAssets.push(entity.src);
+      }
     }
-  });
+  }
   if (missingAssets.length > 0) {
     console.error("\nMissing assets:");
     missingAssets.forEach((asset) => console.error(`  \u2717 ${asset}`));
@@ -1658,7 +2801,7 @@ var recordCommand = new Command("record").description("Record the project to a v
   }
   if (dryRun) {
     console.log("\n=== Validation Results ===");
-    console.log(`\u2713 Scene: ${projectOption}`);
+    console.log(`\u2713 Scene: ${sceneId}`);
     console.log(`\u2713 Duration: ${duration}s @${state.meta.width}\xD7${state.meta.height}`);
     const counts = {};
     state.entities.forEach((e) => {
@@ -1671,12 +2814,21 @@ var recordCommand = new Command("record").description("Record the project to a v
 Assets(${allAssets.length}):`);
       allAssets.forEach((entity) => {
         if (!entity.src) return;
-        let assetPath = path6.resolve(process.cwd(), "assets", entity.src);
-        if (!fs5.existsSync(assetPath)) assetPath = path6.resolve(process.cwd(), entity.src);
-        if (fs5.existsSync(assetPath)) {
-          const stats = fs5.statSync(assetPath);
-          const sizeStr = formatBytes(stats.size);
-          console.log(`  \u2713 ${entity.src} (${sizeStr})`);
+        const src = entity.src;
+        if (apiClient) {
+          const looksRemote = src.startsWith("http://") || src.startsWith("https://") || src.startsWith("data:");
+          console.log(`  \u2713 ${src} (${looksRemote ? "remote" : "resolved via API"})`);
+        } else {
+          const resolved = assetRegistry2.resolve(src, projectRecord.rootPath || process.cwd());
+          if (resolved.type === "local" && fs8.existsSync(resolved.localPath)) {
+            const stats = fs8.statSync(resolved.localPath);
+            const sizeStr = formatBytes(stats.size);
+            console.log(`  \u2713 ${src} (${sizeStr})`);
+          } else if (resolved.type === "remote") {
+            console.log(`  \u2713 ${src} (remote)`);
+          } else {
+            console.log(`  \u2713 ${src}`);
+          }
         }
       });
     }
@@ -1702,17 +2854,18 @@ Warnings:`);
 Estimate: ${totalFrames} frames, ~${estimatedMinutes}m ${remainingSeconds}s @${estimatedFps} fps`);
     console.log(`
 Ready to record. Run without --dry-run to start rendering.`);
+    writeFlowState({ projectId, sceneId, apiUrl });
     process.exit(0);
   }
   console.log("Running runtime preflight checks...");
   ensureFfmpegAvailableOrExit();
   await ensurePlaywrightReadyOrExit();
   console.log("Starting temporary server...");
-  let staticRoot = path6.resolve(__dirname3, "../../dist/ui");
-  if (!fs5.existsSync(staticRoot)) {
-    staticRoot = path6.resolve(__dirname3, "../ui");
+  let staticRoot = path8.resolve(__dirname3, "../../dist/ui");
+  if (!fs8.existsSync(staticRoot)) {
+    staticRoot = path8.resolve(__dirname3, "../ui");
   }
-  if (!fs5.existsSync(staticRoot)) {
+  if (!fs8.existsSync(staticRoot)) {
     console.error(`Error: UI assets not found at ${staticRoot}. Please run 'bun run build' first.`);
     process.exit(1);
   }
@@ -1761,27 +2914,31 @@ Ready to record. Run without --dry-run to start rendering.`);
     const widthNum = parseInt(width);
     const heightNum = parseInt(height);
     console.log("Starting recording...");
-    console.log(`Project: ${projectOption}`);
+    console.log(`Project: ${projectId}`);
+    console.log(`Scene: ${sceneId}`);
     console.log(`Duration: ${duration}s, Frames: ${totalFrames}`);
     const validAudio = audioEntities.filter((e) => {
       if (!e.src) return false;
-      let assetPath = "";
-      if (e.src.startsWith("/")) {
-        if (e.src.startsWith("/api/fs/assets/")) {
-          assetPath = path6.resolve(process.cwd(), "assets", e.src.replace("/api/fs/assets/", ""));
-        } else {
-          assetPath = e.src;
-        }
-      } else {
-        assetPath = path6.resolve(process.cwd(), e.src);
+      const src = e.src;
+      if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("data:")) {
+        e.src = src;
+        return true;
       }
-      if (fs5.existsSync(assetPath)) {
-        e.src = assetPath;
+      if (apiClient) {
+        e.src = apiClient.assetContentUrl(src, projectId);
+        return true;
+      }
+      const resolved = assetRegistry2.resolve(src, projectRecord.rootPath || process.cwd());
+      if (resolved.type === "local" && fs8.existsSync(resolved.localPath)) {
+        e.src = resolved.localPath;
         return true;
-      } else {
-        console.warn(`Asset not found: ${assetPath} (orig: ${e.src})`);
-        return false;
       }
+      if (resolved.type === "remote") {
+        e.src = resolved.remoteUrl;
+        return true;
+      }
+      console.warn(`Asset not found or unsupported: ${e.src}`);
+      return false;
     });
     const ffmpegArgs = [
       "-y",
@@ -1885,8 +3042,7 @@ Ready to record. Run without --dry-run to start rendering.`);
     try {
       for (let i = 0; i < totalFrames; i++) {
         const time = i / fpsNum;
-        const projectRelativePath = path6.relative(process.cwd(), projectPath);
-        const targetUrl = `${url}?mode=render&time=${time}&project=${encodeURIComponent(projectRelativePath)}`;
+        const targetUrl = `${url}?mode=render&time=${time}&projectId=${encodeURIComponent(projectId)}&sceneId=${encodeURIComponent(sceneId)}`;
         await page.goto(targetUrl, { waitUntil: "load" });
         await page.waitForSelector('canvas[data-ready="true"]', { timeout: 3e4 });
         const buffer = await page.locator("canvas").screenshot({ type: "png" });
@@ -1919,16 +3075,17 @@ Ready to record. Run without --dry-run to start rendering.`);
     console.log("Stopping temporary server...");
     server.stop();
   }
+  writeFlowState({ projectId, sceneId, apiUrl });
 });
 
 // src/cli/commands/inspect.ts
 import { Command as Command2 } from "commander";
-import fs6 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path9 from "path";
 var inspectCommand = new Command2("inspect");
 inspectCommand.description("Inspect an asset file to get metadata (duration, format, etc.)").argument("<file>", "Path to the asset file").option("--json", "Output in JSON format").action(async (file, options) => {
-  const filePath = path7.resolve(process.cwd(), file);
-  if (!fs6.existsSync(filePath)) {
+  const filePath = path9.resolve(process.cwd(), file);
+  if (!fs9.existsSync(filePath)) {
     console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
@@ -1957,23 +3114,33 @@ inspectCommand.description("Inspect an asset file to get metadata (duration, for
 
 // src/cli/commands/validate.ts
 import { Command as Command3 } from "commander";
-import fs7 from "fs";
-import path8 from "path";
+import fs10 from "fs";
 var validateCommand = new Command3("validate");
 function resolveRuntimeFit(fit, imageRatio, canvasRatio) {
   if (fit === "cover" || fit === "contain") return fit;
   const ratioDelta = Math.abs(imageRatio / canvasRatio - 1);
   return ratioDelta > 0.2 ? "contain" : "cover";
 }
-validateCommand.description("Validate a scene file").argument("<file>", "Path to the scene file").action(async (file) => {
-  const filePath = path8.resolve(process.cwd(), file);
-  if (!fs7.existsSync(filePath)) {
-    console.error(`File not found: ${filePath}`);
-    process.exit(1);
-  }
+validateCommand.description("Validate a scene by project and scene ID").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
   try {
-    const rawScene = JSON.parse(fs7.readFileSync(filePath, "utf-8"));
-    const data = await SceneResolver.resolve(rawScene, process.cwd());
+    const projectId = resolveProjectId(options.projectId);
+    const sceneId = resolveSceneId(options.sceneId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const apiClient = apiUrl ? new SceneApiClient(apiUrl) : null;
+    const bundle = createSceneStoreBundle("file");
+    const project = apiClient ? await apiClient.getProject(projectId) : await bundle.projects.getProject(projectId);
+    if (!project) {
+      console.error(JSON.stringify({ valid: false, errors: [`Project not found: ${projectId}`] }, null, 2));
+      process.exit(1);
+    }
+    const sceneRecord = apiClient ? await apiClient.getScene(projectId, sceneId) : await bundle.scenes.getScene(projectId, sceneId);
+    if (!sceneRecord) {
+      console.error(JSON.stringify({ valid: false, errors: [`Scene not found: ${sceneId}`] }, null, 2));
+      process.exit(1);
+    }
+    const registry = createDefaultAssetResolverRegistry();
+    const rawScene = { meta: sceneRecord.meta, entities: sceneRecord.entities };
+    const data = await SceneResolver.resolve(rawScene, project.rootPath || process.cwd());
     const errors = [];
     const warnings = [];
     if (!data.meta) {
@@ -2009,36 +3176,32 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
             if (typeof entity.src !== "string") {
               errors.push(`${prefix} "src" must be a string`);
             } else {
-              let fullPath = "";
-              if (entity.src.startsWith("/api/fs/assets/")) {
-                const stripped = entity.src.replace("/api/fs/assets/", "");
-                fullPath = path8.resolve(process.cwd(), stripped);
-              } else if (entity.src.startsWith("/")) {
-                fullPath = entity.src;
-              } else {
-                fullPath = path8.resolve(process.cwd(), entity.src);
-              }
-              if (!fs7.existsSync(fullPath)) {
-                errors.push(`${prefix} asset not found at ${fullPath} (derived from src: "${entity.src}")`);
-              } else {
-                try {
-                  const metadata = await FFprobeService.getMetadata(fullPath);
-                  if (metadata.width && metadata.height && data.meta?.width && data.meta?.height) {
-                    const imageRatio = metadata.width / metadata.height;
-                    const canvasRatio = data.meta.width / data.meta.height;
-                    const fit = resolveRuntimeFit(entity.fit, imageRatio, canvasRatio);
-                    if (fit === "cover") {
-                      const visibleFraction = Math.min(canvasRatio / imageRatio, imageRatio / canvasRatio);
-                      const cropPct = (1 - visibleFraction) * 100;
-                      if (cropPct > 15) {
-                        warnings.push(
-                          `${prefix} may crop ~${cropPct.toFixed(1)}% of image area at render time (image ${metadata.width}x${metadata.height}, canvas ${data.meta.width}x${data.meta.height}). Consider "fit": "contain" or generate matching aspect ratio.`
-                        );
+              const resolved = registry.resolve(entity.src, project.rootPath || process.cwd());
+              if (resolved.type === "unsupported") {
+                errors.push(`${prefix} unsupported asset URI: ${entity.src} (${resolved.reason})`);
+              } else if (resolved.type === "local") {
+                if (!fs10.existsSync(resolved.localPath)) {
+                  errors.push(`${prefix} asset not found at ${resolved.localPath} (src: "${entity.src}")`);
+                } else {
+                  try {
+                    const metadata = await FFprobeService.getMetadata(resolved.localPath);
+                    if (metadata.width && metadata.height && data.meta?.width && data.meta?.height) {
+                      const imageRatio = metadata.width / metadata.height;
+                      const canvasRatio = data.meta.width / data.meta.height;
+                      const fit = resolveRuntimeFit(entity.fit, imageRatio, canvasRatio);
+                      if (fit === "cover") {
+                        const visibleFraction = Math.min(canvasRatio / imageRatio, imageRatio / canvasRatio);
+                        const cropPct = (1 - visibleFraction) * 100;
+                        if (cropPct > 15) {
+                          warnings.push(
+                            `${prefix} may crop ~${cropPct.toFixed(1)}% of image area at render time (image ${metadata.width}x${metadata.height}, canvas ${data.meta.width}x${data.meta.height}). Consider "fit": "contain" or generate matching aspect ratio.`
+                          );
+                        }
                       }
                     }
+                  } catch (metaError) {
+                    warnings.push(`${prefix} could not inspect image dimensions: ${metaError.message}`);
                   }
-                } catch (metaError) {
-                  warnings.push(`${prefix} could not inspect image dimensions: ${metaError.message}`);
                 }
               }
             }
@@ -2049,17 +3212,11 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
           } else if (typeof entity.src !== "string") {
             errors.push(`${prefix} "src" must be a string`);
           } else {
-            let fullPath = "";
-            if (entity.src.startsWith("/api/fs/assets/")) {
-              const stripped = entity.src.replace("/api/fs/assets/", "");
-              fullPath = path8.resolve(process.cwd(), stripped);
-            } else if (entity.src.startsWith("/")) {
-              fullPath = entity.src;
-            } else {
-              fullPath = path8.resolve(process.cwd(), entity.src);
-            }
-            if (!fs7.existsSync(fullPath)) {
-              errors.push(`${prefix} asset not found at ${fullPath} (derived from src: "${entity.src}")`);
+            const resolved = registry.resolve(entity.src, project.rootPath || process.cwd());
+            if (resolved.type === "unsupported") {
+              errors.push(`${prefix} unsupported asset URI: ${entity.src} (${resolved.reason})`);
+            } else if (resolved.type === "local" && !fs10.existsSync(resolved.localPath)) {
+              errors.push(`${prefix} asset not found at ${resolved.localPath} (src: "${entity.src}")`);
             }
           }
           if (entity.sourceStart !== void 0 && typeof entity.sourceStart !== "number") {
@@ -2079,9 +3236,9 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
     if (errors.length > 0) {
       console.log(JSON.stringify({ valid: false, errors, warnings }, null, 2));
       process.exit(1);
-    } else {
-      console.log(JSON.stringify({ valid: true, warnings }, null, 2));
     }
+    writeFlowState({ projectId, sceneId, apiUrl });
+    console.log(JSON.stringify({ valid: true, warnings }, null, 2));
   } catch (e) {
     console.error(JSON.stringify({ valid: false, errors: ["Error validating scene: " + e.message] }, null, 2));
     process.exit(1);
@@ -2090,43 +3247,87 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
 
 // src/cli/commands/set-scene.ts
 import { Command as Command4 } from "commander";
-import fs8 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 var setSceneCommand = new Command4("set-scene");
-setSceneCommand.description("Update or create a scene file with new content").argument("<file>", "Path to the scene file to update").option("-c, --content <json>", "JSON content string").option("-i, --input <file>", "Input JSON file to copy from").action(async (file, options) => {
-  const targetPath = path9.resolve(process.cwd(), file);
+setSceneCommand.description("Update an existing scene by project/scene ID").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").option("-c, --content <json>", "JSON content string").option("-i, --input <file>", "Input JSON file to copy from").option("--version <number>", "Expected scene version").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
   let contentStr = "";
   if (options.content) {
     contentStr = options.content;
   } else if (options.input) {
-    const inputPath = path9.resolve(process.cwd(), options.input);
-    if (!fs8.existsSync(inputPath)) {
+    const inputPath = path10.resolve(process.cwd(), options.input);
+    if (!fs11.existsSync(inputPath)) {
       console.error(`Input file not found: ${inputPath}`);
       process.exit(1);
     }
-    contentStr = fs8.readFileSync(inputPath, "utf-8");
+    contentStr = fs11.readFileSync(inputPath, "utf-8");
   } else {
     console.error("Error: Please provide --content <json> or --input <file>");
     process.exit(1);
   }
   try {
     const data = JSON.parse(contentStr);
-    if (!data.meta || !data.entities) {
+    if (!data.meta || !Array.isArray(data.entities)) {
       console.error('Error: Invalid scene format. Missing "meta" or "entities".');
       process.exit(1);
     }
-    fs8.writeFileSync(targetPath, JSON.stringify(data, null, 2));
-    console.log(`Scene updated at ${targetPath}`);
+    const projectId = resolveProjectId(options.projectId);
+    const sceneId = resolveSceneId(options.sceneId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const scene = apiUrl ? await new SceneApiClient(apiUrl).updateScene(
+      projectId,
+      sceneId,
+      {
+        meta: data.meta,
+        entities: data.entities,
+        version: options.version !== void 0 ? Number(options.version) : void 0
+      }
+    ) : await createSceneStoreBundle("file").scenes.updateScene(
+      projectId,
+      sceneId,
+      {
+        meta: data.meta,
+        entities: data.entities
+      },
+      options.version !== void 0 ? Number(options.version) : void 0
+    );
+    writeFlowState({ projectId, sceneId, apiUrl });
+    console.log(`Scene updated: project=${scene.projectId} scene=${scene.id} version=${scene.version}`);
   } catch (e) {
-    console.error("Error: Content is not valid JSON.", e.message);
+    console.error("Error: Content is not valid JSON or update failed.", e.message);
     process.exit(1);
   }
 });
 
 // src/cli/commands/imagine.ts
 import { Command as Command5 } from "commander";
-import fs9 from "fs";
-import path10 from "path";
+import fs13 from "fs";
+import path12 from "path";
+
+// src/cli/utils/path.ts
+import path11 from "path";
+import fs12 from "fs";
+function resolveAssetOutputPath(outputOption, cwd = process.cwd()) {
+  if (path11.isAbsolute(outputOption)) {
+    return outputOption;
+  }
+  const assetsDir = path11.resolve(cwd, "assets");
+  if (!fs12.existsSync(assetsDir)) {
+    fs12.mkdirSync(assetsDir, { recursive: true });
+  }
+  const normalizedInput = path11.normalize(outputOption);
+  let cleanRelativePath = normalizedInput;
+  const segments = normalizedInput.split(path11.sep);
+  if (segments[0] === "assets") {
+    cleanRelativePath = segments.slice(1).join(path11.sep);
+  }
+  if (!cleanRelativePath) {
+    cleanRelativePath = `unnamed-asset-${Date.now()}`;
+  }
+  return path11.join(assetsDir, cleanRelativePath);
+}
+
+// src/cli/commands/imagine.ts
 var imagineCommand = new Command5("imagine");
 imagineCommand.description("Generate images using Google Gemini AI (Imagen)").argument("<prompt-or-file>", "Text prompt or path to a file containing the prompt").option("-o, --output <filename>", "Output filename (relative to assets/ or absolute path)", "generated.png").option("-k, --api-key <key>", "Gemini API key (or set GEMINI_API_KEY env var)").option("-n, --number <count>", "Number of images to generate", "1").option("--aspect-ratio <ratio>", "Aspect ratio (e.g., 9:16, 1:1, 16:9, or auto)", "auto").option("--image-size <size>", "Image size hint: 1K, 2K, or 4K", "2K").option("--project <path>", "Scene file path to infer aspect ratio from (reads meta.width/meta.height)", "scene_1.json").option("--json", "Emit machine-readable JSON output").addHelpText("after", `
 
@@ -2176,9 +3377,9 @@ Note:
 `).action(async (promptOrFile, options) => {
   try {
     let prompt;
-    if (fs9.existsSync(promptOrFile)) {
+    if (fs13.existsSync(promptOrFile)) {
       console.log(`Reading prompt from file: ${promptOrFile}`);
-      prompt = fs9.readFileSync(promptOrFile, "utf-8").trim();
+      prompt = fs13.readFileSync(promptOrFile, "utf-8").trim();
     } else {
       prompt = promptOrFile;
     }
@@ -2219,27 +3420,17 @@ Note:
       aspectRatio,
       imageSize
     });
-    let outputPath;
-    if (path10.isAbsolute(options.output)) {
-      outputPath = options.output;
-    } else {
-      const assetsDir = path10.resolve(process.cwd(), "assets");
-      if (!fs9.existsSync(assetsDir)) {
-        console.log(`\u{1F4C1} Creating assets directory: ${assetsDir}`);
-        fs9.mkdirSync(assetsDir, { recursive: true });
-      }
-      outputPath = path10.join(assetsDir, options.output);
-    }
-    const outputDir = path10.dirname(outputPath);
-    const outputExt = path10.extname(outputPath) || ".png";
-    const outputBase = path10.basename(outputPath, outputExt);
-    if (!fs9.existsSync(outputDir)) {
-      fs9.mkdirSync(outputDir, { recursive: true });
+    const outputPath = resolveAssetOutputPath(options.output);
+    const outputDir = path12.dirname(outputPath);
+    const outputExt = path12.extname(outputPath) || ".png";
+    const outputBase = path12.basename(outputPath, outputExt);
+    if (!fs13.existsSync(outputDir)) {
+      fs13.mkdirSync(outputDir, { recursive: true });
     }
     const savedFiles = [];
     for (let i = 0; i < images.length; i++) {
-      const filename = images.length > 1 ? path10.join(outputDir, `${outputBase}_${i + 1}${outputExt}`) : outputPath;
-      fs9.writeFileSync(filename, images[i]);
+      const filename = images.length > 1 ? path12.join(outputDir, `${outputBase}_${i + 1}${outputExt}`) : outputPath;
+      fs13.writeFileSync(filename, images[i]);
       if (!options.json) console.log(`\u2705 Image saved: ${filename}`);
       savedFiles.push(filename);
     }
@@ -2263,6 +3454,9 @@ Note:
     if (error.cause) {
       console.error("Details:", error.cause);
     }
+    if (error.message.includes("Responsible AI practices")) {
+      console.error("\n\u26A0\uFE0F  Google GenAI Filter violation. Please try standardizing the prompt to be more descriptive and avoid vague words.");
+    }
     process.exit(1);
   }
 });
@@ -2347,10 +3541,10 @@ function resolveAspectRatio(input, projectFile) {
   return normalizeAspectRatio(input);
 }
 function inferAspectRatioFromProject(projectFile) {
-  const filePath = path10.resolve(process.cwd(), projectFile);
-  if (!fs9.existsSync(filePath)) return null;
+  const filePath = path12.resolve(process.cwd(), projectFile);
+  if (!fs13.existsSync(filePath)) return null;
   try {
-    const scene = JSON.parse(fs9.readFileSync(filePath, "utf-8"));
+    const scene = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
     const width = scene?.meta?.width;
     const height = scene?.meta?.height;
     if (typeof width !== "number" || typeof height !== "number" || width <= 0 || height <= 0) {
@@ -2390,12 +3584,12 @@ function gcd(a, b) {
 
 // src/cli/commands/audio.ts
 import { Command as Command6 } from "commander";
-import fs11 from "fs";
-import path12 from "path";
+import fs16 from "fs";
+import path15 from "path";
 
 // src/cli/services/whisper.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path13 from "path";
 import os from "os";
 import { spawn as spawn5 } from "child_process";
 import https from "https";
@@ -2404,37 +3598,37 @@ var WhisperService = class {
     return os.homedir();
   }
   static getBaseDir() {
-    return path11.join(this.getHomeDir(), ".feedeas");
+    return path13.join(this.getHomeDir(), ".feedeas");
   }
   static getBinDir() {
-    return path11.join(this.getBaseDir(), "bin");
+    return path13.join(this.getBaseDir(), "bin");
   }
   static getModelsDir() {
-    return path11.join(this.getBaseDir(), "models");
+    return path13.join(this.getBaseDir(), "models");
   }
   static getExecutablePath() {
-    const repoDir = path11.join(this.getBaseDir(), "whisper.cpp-repo");
+    const repoDir = path13.join(this.getBaseDir(), "whisper.cpp-repo");
     const possiblePaths = [
-      path11.join(repoDir, "build", "bin", "whisper-cli"),
-      path11.join(repoDir, "build", "bin", "main"),
-      path11.join(repoDir, "main"),
-      path11.join(this.getBinDir(), "whisper-main")
+      path13.join(repoDir, "build", "bin", "whisper-cli"),
+      path13.join(repoDir, "build", "bin", "main"),
+      path13.join(repoDir, "main"),
+      path13.join(this.getBinDir(), "whisper-main")
       // fallback to copied/downloaded
     ];
     for (const p of possiblePaths) {
-      if (fs10.existsSync(p)) return p;
+      if (fs14.existsSync(p)) return p;
     }
-    return path11.join(this.getBinDir(), "whisper-main");
+    return path13.join(this.getBinDir(), "whisper-main");
   }
   static getModelPath(modelName = "base.en") {
-    return path11.join(this.getModelsDir(), `ggml-${modelName}.bin`);
+    return path13.join(this.getModelsDir(), `ggml-${modelName}.bin`);
   }
   /**
    * Download a file from a URL to a destination path
    */
   static async downloadFile(url, destPath) {
     return new Promise((resolve, reject) => {
-      const file = fs10.createWriteStream(destPath);
+      const file = fs14.createWriteStream(destPath);
       https.get(url, (response) => {
         if (response.statusCode === 302 || response.statusCode === 301) {
           this.downloadFile(response.headers.location, destPath).then(resolve).catch(reject);
@@ -2450,7 +3644,7 @@ var WhisperService = class {
           resolve();
         });
       }).on("error", (err) => {
-        fs10.unlink(destPath, () => {
+        fs14.unlink(destPath, () => {
         });
         reject(err);
       });
@@ -2462,15 +3656,15 @@ var WhisperService = class {
   static async ensureReady() {
     const binDir = this.getBinDir();
     const modelsDir = this.getModelsDir();
-    if (!fs10.existsSync(binDir)) fs10.mkdirSync(binDir, { recursive: true });
-    if (!fs10.existsSync(modelsDir)) fs10.mkdirSync(modelsDir, { recursive: true });
+    if (!fs14.existsSync(binDir)) fs14.mkdirSync(binDir, { recursive: true });
+    if (!fs14.existsSync(modelsDir)) fs14.mkdirSync(modelsDir, { recursive: true });
     const execPath = this.getExecutablePath();
     const modelPath = this.getModelPath();
-    if (!fs10.existsSync(execPath)) {
+    if (!fs14.existsSync(execPath)) {
       console.log("\u2B07\uFE0F  Whisper binary not found. Attempting to build...");
       try {
-        const repoDir = path11.join(this.getBaseDir(), "whisper.cpp-repo");
-        if (!fs10.existsSync(repoDir)) {
+        const repoDir = path13.join(this.getBaseDir(), "whisper.cpp-repo");
+        if (!fs14.existsSync(repoDir)) {
           console.log("\u{1F4E6}  Cloning whisper.cpp...");
           await runCommand("git", ["clone", "https://github.com/ggerganov/whisper.cpp.git", repoDir]);
         } else {
@@ -2478,7 +3672,7 @@ var WhisperService = class {
         console.log("\u{1F528}  Building whisper.cpp (this may take a minute)...");
         await runCommand("make", [], repoDir);
         const newPath = this.getExecutablePath();
-        if (fs10.existsSync(newPath)) {
+        if (fs14.existsSync(newPath)) {
           console.log(`\u2705 Whisper binary built at: ${newPath}`);
         } else {
           throw new Error("Build command finished but binary not found in expected paths.");
@@ -2489,7 +3683,7 @@ var WhisperService = class {
 Please install manually: 'brew install whisper-cpp'`);
       }
     }
-    if (!fs10.existsSync(modelPath)) {
+    if (!fs14.existsSync(modelPath)) {
       console.log("\u2B07\uFE0F  Downloading Whisper model (base.en)...");
       const modelUrl = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin";
       await this.downloadFile(modelUrl, modelPath);
@@ -2502,12 +3696,12 @@ Please install manually: 'brew install whisper-cpp'`);
   static async transcribe(audioPath) {
     const execPath = this.getExecutablePath();
     const modelPath = this.getModelPath();
-    const ext = path11.extname(audioPath).toLowerCase();
+    const ext = path13.extname(audioPath).toLowerCase();
     let inputToWhisper = audioPath;
     let isTempFile = false;
     if (ext !== ".wav") {
       console.log("\u{1F504} Converting audio to 16kHz WAV for Whisper...");
-      const tempWav = path11.join(path11.dirname(audioPath), `temp_${Date.now()}.wav`);
+      const tempWav = path13.join(path13.dirname(audioPath), `temp_${Date.now()}.wav`);
       await runCommand("ffmpeg", [
         "-i",
         audioPath,
@@ -2524,7 +3718,7 @@ Please install manually: 'brew install whisper-cpp'`);
       isTempFile = true;
     }
     try {
-      const outputBase = path11.join(path11.dirname(audioPath), path11.basename(audioPath, path11.extname(audioPath)));
+      const outputBase = path13.join(path13.dirname(audioPath), path13.basename(audioPath, path13.extname(audioPath)));
       const baseArgs = [
         "-m",
         modelPath,
@@ -2561,8 +3755,8 @@ Please install manually: 'brew install whisper-cpp'`);
         words
       };
     } finally {
-      if (isTempFile && fs10.existsSync(inputToWhisper)) {
-        fs10.unlinkSync(inputToWhisper);
+      if (isTempFile && fs14.existsSync(inputToWhisper)) {
+        fs14.unlinkSync(inputToWhisper);
       }
     }
   }
@@ -2588,12 +3782,12 @@ function runWhisper(execPath, args) {
       const outputFileIndex = args.indexOf("-of");
       const outputBase = outputFileIndex >= 0 ? args[outputFileIndex + 1] : void 0;
       const jsonPath = outputBase ? `${outputBase}.json` : "";
-      if (!jsonPath || !fs10.existsSync(jsonPath)) {
+      if (!jsonPath || !fs14.existsSync(jsonPath)) {
         reject(new Error("Whisper output JSON not found"));
         return;
       }
       try {
-        const data = JSON.parse(fs10.readFileSync(jsonPath, "utf-8"));
+        const data = JSON.parse(fs14.readFileSync(jsonPath, "utf-8"));
         resolve(data);
       } catch (err) {
         reject(err);
@@ -2641,14 +3835,133 @@ function roundTo3(value) {
   return Math.round(value * 1e3) / 1e3;
 }
 
+// src/cli/services/audio-convert.ts
+import fs15 from "fs";
+import path14 from "path";
+import { spawn as spawn6 } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { FFmpeg } from "@ffmpeg/ffmpeg";
+function isNodeRuntime() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
+function buildCodecArgs(options) {
+  if (options.format === "wav") {
+    return ["-c:a", "pcm_s16le"];
+  }
+  if (typeof options.mp3Quality === "number") {
+    return ["-c:a", "libmp3lame", "-q:a", String(options.mp3Quality)];
+  }
+  return ["-c:a", "libmp3lame", "-b:a", options.mp3Bitrate || "128k"];
+}
+async function convertWithNodeFfmpeg(options) {
+  const { pcmPath, outputPath, sampleRate, channels, durationSec } = options;
+  const codecArgs = buildCodecArgs(options);
+  await new Promise((resolve, reject) => {
+    const ffmpeg = spawn6("ffmpeg", [
+      "-f",
+      "s16le",
+      "-ar",
+      String(sampleRate),
+      "-ac",
+      String(channels),
+      "-i",
+      pcmPath,
+      ...typeof durationSec === "number" ? ["-t", String(durationSec)] : [],
+      ...codecArgs,
+      "-y",
+      outputPath
+    ], { stdio: "inherit" });
+    ffmpeg.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`FFmpeg exited with code ${code}`));
+    });
+    ffmpeg.on("error", (err) => reject(err));
+  });
+}
+async function convertWithWasm(options) {
+  const { pcmPath, outputPath, sampleRate, channels, durationSec } = options;
+  const ffmpeg = new FFmpeg();
+  const baseDir = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+  const coreDir = path14.resolve(baseDir, "node_modules/@ffmpeg/core/dist");
+  const coreURL = pathToFileURL(path14.join(coreDir, "ffmpeg-core.js")).toString();
+  const wasmURL = pathToFileURL(path14.join(coreDir, "ffmpeg-core.wasm")).toString();
+  const workerURL = pathToFileURL(path14.join(coreDir, "ffmpeg-core.worker.js")).toString();
+  await ffmpeg.load({ coreURL, wasmURL, workerURL });
+  const pcmBytes = await fs15.promises.readFile(pcmPath);
+  await ffmpeg.writeFile("input.pcm", pcmBytes);
+  const codecArgs = buildCodecArgs(options);
+  const outputName = options.format === "wav" ? "output.wav" : "output.mp3";
+  await ffmpeg.exec([
+    "-f",
+    "s16le",
+    "-ar",
+    String(sampleRate),
+    "-ac",
+    String(channels),
+    "-i",
+    "input.pcm",
+    ...typeof durationSec === "number" ? ["-t", String(durationSec)] : [],
+    ...codecArgs,
+    outputName
+  ]);
+  const output = await ffmpeg.readFile(outputName);
+  await fs15.promises.writeFile(outputPath, output);
+}
+async function convertPcmToAudio(options) {
+  const { pcmPath } = options;
+  let useWasm = !isNodeRuntime();
+  try {
+    try {
+      if (!useWasm) {
+        await convertWithNodeFfmpeg(options);
+        return;
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw err;
+      }
+      useWasm = true;
+    }
+    if (useWasm) {
+      try {
+        await convertWithWasm(options);
+        return;
+      } catch (err) {
+        throw new Error(
+          `Audio conversion failed. Install ffmpeg or ensure @ffmpeg/core assets are present for wasm conversion. (${err?.message || err})`
+        );
+      }
+    }
+    throw new Error(
+      "Audio conversion failed. Install ffmpeg or ensure @ffmpeg/core assets are present for wasm conversion."
+    );
+  } finally {
+    if (fs15.existsSync(pcmPath)) {
+      try {
+        await fs15.promises.unlink(pcmPath);
+      } catch {
+      }
+    }
+  }
+}
+async function convertPcmToMp3(options) {
+  await convertPcmToAudio({
+    ...options,
+    format: "mp3",
+    sampleRate: 24e3,
+    channels: 1,
+    mp3Bitrate: "128k"
+  });
+}
+
 // src/cli/commands/audio.ts
 var audioCommand = new Command6("generate:audio");
 audioCommand.alias("audio").description("Generate audio from text using Gemini API and extract metadata").argument("<text-or-file>", "Input text or path to text file").option("-o, --output <filename>", "Output filename (relative to assets/ or absolute path)", "speech.mp3").option("-k, --api-key <key>", "Gemini API key (or set GEMINI_API_KEY env var)").option("--voice <name>", "Voice name (optional)").option("--no-transcribe", "Skip Whisper transcription/metadata generation").action(async (textOrFile, options) => {
   try {
     let text;
-    if (fs11.existsSync(textOrFile)) {
+    if (fs16.existsSync(textOrFile)) {
       console.log(`\u{1F4D6} Reading text from file: ${textOrFile}`);
-      text = fs11.readFileSync(textOrFile, "utf-8").trim();
+      text = fs16.readFileSync(textOrFile, "utf-8").trim();
     } else {
       text = textOrFile;
     }
@@ -2663,41 +3976,22 @@ audioCommand.alias("audio").description("Generate audio from text using Gemini A
     }
     console.log("\u{1F5E3}\uFE0F  Generating speech with Gemini...");
     const audioBuffer = await generateGeminiAudio(text, apiKey, options.voice);
-    const outputPath = resolveOutputPath(options.output);
-    const tempPcmPath = path12.join(path12.dirname(outputPath), `temp_${Date.now()}.pcm`);
-    fs11.writeFileSync(tempPcmPath, audioBuffer);
-    try {
-      console.log(`\u{1F504} Converting raw PCM to ${path12.extname(outputPath)}...`);
-      await new Promise((resolve, reject) => {
-        const ffmpeg = __require("child_process").spawn("ffmpeg", [
-          "-f",
-          "s16le",
-          "-ar",
-          "24000",
-          "-ac",
-          "1",
-          "-i",
-          tempPcmPath,
-          "-y",
-          outputPath
-        ], { stdio: "inherit" });
-        ffmpeg.on("close", (code) => {
-          if (code === 0) resolve();
-          else reject(new Error(`FFmpeg exited with code ${code}`));
-        });
-        ffmpeg.on("error", (err) => reject(err));
-      });
-      console.log(`\u2705 Audio saved: ${outputPath}`);
-    } finally {
-      if (fs11.existsSync(tempPcmPath)) fs11.unlinkSync(tempPcmPath);
-    }
+    const outputPath = resolveAssetOutputPath(options.output);
+    const tempPcmPath = path15.join(path15.dirname(outputPath), `temp_${Date.now()}.pcm`);
+    fs16.writeFileSync(tempPcmPath, audioBuffer);
+    console.log(`\u{1F504} Converting raw PCM to ${path15.extname(outputPath)}...`);
+    await convertPcmToMp3({
+      pcmPath: tempPcmPath,
+      outputPath
+    });
+    console.log(`\u2705 Audio saved: ${outputPath}`);
     if (options.transcribe) {
       try {
         console.log("\u{1F50D} Aligning audio with Whisper...");
         await WhisperService.ensureReady();
         const metadata = await WhisperService.transcribe(outputPath);
-        const metaPath = outputPath.replace(path12.extname(outputPath), ".json");
-        fs11.writeFileSync(metaPath, JSON.stringify(metadata, null, 2));
+        const metaPath = outputPath.replace(path15.extname(outputPath), ".json");
+        fs16.writeFileSync(metaPath, JSON.stringify(metadata, null, 2));
         console.log(`\u2705 Metadata saved: ${metaPath}`);
       } catch (wErr) {
         console.warn("\u26A0\uFE0F  Whisper alignment failed:", wErr.message);
@@ -2708,12 +4002,6 @@ audioCommand.alias("audio").description("Generate audio from text using Gemini A
     process.exit(1);
   }
 });
-function resolveOutputPath(outputOption) {
-  if (path12.isAbsolute(outputOption)) return outputOption;
-  const assetsDir = path12.resolve(process.cwd(), "assets");
-  if (!fs11.existsSync(assetsDir)) fs11.mkdirSync(assetsDir, { recursive: true });
-  return path12.join(assetsDir, outputOption);
-}
 async function generateGeminiAudio(text, apiKey, voiceName) {
   const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent`;
   const requestBody = {
@@ -2753,9 +4041,8 @@ async function generateGeminiAudio(text, apiKey, voiceName) {
 
 // src/cli/commands/bgm.ts
 import { Command as Command7 } from "commander";
-import fs12 from "fs";
-import path13 from "path";
-import { spawn as spawn6 } from "child_process";
+import fs17 from "fs";
+import path16 from "path";
 var bgmCommand = new Command7("generate:bgm");
 bgmCommand.alias("bgm").alias("music").description("Generate background music with Gemini Lyria (Live Music API)").argument("<prompt-or-file>", "Music prompt text or path to a text file").option("-o, --output <filename>", "Output filename (relative to assets/ or absolute path)", "bgm.mp3").option("-k, --api-key <key>", "Gemini API key (or set GEMINI_API_KEY env var)").option("-d, --duration <seconds>", "Target duration in seconds (5-300)", "30").option("--seed <number>", "Optional seed for reproducible output").option("--json", "Emit machine-readable JSON output").action(async (promptOrFile, options) => {
   try {
@@ -2766,7 +4053,7 @@ bgmCommand.alias("bgm").alias("music").description("Generate background music wi
     }
     const durationSec = parseDuration(options.duration);
     const seed = parseSeed(options.seed);
-    const outputPath = resolveOutputPath2(options.output);
+    const outputPath = resolveAssetOutputPath(options.output);
     const format = inferOutputFormat(outputPath);
     const request = {
       provider: "gemini",
@@ -2806,7 +4093,7 @@ bgmCommand.alias("bgm").alias("music").description("Generate background music wi
   }
 });
 function resolvePrompt(promptOrFile) {
-  const prompt = fs12.existsSync(promptOrFile) ? fs12.readFileSync(promptOrFile, "utf-8").trim() : String(promptOrFile).trim();
+  const prompt = fs17.existsSync(promptOrFile) ? fs17.readFileSync(promptOrFile, "utf-8").trim() : String(promptOrFile).trim();
   if (!prompt) {
     throw new Error("Prompt cannot be empty");
   }
@@ -2827,14 +4114,8 @@ function parseSeed(input) {
   }
   return value;
 }
-function resolveOutputPath2(outputOption) {
-  if (path13.isAbsolute(outputOption)) return outputOption;
-  const assetsDir = path13.resolve(process.cwd(), "assets");
-  if (!fs12.existsSync(assetsDir)) fs12.mkdirSync(assetsDir, { recursive: true });
-  return path13.join(assetsDir, outputOption);
-}
 function inferOutputFormat(outputPath) {
-  const ext = path13.extname(outputPath).toLowerCase();
+  const ext = path16.extname(outputPath).toLowerCase();
   if (ext === ".wav") return "wav";
   if (ext === ".mp3" || !ext) return "mp3";
   throw new Error("Invalid output format. Use .mp3 or .wav.");
@@ -2922,54 +4203,36 @@ async function generateGeminiMusicPcm(request) {
   });
 }
 async function convertPcmToOutput(pcmBuffer, outputPath, format, durationSec) {
-  const outputDir = path13.dirname(outputPath);
-  if (!fs12.existsSync(outputDir)) fs12.mkdirSync(outputDir, { recursive: true });
-  const tempPcmPath = path13.join(outputDir, `temp_bgm_${Date.now()}.pcm`);
-  fs12.writeFileSync(tempPcmPath, pcmBuffer);
-  const codecArgs = format === "wav" ? ["-c:a", "pcm_s16le"] : ["-c:a", "libmp3lame", "-q:a", "2"];
-  try {
-    await new Promise((resolve, reject) => {
-      const ffmpeg = spawn6("ffmpeg", [
-        "-f",
-        "s16le",
-        "-ar",
-        "48000",
-        "-ac",
-        "2",
-        "-i",
-        tempPcmPath,
-        "-t",
-        String(durationSec),
-        ...codecArgs,
-        "-y",
-        outputPath
-      ], { stdio: "inherit" });
-      ffmpeg.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`FFmpeg exited with code ${code}`));
-      });
-      ffmpeg.on("error", reject);
-    });
-  } finally {
-    if (fs12.existsSync(tempPcmPath)) fs12.unlinkSync(tempPcmPath);
-  }
+  const outputDir = path16.dirname(outputPath);
+  if (!fs17.existsSync(outputDir)) fs17.mkdirSync(outputDir, { recursive: true });
+  const tempPcmPath = path16.join(outputDir, `temp_bgm_${Date.now()}.pcm`);
+  fs17.writeFileSync(tempPcmPath, pcmBuffer);
+  await convertPcmToAudio({
+    pcmPath: tempPcmPath,
+    outputPath,
+    format,
+    sampleRate: 48e3,
+    channels: 2,
+    durationSec,
+    mp3Quality: format === "mp3" ? 2 : void 0
+  });
 }
 
 // src/cli/commands/asset.ts
 import { Command as Command8 } from "commander";
-import fs13 from "fs";
-import path14 from "path";
+import fs18 from "fs";
+import path17 from "path";
 import { spawn as spawn7 } from "child_process";
 var assetCommand = new Command8("asset").description("Asset information and management");
 assetCommand.command("info <file>").description("Show detailed information about an asset").action(async (file) => {
-  const assetPath = path14.resolve(process.cwd(), "assets", file);
-  if (!fs13.existsSync(assetPath)) {
+  const assetPath = path17.resolve(process.cwd(), "assets", file);
+  if (!fs18.existsSync(assetPath)) {
     console.error(`Asset not found: ${file}`);
     console.error(`Looked in: ${assetPath}`);
     process.exit(1);
   }
-  const stats = fs13.statSync(assetPath);
-  const ext = path14.extname(file).toLowerCase();
+  const stats = fs18.statSync(assetPath);
+  const ext = path17.extname(file).toLowerCase();
   console.log(`
 Asset: ${file}`);
   console.log(`Size: ${formatBytes2(stats.size)}`);
@@ -2992,11 +4255,11 @@ Asset: ${file}`);
       console.log(`Channels: ${audioInfo.channels}`);
       console.log(`Bitrate: ${audioInfo.bitrate}`);
       const metadataFile = file.replace(ext, ".json");
-      const metadataPath = path14.resolve(process.cwd(), "assets", metadataFile);
-      if (fs13.existsSync(metadataPath)) {
+      const metadataPath = path17.resolve(process.cwd(), "assets", metadataFile);
+      if (fs18.existsSync(metadataPath)) {
         console.log(`
 Metadata: ${metadataFile}`);
-        const metadata = JSON.parse(fs13.readFileSync(metadataPath, "utf-8"));
+        const metadata = JSON.parse(fs18.readFileSync(metadataPath, "utf-8"));
         if (Array.isArray(metadata.words) && metadata.words.length > 0) {
           console.log(`Word timings: ${metadata.words.length} words`);
           const firstWord = metadata.words[0];
@@ -3033,7 +4296,8 @@ function getAssetType(ext) {
 async function getImageDimensions(filePath) {
   try {
     const imageSize = await import("image-size");
-    const dimensions = imageSize.default(filePath);
+    const buffer = fs18.readFileSync(filePath);
+    const dimensions = imageSize.default(buffer);
     return { width: dimensions.width || 0, height: dimensions.height || 0 };
   } catch (err) {
     throw new Error("image-size package not available");
@@ -3080,9 +4344,9 @@ async function getAudioInfo(filePath) {
 
 // src/cli/index.ts
 import open2 from "open";
-import path18 from "path";
+import path21 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import fs17 from "fs";
+import fs21 from "fs";
 
 // src/cli/commands/example.ts
 import { Command as Command9 } from "commander";
@@ -3375,72 +4639,42 @@ function printSchema(name, schema) {
 
 // src/cli/commands/create-scene.ts
 import { Command as Command11 } from "commander";
-import path15 from "path";
-
-// src/cli/services/scene-builder.ts
-import fs14 from "fs";
-function loadScene(filePath) {
-  if (fs14.existsSync(filePath)) {
-    try {
-      return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
-    } catch (e) {
-      throw new Error(`Failed to parse existing scene file: ${e}`);
-    }
-  } else {
-    return {
-      meta: {
-        width: 1080,
-        height: 1920,
-        duration: 10
-      },
-      entities: []
-    };
-  }
-}
-function saveScene(filePath, scene) {
-  fs14.writeFileSync(filePath, JSON.stringify(scene, null, 2));
-}
-function addEntityToScene(scene, entity) {
-  if (!entity.id) {
-    const typeCount = scene.entities.filter((e) => e.type === entity.type).length + 1;
-    entity.id = `${entity.type}-${typeCount}`;
-  }
-  if (scene.entities.some((e) => e.id === entity.id)) {
-    throw new Error(`Entity with ID "${entity.id}" already exists.`);
-  }
-  scene.entities.push(entity);
-  if (typeof entity.startTime === "number" && typeof entity.duration === "number") {
-    const entityEnd = entity.startTime + entity.duration;
-    if (entityEnd > scene.meta.duration) {
-      scene.meta.duration = Math.ceil(entityEnd);
-    }
-  }
-}
-
-// src/cli/commands/create-scene.ts
-import fs15 from "fs";
 var createSceneCommand = new Command11("create-scene");
-createSceneCommand.description("Create and modify scene files").argument("<file>", "Path to the scene file").action(async (file) => {
-  const filePath = path15.resolve(process.cwd(), file);
+createSceneCommand.description("Create a new scene in a project").option("--project-id <id>", "Project ID").option("--name <name>", "Scene name").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
   try {
-    const scene = loadScene(filePath);
-    saveScene(filePath, scene);
-    console.log(`\u2705 Scene file ready at: ${filePath}`);
+    const projectId = resolveProjectId(options.projectId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const scene = apiUrl ? await new SceneApiClient(apiUrl).createScene(projectId, {
+      name: options.name ? String(options.name) : void 0
+    }) : await createSceneStoreBundle("file").scenes.createScene(projectId, {
+      name: options.name ? String(options.name) : void 0
+    });
+    writeFlowState({ projectId, sceneId: scene.id, apiUrl });
+    console.log(`\u2705 Scene created: ${scene.id} (project ${scene.projectId})`);
   } catch (error) {
     console.error(`\u274C Error creating scene: ${error.message}`);
     process.exit(1);
   }
 });
 var addEntityCommand = new Command11("add-entity");
-addEntityCommand.description("Add an entity to an existing scene file").argument("<file>", "Path to the scene file").requiredOption("-t, --type <type>", "Entity type (image, audio, text)").option("--src <path>", "Asset path (relative to CWD or absolute)").option("--text <content>", "Text content (for text)").option("--fit <mode>", "Image fit mode: smart | contain | cover", "smart").option("--start <number>", "Start time in seconds").option("--duration <string>", 'Duration in seconds or "auto"', "5").option("--at <position>", 'Position ("end" to append after last entity)', "end").action(async (file, options) => {
-  const filePath = path15.resolve(process.cwd(), file);
-  if (!fs15.existsSync(filePath)) {
-    console.error(`\u274C Scene file not found: ${filePath}`);
-    process.exit(1);
-  }
+addEntityCommand.description("Add an entity to an existing scene").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").requiredOption("-t, --type <type>", "Entity type (image, audio, text)").option("--src <path>", "Asset URI/path").option("--text <content>", "Text content (for text)").option("--fit <mode>", "Image fit mode: smart | contain | cover", "smart").option("--start <number>", "Start time in seconds").option("--duration <string>", 'Duration in seconds or "auto"', "5").option("--at <position>", 'Position ("end" to append after last entity)', "end").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
   try {
-    const scene = loadScene(filePath);
+    const bundle = createSceneStoreBundle("file");
+    const projectId = resolveProjectId(options.projectId);
+    const sceneId = resolveSceneId(options.sceneId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const apiClient = apiUrl ? new SceneApiClient(apiUrl) : null;
+    const project = apiClient ? await apiClient.getProject(projectId) : await bundle.projects.getProject(projectId);
+    if (!project) {
+      throw new Error(`Project not found: ${projectId}`);
+    }
+    const scene = apiClient ? await apiClient.getScene(projectId, sceneId) : await bundle.scenes.getScene(projectId, sceneId);
+    if (!scene) {
+      throw new Error(`Scene not found: ${sceneId}`);
+    }
     const type = options.type;
+    const entities = [...scene.entities];
+    const registry = createDefaultAssetResolverRegistry();
     let entity = {
       type,
       visible: true
@@ -3448,30 +4682,27 @@ addEntityCommand.description("Add an entity to an existing scene file").argument
     let startTime = parseFloat(options.start);
     let duration = parseFloat(options.duration);
     if (isNaN(startTime) && options.at === "end") {
-      const entities = scene.entities;
-      if (entities.length > 0) {
-        let maxEnd = 0;
-        entities.forEach((e) => {
-          if (typeof e.startTime === "number" && typeof e.duration === "number") {
-            const end = e.startTime + e.duration;
-            if (end > maxEnd) maxEnd = end;
-          }
-        });
-        startTime = maxEnd;
-      } else {
-        startTime = 0;
-      }
+      let maxEnd = 0;
+      entities.forEach((e) => {
+        if (typeof e.startTime === "number" && typeof e.duration === "number") {
+          const end = e.startTime + e.duration;
+          if (end > maxEnd) maxEnd = end;
+        }
+      });
+      startTime = maxEnd;
     } else if (isNaN(startTime)) {
       startTime = 0;
     }
     if (options.duration === "auto" && options.src) {
-      const assetPath = path15.resolve(process.cwd(), options.src);
-      try {
-        const metadata = await FFprobeService.getMetadata(assetPath);
-        duration = metadata.duration;
-        console.log(`\u2139\uFE0F  Auto-detected duration: ${duration.toFixed(2)}s`);
-      } catch (e) {
-        console.warn(`\u26A0\uFE0F  Could not auto-detect duration for ${options.src}, using default 5s`);
+      const resolved = registry.resolve(options.src, project.rootPath || process.cwd());
+      if (resolved.type === "local") {
+        try {
+          const metadata = await FFprobeService.getMetadata(resolved.localPath);
+          duration = metadata.duration;
+        } catch {
+          duration = 5;
+        }
+      } else {
         duration = 5;
       }
     } else if (options.duration === "auto") {
@@ -3498,12 +4729,32 @@ addEntityCommand.description("Add an entity to an existing scene file").argument
       entity.color = "#ffffff";
       entity.x = 540;
       entity.y = 960;
+      entity.fontFamily = "Arial";
+      entity.fontWeight = "700";
+      entity.bgColor = "transparent";
+      entity.maxWidth = 900;
+      entity.lineHeight = 1.2;
+      entity.padding = 8;
+      entity.textAlign = "left";
     } else {
       throw new Error(`Unknown type: ${type}`);
     }
-    addEntityToScene(scene, entity);
-    saveScene(filePath, scene);
-    console.log(`\u2705 Added ${type} entity to ${file} at ${startTime}s`);
+    if (!entity.id) {
+      const typeCount = entities.filter((e) => e.type === entity.type).length + 1;
+      entity.id = `${entity.type}-${typeCount}`;
+    }
+    entity.name = entity.name || entity.id;
+    entities.push(entity);
+    const updated = apiClient ? await apiClient.updateScene(projectId, sceneId, {
+      entities,
+      meta: scene.meta,
+      version: scene.version
+    }) : await bundle.scenes.updateScene(projectId, sceneId, {
+      entities,
+      meta: scene.meta
+    }, scene.version);
+    writeFlowState({ projectId, sceneId, apiUrl });
+    console.log(`\u2705 Added ${type} entity to scene ${updated.id} at ${startTime}s`);
   } catch (error) {
     console.error(`\u274C Error adding entity: ${error.message}`);
     process.exit(1);
@@ -3512,7 +4763,7 @@ addEntityCommand.description("Add an entity to an existing scene file").argument
 
 // src/cli/services/telemetry.ts
 import os2 from "os";
-import path16 from "path";
+import path18 from "path";
 import { createHash as createHash2 } from "crypto";
 var POSTHOG_CAPTURE_URL = "https://us.i.posthog.com/capture/";
 var TELEMETRY_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
@@ -3524,7 +4775,7 @@ var PostHogTelemetryService = class {
     if (!this.enabled) return;
     this.capture("cli_feedback", {
       details: String(details).slice(0, 2e3),
-      cwd_basename: path16.basename(process.cwd())
+      cwd_basename: path18.basename(process.cwd())
     });
   }
   apiKey;
@@ -3547,7 +4798,7 @@ var PostHogTelemetryService = class {
       command_name: this.getCommandPath(actionCommand),
       command_aliases: actionCommand.aliases(),
       options_used: this.getUsedOptionNames(actionCommand),
-      cwd_basename: path16.basename(process.cwd()),
+      cwd_basename: path18.basename(process.cwd()),
       node_version: process.version,
       platform: process.platform,
       arch: process.arch
@@ -3560,7 +4811,7 @@ var PostHogTelemetryService = class {
       status,
       duration_ms: Math.max(0, Math.round(durationMs)),
       error_message: errorMessage ? String(errorMessage).slice(0, 300) : void 0,
-      cwd_basename: path16.basename(process.cwd())
+      cwd_basename: path18.basename(process.cwd())
     });
   }
   getCommandPath(command) {
@@ -3613,26 +4864,26 @@ var PostHogTelemetryService = class {
 
 // src/cli/commands/taste.ts
 import { Command as Command12 } from "commander";
-import fs16 from "node:fs";
-import path17 from "node:path";
+import fs19 from "node:fs";
+import path19 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import open from "open";
 var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = path17.dirname(__filename4);
+var __dirname4 = path19.dirname(__filename4);
 function resolveStaticRoot() {
-  let staticRoot = path17.resolve(__dirname4, "../../../dist/ui");
-  if (!fs16.existsSync(staticRoot)) {
-    staticRoot = path17.resolve(__dirname4, "../../ui");
+  let staticRoot = path19.resolve(__dirname4, "../../../dist/ui");
+  if (!fs19.existsSync(staticRoot)) {
+    staticRoot = path19.resolve(__dirname4, "../../ui");
   }
   return staticRoot;
 }
 function prepareWorkingDirectory(pathArg) {
   if (!pathArg) return;
-  const targetPath = path17.resolve(process.cwd(), pathArg);
-  if (fs16.existsSync(targetPath)) {
-    const stats = fs16.statSync(targetPath);
+  const targetPath = path19.resolve(process.cwd(), pathArg);
+  if (fs19.existsSync(targetPath)) {
+    const stats = fs19.statSync(targetPath);
     if (stats.isFile()) {
-      process.chdir(path17.dirname(targetPath));
+      process.chdir(path19.dirname(targetPath));
       return;
     }
     if (stats.isDirectory()) {
@@ -3640,13 +4891,13 @@ function prepareWorkingDirectory(pathArg) {
       return;
     }
   }
-  if (path17.extname(pathArg)) {
-    const dir = path17.dirname(targetPath);
-    fs16.mkdirSync(dir, { recursive: true });
+  if (path19.extname(pathArg)) {
+    const dir = path19.dirname(targetPath);
+    fs19.mkdirSync(dir, { recursive: true });
     process.chdir(dir);
     return;
   }
-  fs16.mkdirSync(targetPath, { recursive: true });
+  fs19.mkdirSync(targetPath, { recursive: true });
   process.chdir(targetPath);
 }
 function createStoreFromOptions(options) {
@@ -3666,7 +4917,7 @@ var tasteCommand = new Command12("taste").description("Launch and automate the T
   const store = createStoreFromOptions(options);
   await store.ensureWorkspace();
   const staticRoot = resolveStaticRoot();
-  if (!fs16.existsSync(staticRoot)) {
+  if (!fs19.existsSync(staticRoot)) {
     console.warn(`Warning: UI assets not found at ${staticRoot}. Did you run 'bun run build'?`);
   }
   const port = parseInt(options.port, 10);
@@ -3891,13 +5142,140 @@ function createFeedbackCommand(telemetry2) {
   });
 }
 
+// src/cli/commands/project.ts
+import { Command as Command14 } from "commander";
+var projectCommand = new Command14("project").description("Manage projects");
+projectCommand.command("create").description("Create a project with a default scene").requiredOption("--name <name>", "Project name").option("--root-path <path>", "Project root path", process.cwd()).option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
+  try {
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    if (apiUrl) {
+      const client = new SceneApiClient(apiUrl);
+      const created = await client.createProject({
+        name: String(options.name),
+        rootPath: String(options.rootPath || process.cwd())
+      });
+      writeFlowState({ projectId: created.project.id, sceneId: created.defaultScene.id, apiUrl });
+      console.log(JSON.stringify(created, null, 2));
+    } else {
+      const bundle = createSceneStoreBundle("file");
+      const project = await bundle.projects.createProject({
+        name: String(options.name),
+        rootPath: String(options.rootPath || process.cwd())
+      });
+      const defaultScene = await bundle.scenes.createScene(project.id, { name: "Scene 1" });
+      const updated = await bundle.projects.updateProject(project.id, { defaultSceneId: defaultScene.id });
+      writeFlowState({ projectId: updated.id, sceneId: defaultScene.id });
+      console.log(JSON.stringify({ project: updated, defaultScene }, null, 2));
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+projectCommand.command("list").description("List projects").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
+  try {
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const projects = apiUrl ? await new SceneApiClient(apiUrl).listProjects() : await createSceneStoreBundle("file").projects.listProjects();
+    console.log(JSON.stringify({ projects }, null, 2));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/scene.ts
+import fs20 from "node:fs";
+import path20 from "node:path";
+import { Command as Command15 } from "commander";
+var sceneCommand = new Command15("scene").description("Manage scenes");
+sceneCommand.command("list").option("--project-id <id>", "Project ID").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
+  try {
+    const projectId = resolveProjectId(options.projectId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const scenes = apiUrl ? await new SceneApiClient(apiUrl).listScenes(projectId) : await createSceneStoreBundle("file").scenes.listScenes(projectId);
+    console.log(JSON.stringify({ scenes }, null, 2));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+sceneCommand.command("create").option("--project-id <id>", "Project ID").option("--name <name>", "Scene name").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
+  try {
+    const projectId = resolveProjectId(options.projectId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const scene = apiUrl ? await new SceneApiClient(apiUrl).createScene(projectId, {
+      name: options.name ? String(options.name) : void 0
+    }) : await createSceneStoreBundle("file").scenes.createScene(projectId, {
+      name: options.name ? String(options.name) : void 0
+    });
+    writeFlowState({ projectId, sceneId: scene.id, apiUrl });
+    console.log(JSON.stringify({ scene }, null, 2));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+sceneCommand.command("import").option("--project-id <id>", "Project ID").requiredOption("--file <path>", "Scene JSON file path").option("--name <name>", "Scene name").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
+  try {
+    const filePath = path20.resolve(process.cwd(), String(options.file));
+    if (!fs20.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const parsed = JSON.parse(fs20.readFileSync(filePath, "utf-8"));
+    if (!parsed?.meta || !Array.isArray(parsed?.entities)) {
+      throw new Error("Invalid scene file. Expected { meta, entities }.");
+    }
+    const projectId = resolveProjectId(options.projectId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const scene = apiUrl ? await new SceneApiClient(apiUrl).createScene(projectId, {
+      name: options.name ? String(options.name) : path20.basename(filePath, path20.extname(filePath)),
+      scene: { meta: parsed.meta, entities: parsed.entities }
+    }) : await createSceneStoreBundle("file").scenes.createScene(projectId, {
+      name: options.name ? String(options.name) : path20.basename(filePath, path20.extname(filePath)),
+      scene: { meta: parsed.meta, entities: parsed.entities }
+    });
+    writeFlowState({ projectId, sceneId: scene.id, apiUrl });
+    console.log(JSON.stringify({ scene }, null, 2));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+sceneCommand.command("export").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").requiredOption("--file <path>", "Output file path").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
+  try {
+    const projectId = resolveProjectId(options.projectId);
+    const sceneId = resolveSceneId(options.sceneId);
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const scene = apiUrl ? await new SceneApiClient(apiUrl).getScene(projectId, sceneId) : await createSceneStoreBundle("file").scenes.getScene(projectId, sceneId);
+    if (!scene) {
+      throw new Error(`Scene not found: ${sceneId}`);
+    }
+    const out = path20.resolve(process.cwd(), String(options.file));
+    fs20.mkdirSync(path20.dirname(out), { recursive: true });
+    fs20.writeFileSync(out, JSON.stringify({ meta: scene.meta, entities: scene.entities }, null, 2), "utf-8");
+    writeFlowState({ projectId, sceneId, apiUrl });
+    console.log(`Scene exported to ${out}`);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+sceneCommand.command("use").description("Set current flow state for project/scene").requiredOption("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action((options) => {
+  const next = writeFlowState({
+    projectId: String(options.projectId),
+    sceneId: options.sceneId ? String(options.sceneId) : void 0,
+    apiUrl: options.apiUrl ? String(options.apiUrl) : void 0
+  });
+  console.log(JSON.stringify({ session: next }, null, 2));
+});
+
 // src/cli/index.ts
 var __filename5 = fileURLToPath5(import.meta.url);
-var __dirname5 = path18.dirname(__filename5);
-var program = new Command14();
+var __dirname5 = path21.dirname(__filename5);
+var program = new Command16();
 var telemetry = new PostHogTelemetryService();
 var commandStartTimes = /* @__PURE__ */ new WeakMap();
-program.name("feedeas").description("CLI for Feedeas - AI-native video creation tool").version("0.1.0-alpha.9");
+program.name("feedeas").description("CLI for Feedeas - AI-native video creation tool").version("0.1.0-alpha.18");
 program.hook("preAction", (_thisCommand, actionCommand) => {
   commandStartTimes.set(actionCommand, Date.now());
   telemetry.trackCommandStarted(actionCommand);
@@ -3906,57 +5284,49 @@ program.hook("postAction", (_thisCommand, actionCommand) => {
   const startedAt = commandStartTimes.get(actionCommand) || Date.now();
   telemetry.trackCommandFinished(actionCommand, "success", Date.now() - startedAt);
 });
-program.command("edit [path]").alias("start").alias("init").description("Start the Feedeas editor server. Accepts a directory or scene file path.").option("-p, --port <number>", "Port to run on", "3331").option("--no-open", "Do not open browser").action(async (pathArg, options) => {
+program.command("edit").alias("start").alias("init").description("Start the Feedeas editor server for a project/scene.").option("-p, --port <number>", "Port to run on", "3331").option("--project-id <id>", "Project ID to open").option("--scene-id <id>", "Scene ID to open").option("--no-open", "Do not open browser").action(async (options) => {
   const port = parseInt(options.port);
-  let sceneFile;
-  if (pathArg) {
-    const targetPath = path18.resolve(process.cwd(), pathArg);
-    if (fs17.existsSync(targetPath)) {
-      const stats = fs17.statSync(targetPath);
-      if (stats.isFile()) {
-        sceneFile = path18.basename(targetPath);
-        const dir = path18.dirname(targetPath);
-        process.chdir(dir);
-        console.log(`Opening scene file: ${sceneFile}`);
-      } else if (stats.isDirectory()) {
-        process.chdir(targetPath);
-      }
-    } else {
-      if (pathArg.endsWith(".json")) {
-        sceneFile = path18.basename(pathArg);
-        const dir = path18.dirname(path18.resolve(process.cwd(), pathArg));
-        if (!fs17.existsSync(dir)) {
-          console.log(`Creating directory ${dir}...`);
-          fs17.mkdirSync(dir, { recursive: true });
-        }
-        process.chdir(dir);
-        console.log(`Will create new scene file: ${sceneFile}`);
-      } else {
-        console.log(`Creating directory ${targetPath}...`);
-        fs17.mkdirSync(targetPath, { recursive: true });
-        process.chdir(targetPath);
-      }
+  const projectId = options.projectId ? resolveProjectId(options.projectId) : (() => {
+    try {
+      return resolveProjectId();
+    } catch {
+      return void 0;
     }
-  }
+  })();
+  const sceneId = options.sceneId ? resolveSceneId(options.sceneId) : (() => {
+    try {
+      return resolveSceneId();
+    } catch {
+      return void 0;
+    }
+  })();
   const cwd = process.cwd();
   console.log(`Starting Feedeas in ${cwd}...`);
-  let staticRoot = path18.resolve(__dirname5, "../../dist/ui");
-  if (!fs17.existsSync(staticRoot)) {
-    staticRoot = path18.resolve(__dirname5, "../ui");
+  let staticRoot = path21.resolve(__dirname5, "../../dist/ui");
+  if (!fs21.existsSync(staticRoot)) {
+    staticRoot = path21.resolve(__dirname5, "../ui");
   }
-  if (!fs17.existsSync(staticRoot)) {
+  if (!fs21.existsSync(staticRoot)) {
     console.warn(`Warning: UI assets not found at ${staticRoot}. Did you run 'bun run build'?`);
   }
   const app2 = createServer(staticRoot);
   startServer(app2, port);
-  const url = `http://localhost:${port}`;
+  const params = new URLSearchParams();
+  if (projectId) params.set("projectId", String(projectId));
+  if (sceneId) params.set("sceneId", String(sceneId));
+  const url = `http://localhost:${port}/editor${params.toString() ? `?${params.toString()}` : ""}`;
   console.log(`Server running at ${url}`);
   if (options.open) {
     await open2(url);
   }
+  if (projectId || sceneId) {
+    writeFlowState({ projectId, sceneId });
+  }
 });
-program.command("snap").alias("screenshot").description("Take a snapshot of the canvas at a specific time").argument("<time>", "Time in seconds").option("-o, --output <path>", "Output file path", "snapshot.png").option("-u, --url <url>", "URL of the running server", "http://localhost:3331").option("-W, --width <number>", "Viewport width", "1080").option("-H, --height <number>", "Viewport height", "1350").action(async (time, options) => {
+program.command("snap").alias("screenshot").description("Take a snapshot of the canvas at a specific time").argument("<time>", "Time in seconds").option("-o, --output <path>", "Output file path", "snapshot.png").option("-u, --url <url>", "URL of the running server", "http://localhost:3331").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").option("-W, --width <number>", "Viewport width", "1080").option("-H, --height <number>", "Viewport height", "1350").action(async (time, options) => {
   console.log(`Taking snapshot at ${time}s...`);
+  const projectId = resolveProjectId(options.projectId);
+  const sceneId = resolveSceneId(options.sceneId);
   try {
     const { chromium: chromium2 } = await import("playwright-core");
     let browser;
@@ -3985,7 +5355,7 @@ program.command("snap").alias("screenshot").description("Take a snapshot of the
     const width = parseInt(options.width);
     const height = parseInt(options.height);
     await page.setViewportSize({ width, height });
-    const targetUrl = `${options.url}?time=${time}&mode=render`;
+    const targetUrl = `${options.url}?time=${time}&mode=render&projectId=${encodeURIComponent(projectId)}&sceneId=${encodeURIComponent(sceneId)}`;
     console.log(`Navigating to ${targetUrl}...`);
     await page.goto(targetUrl);
     try {
@@ -3999,6 +5369,7 @@ program.command("snap").alias("screenshot").description("Take a snapshot of the
     const file = options.output;
     await page.locator("canvas").first().screenshot({ path: file });
     console.log(`Snapshot saved to ${file}`);
+    writeFlowState({ projectId, sceneId });
     await browser.close();
   } catch (e) {
     console.error("Failed to take snapshot:", e.message);
@@ -4019,16 +5390,18 @@ program.addCommand(createSceneCommand);
 program.addCommand(addEntityCommand);
 program.addCommand(tasteCommand);
 program.addCommand(createFeedbackCommand(telemetry));
+program.addCommand(projectCommand);
+program.addCommand(sceneCommand);
 program.addHelpText("after", `
 
 Agent tip:
   feedeas feedback "<what to improve>"
 
 Quick Start (30 seconds):
-  1. feedeas example basic > scene.json    # Create a scene template
-  2. feedeas validate scene.json           # Verify it's valid
-  3. feedeas edit                          # Open interactive editor, or...
-  4. feedeas record --project scene.json   # Render video directly
+  1. feedeas project create --name "My Project" > project.json
+  2. feedeas scene list --project-id <projectId>
+  3. feedeas edit --project-id <projectId> --scene-id <sceneId>
+  4. feedeas record --project-id <projectId> --scene-id <sceneId>   # Render video directly
 
 Guided Flow (Agent-Friendly, End-to-End):
   1. mkdir -p my-reel && cd my-reel
@@ -4053,8 +5426,8 @@ Agent Conversation Example:
   Agent (tool): feedeas audio "Life changes in small daily choices. A morning ritual of mindfulness can set the tone for your day..." -o narration.mp3 --no-transcribe
   Agent: Now I'll generate some visuals to match the narration.
   Agent (tool): feedeas example documentary > scene.json
-  Agent (tool): feedeas imagine "warm cinematic kitchen morning..." --aspect-ratio 9:16 -o scene1.png
-  Agent (tool): feedeas imagine "A person meditating in a park..." --aspect-ratio 9:16 -o scene2.png
+  Agent (tool): feedeas imagine "A peaceful sunrise over a mountain lake, cinematic lighting" --aspect-ratio 9:16 -o scene1.png
+  Agent (tool): feedeas imagine "A person meditating in a park, soft morning light" --aspect-ratio 9:16 -o scene2.png
   Agent (tool): feedeas audio "Life changes in small daily choices..." -o narration.mp3 --no-transcribe
   Agent (tool): feedeas bgm "soft reflective ambient, no vocals..." -d 25 -o bgm.mp3
   Agent: Now I\u2019ll wire assets into scene.json with src values under assets/.
@@ -4113,7 +5486,7 @@ Transition Types:
 
 Project Structure:
   your-project/
-  \u251C\u2500\u2500 scene_1.json          # Scene definition (required)
+  \u251C\u2500\u2500 .feedeas/             # Project + scene resource storage (default file backend)
   \u251C\u2500\u2500 assets/               # Asset folder (images, audio)
   \u2502   \u251C\u2500\u2500 image.jpg
   \u2502   \u251C\u2500\u2500 music.mp3
@@ -4126,14 +5499,14 @@ Programmatic Workflow (for Agents):
   $ feedeas audio "narration text" -o assets/voice.mp3   # Generate audio
   $ feedeas bgm "cinematic bgm, no vocals" -o assets/bgm.mp3
   $ feedeas example documentary            # See a complete example
-  $ feedeas set-scene my.json --content '{...}'  # Create scene
-  $ feedeas validate my.json               # Validate before rendering
+  $ feedeas set-scene --project-id <pid> --scene-id <sid> --content '{...}'
+  $ feedeas validate --project-id <pid> --scene-id <sid>   # Validate before rendering
   $ feedeas edit --no-open &               # Start server in background
-  $ feedeas record --project my.json       # Render to video
+  $ feedeas record --project-id <pid> --scene-id <sid>       # Render to video
 
 Interactive Workflow (for Humans):
-  $ feedeas edit .                         # Start editor in current dir
-  $ feedeas snap 2.5 -o frame.png          # Take snapshot at 2.5s
+  $ feedeas edit --project-id <pid> --scene-id <sid>   # Start editor
+  $ feedeas snap 2.5 --project-id <pid> --scene-id <sid> -o frame.png
 
 Taste Workflow:
   $ feedeas taste                          # Start UI Workspace