feedeas 0.1.0-alpha.13 → 0.1.0-alpha.15

package/dist/cli/index.js

@@ -19,7 +19,7 @@ var playwright_installer_exports = {};
 __export(playwright_installer_exports, {
   ensurePlaywrightBrowsers: () => ensurePlaywrightBrowsers
 });
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { createInterface } from "readline";
 async function ensurePlaywrightBrowsers() {
   try {
@@ -71,7 +71,7 @@ function promptUser(question) {
 }
 function installPlaywrightBrowsers() {
   return new Promise((resolve) => {
-    const child = spawn2("npx", ["playwright", "install", "chromium", "--with-deps"], {
+    const child = spawn3("npx", ["playwright", "install", "chromium", "--with-deps"], {
       stdio: "inherit",
       // Show installation progress to user
       shell: true
@@ -97,10 +97,10 @@ import { Command as Command14 } from "commander";
 // src/cli/commands/record.ts
 import { Command } from "commander";
 import { chromium } from "playwright-core";
-import { spawn as spawn3, spawnSync } from "child_process";
-import fs4 from "fs";
-import path4 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { spawn as spawn4, spawnSync } from "child_process";
+import fs5 from "fs";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/services/ffprobe.ts
 import { spawn } from "child_process";
@@ -256,9 +256,92 @@ import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
 import { join, dirname } 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 { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+async function runCliCommand(args, cwd) {
+  const isCompiled = __filename.endsWith(".js");
+  let command;
+  let spawnArgs;
+  if (isCompiled) {
+    const binPath = path2.resolve(__dirname, "../../../bin/feedeas.js");
+    if (!fs2.existsSync(binPath)) {
+      throw new Error(`Could not find compiled CLI binary at ${binPath}`);
+    }
+    command = "node";
+    spawnArgs = [binPath, ...args];
+  } else {
+    const srcPath = path2.resolve(__dirname, "../index.ts");
+    command = "bun";
+    spawnArgs = ["run", srcPath, ...args];
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, spawnArgs, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        FORCE_COLOR: "0"
+        // Disable colored output for easier JSON parsing
+      }
+    });
+    let stdoutData = "";
+    let stderrData = "";
+    child.stdout.on("data", (chunk) => {
+      stdoutData += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrData += chunk.toString();
+    });
+    child.on("close", (code) => {
+      let parsedJson = null;
+      try {
+        const lines = stdoutData.split("\n");
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i].trim();
+          if (line.startsWith("{") || line.startsWith("[")) {
+            try {
+              parsedJson = JSON.parse(line);
+              break;
+            } catch {
+              const block = lines.slice(i).join("\n");
+              try {
+                parsedJson = JSON.parse(block);
+                break;
+              } catch {
+              }
+            }
+          }
+        }
+      } catch (e) {
+      }
+      if (code === 0) {
+        if (parsedJson) {
+          resolve(parsedJson);
+        } else {
+          resolve({ rawOutput: stdoutData.trim() });
+        }
+      } else {
+        if (parsedJson && parsedJson.error) {
+          reject(new Error(parsedJson.error));
+        } else {
+          reject(new Error(`CLI command failed with code ${code}:
+${stderrData || stdoutData}`));
+        }
+      }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn CLI process: ${err.message}`));
+    });
+  });
+}
+
 // src/cli/services/taste.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 var DEFAULT_TASTE_FILE_CONTENT = `# Taste File v1
 ## Brand Identity
 Describe brand voice, tone, and core promise.
@@ -332,28 +415,16 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
 ]);
 function safeResolveFromCwd(relativePath) {
   const cwd = process.cwd();
-  const normalized = path2.normalize(relativePath);
+  const normalized = path3.normalize(relativePath);
   if (normalized.includes("..")) {
     throw new Error("Invalid path");
   }
-  const fullPath = path2.resolve(cwd, normalized);
-  if (fullPath !== cwd && !fullPath.startsWith(`${cwd}${path2.sep}`)) {
+  const fullPath = path3.resolve(cwd, normalized);
+  if (fullPath !== cwd && !fullPath.startsWith(`${cwd}${path3.sep}`)) {
     throw new Error("Invalid path");
   }
   return fullPath;
 }
-function ensureTasteWorkspaceFiles(tasteFilePath, memoryFilePath) {
-  const tasteFull = safeResolveFromCwd(tasteFilePath);
-  const memoryFull = safeResolveFromCwd(memoryFilePath);
-  fs2.mkdirSync(path2.dirname(tasteFull), { recursive: true });
-  fs2.mkdirSync(path2.dirname(memoryFull), { recursive: true });
-  if (!fs2.existsSync(tasteFull)) {
-    fs2.writeFileSync(tasteFull, DEFAULT_TASTE_FILE_CONTENT, "utf-8");
-  }
-  if (!fs2.existsSync(memoryFull)) {
-    fs2.writeFileSync(memoryFull, DEFAULT_MEMORY_FILE_CONTENT, "utf-8");
-  }
-}
 function parseListValue(value) {
   const trimmed = value.trim();
   if (!trimmed) return [];
@@ -414,7 +485,10 @@ function parseTasteMemoryMarkdown(markdown) {
       tags: parseListValue(map.tags || ""),
       freshnessTerms: parseListValue(map.freshness_terms || ""),
       summary: map.summary || "",
-      content: map.content || ""
+      content: map.content || "",
+      status: map.status || void 0,
+      reasonTags: parseListValue(map.reason_tags || ""),
+      notes: map.notes || ""
     });
   }
   return entries;
@@ -432,30 +506,21 @@ function formatMemoryEntry(entry, id) {
     `tags: [${(entry.tags || []).join(", ")}]`,
     `freshness_terms: [${(entry.freshnessTerms || []).join(", ")}]`,
     `summary: ${entry.summary || ""}`,
+    ...entry.status ? [`status: ${entry.status}`] : [],
+    ...entry.reasonTags && entry.reasonTags.length ? [`reason_tags: [${entry.reasonTags.join(", ")}]`] : [],
+    ...entry.notes ? [`notes: ${entry.notes}`] : [],
     "content: |",
     contentLines || "  ",
     "```",
     ""
   ].join("\n");
 }
-function appendMemoryEntries(markdown, ideas) {
-  const base = markdown.trim().length > 0 ? markdown.trimEnd() : DEFAULT_MEMORY_FILE_CONTENT.trimEnd();
-  const appendedIds = [];
-  let output = `${base}
-
-`;
-  for (const idea of ideas) {
-    const id = `mem_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}_${Math.floor(Math.random() * 900 + 100)}_${appendedIds.length + 1}`;
-    appendedIds.push(id);
-    output += formatMemoryEntry(idea, id);
-  }
-  return { markdown: output, appendedIds };
-}
 function queryMemoryItems(items, options) {
   const limit = Math.max(1, options.limit ?? 20);
   const sinceDate = options.since ? new Date(options.since) : null;
   const text = options.text?.toLowerCase().trim();
   const tag = options.tag?.toLowerCase().trim();
+  const status = options.status?.toLowerCase().trim();
   return items.filter((item) => {
     if (sinceDate && !Number.isNaN(sinceDate.getTime())) {
       const createdAt = new Date(item.createdAt);
@@ -464,6 +529,9 @@ function queryMemoryItems(items, options) {
     if (tag && !item.tags.map((t) => t.toLowerCase()).includes(tag)) {
       return false;
     }
+    if (status && (item.status || "").toLowerCase() !== status) {
+      return false;
+    }
     if (text) {
       const hay = `${item.title}
 ${item.summary}
@@ -473,6 +541,71 @@ ${item.content}`.toLowerCase();
     return true;
   }).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
 }
+function upsertFeedbackSection(tasteContent, sectionContent) {
+  const start = "<!-- taste-feedback:start -->";
+  const end = "<!-- taste-feedback:end -->";
+  const block = `${start}
+${sectionContent.trim()}
+${end}`;
+  const hasStart = tasteContent.includes(start);
+  const hasEnd = tasteContent.includes(end);
+  if (hasStart && hasEnd) {
+    return tasteContent.replace(new RegExp(`${start}[\\s\\S]*?${end}`, "m"), block);
+  }
+  const trimmed = tasteContent.trimEnd();
+  return `${trimmed}
+
+${block}
+`;
+}
+function buildTasteSuggestionFromMemory(tasteContent, memories) {
+  const recent = [...memories].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, 50);
+  const acceptedTags = /* @__PURE__ */ new Map();
+  const rejectedReasons = /* @__PURE__ */ new Map();
+  for (const item of recent) {
+    const status = (item.status || "").toLowerCase();
+    if (status === "accepted") {
+      for (const tag of item.tags) {
+        acceptedTags.set(tag, (acceptedTags.get(tag) || 0) + 1);
+      }
+    }
+    if (status === "rejected") {
+      const reasons = item.reasonTags && item.reasonTags.length > 0 ? item.reasonTags : item.tags;
+      for (const reason of reasons) {
+        rejectedReasons.set(reason, (rejectedReasons.get(reason) || 0) + 1);
+      }
+    }
+  }
+  const topAccepted = [...acceptedTags.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([name]) => name);
+  const topRejected = [...rejectedReasons.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([name]) => name);
+  const sectionLines = [
+    "## Feedback Signals",
+    ...topAccepted.length ? [`- Prioritize these themes: ${topAccepted.join(", ")}`] : ["- Prioritize themes with proven audience resonance from recent accepted ideas."],
+    ...topRejected.length ? [`- Avoid these recurring issues: ${topRejected.join(", ")}`] : ["- Avoid repeating patterns that were consistently rejected."],
+    "- Keep hooks specific and concrete, not generic."
+  ];
+  const proposedTasteContent = upsertFeedbackSection(tasteContent, sectionLines.join("\n"));
+  const patch = [
+    "--- taste/taste.md",
+    "+++ taste/taste.md",
+    "@@",
+    `+ ${sectionLines[0]}`,
+    `+ ${sectionLines[1]}`,
+    `+ ${sectionLines[2]}`,
+    `+ ${sectionLines[3]}`
+  ].join("\n");
+  return {
+    title: "Feedback-driven taste refinement",
+    summary: "Update taste profile with recurring accepted/rejected memory patterns.",
+    rationale: [
+      `Analyzed ${recent.length} recent memory entries.`,
+      topAccepted.length ? `Accepted patterns concentrated around: ${topAccepted.join(", ")}.` : "No strong accepted-tag pattern found; using generic prioritization guidance.",
+      topRejected.length ? `Rejected patterns concentrated around: ${topRejected.join(", ")}.` : "No strong rejected-tag pattern found; using generic avoidance guidance."
+    ].join("\n"),
+    patch,
+    proposedTasteContent
+  };
+}
 function tokenize(input) {
   return new Set(
     input.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).map((word) => word.trim()).filter((word) => word.length > 3 && !STOP_WORDS.has(word))
@@ -667,9 +800,298 @@ async function simulateIdeas(params) {
   };
 }
 
+// src/cli/services/taste-store.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import { createHash } from "node:crypto";
+var DEFAULT_SUGGESTIONS_FILE_CONTENT = "# Taste Suggestions v1\n";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function buildId(prefix) {
+  return `${prefix}_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}_${Math.floor(Math.random() * 9e5 + 1e5)}`;
+}
+function formatMultilineField(name, value) {
+  const lines = (value || "").split("\n");
+  return [
+    `${name}: |`,
+    ...(lines.length ? lines : [""]).map((line) => `  ${line}`)
+  ];
+}
+function parseSuggestionMarkdown(markdown) {
+  const blockRegex = /```taste-suggestion\s*([\s\S]*?)```/g;
+  const entries = [];
+  let match;
+  while ((match = blockRegex.exec(markdown)) !== null) {
+    const block = match[1].trim();
+    const lines = block.split("\n");
+    const map = {};
+    let idx = 0;
+    while (idx < lines.length) {
+      const line = lines[idx];
+      const keyMatch = line.match(/^([a-z_]+):\s*(.*)$/i);
+      if (!keyMatch) {
+        idx += 1;
+        continue;
+      }
+      const key = keyMatch[1];
+      const value = keyMatch[2] ?? "";
+      if ((key === "rationale" || key === "patch" || key === "proposed_taste_content") && value.trim() === "|") {
+        const contentLines = [];
+        idx += 1;
+        while (idx < lines.length) {
+          const contentLine = lines[idx];
+          if (contentLine.startsWith("  ")) {
+            contentLines.push(contentLine.slice(2));
+            idx += 1;
+            continue;
+          }
+          if (contentLine.trim() === "") {
+            contentLines.push("");
+            idx += 1;
+            continue;
+          }
+          break;
+        }
+        map[key] = contentLines.join("\n").trimEnd();
+        continue;
+      }
+      map[key] = value.trim();
+      idx += 1;
+    }
+    if (!map.id || !map.created_at || !map.title) {
+      continue;
+    }
+    const status = map.status || "pending";
+    entries.push({
+      id: map.id,
+      createdAt: map.created_at,
+      status: status === "applied" || status === "rejected" ? status : "pending",
+      title: map.title,
+      summary: map.summary || "",
+      rationale: map.rationale || "",
+      patch: map.patch || "",
+      proposedTasteContent: map.proposed_taste_content || "",
+      baseVersion: map.base_version || void 0,
+      appliedAt: map.applied_at || void 0,
+      rejectedAt: map.rejected_at || void 0,
+      reviewNote: map.review_note || void 0
+    });
+  }
+  return entries;
+}
+function formatSuggestionEntry(entry) {
+  const output = [
+    "```taste-suggestion",
+    `id: ${entry.id}`,
+    `created_at: ${entry.createdAt}`,
+    `status: ${entry.status}`,
+    `title: ${entry.title}`,
+    `summary: ${entry.summary || ""}`,
+    ...entry.baseVersion ? [`base_version: ${entry.baseVersion}`] : [],
+    ...formatMultilineField("rationale", entry.rationale),
+    ...formatMultilineField("patch", entry.patch),
+    ...formatMultilineField("proposed_taste_content", entry.proposedTasteContent),
+    ...entry.appliedAt ? [`applied_at: ${entry.appliedAt}`] : [],
+    ...entry.rejectedAt ? [`rejected_at: ${entry.rejectedAt}`] : [],
+    ...entry.reviewNote ? [`review_note: ${entry.reviewNote}`] : [],
+    "```",
+    ""
+  ];
+  return output.join("\n");
+}
+function formatSuggestionsMarkdown(entries) {
+  const base = DEFAULT_SUGGESTIONS_FILE_CONTENT.trimEnd();
+  if (entries.length === 0) {
+    return `${base}
+`;
+  }
+  const blocks = entries.map((entry) => formatSuggestionEntry(entry)).join("");
+  return `${base}
+
+${blocks}`;
+}
+var MarkdownTasteStore = class {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  backend = "markdown";
+  resolveAll() {
+    return {
+      tastePath: safeResolveFromCwd(this.paths.tasteFilePath),
+      memoryPath: safeResolveFromCwd(this.paths.memoryFilePath),
+      suggestionsPath: safeResolveFromCwd(this.paths.suggestionsFilePath)
+    };
+  }
+  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");
+    }
+    if (!fs3.existsSync(memoryPath)) {
+      fs3.writeFileSync(memoryPath, DEFAULT_MEMORY_FILE_CONTENT, "utf-8");
+    }
+    if (!fs3.existsSync(suggestionsPath)) {
+      fs3.writeFileSync(suggestionsPath, DEFAULT_SUGGESTIONS_FILE_CONTENT, "utf-8");
+    }
+  }
+  async readTaste() {
+    await this.ensureWorkspace();
+    const { tastePath } = this.resolveAll();
+    const content = fs3.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 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) };
+  }
+  async appendMemory(entry) {
+    await this.ensureWorkspace();
+    const { memoryPath } = this.resolveAll();
+    const current = fs3.existsSync(memoryPath) ? fs3.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");
+    const parsed = parseTasteMemoryMarkdown(markdown).find((item) => item.id === id);
+    if (!parsed) {
+      throw new Error("Failed to append memory entry");
+    }
+    return parsed;
+  }
+  async queryMemory(options) {
+    await this.ensureWorkspace();
+    const { memoryPath } = this.resolveAll();
+    const content = fs3.existsSync(memoryPath) ? fs3.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 entry = {
+      id: buildId("sug"),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending",
+      title: suggestion.title,
+      summary: suggestion.summary,
+      rationale: suggestion.rationale,
+      patch: suggestion.patch,
+      proposedTasteContent: suggestion.proposedTasteContent,
+      baseVersion: suggestion.baseVersion,
+      appliedAt: void 0,
+      rejectedAt: void 0,
+      reviewNote: void 0
+    };
+    const existing = parseSuggestionMarkdown(current);
+    const markdown = formatSuggestionsMarkdown([...existing, entry]);
+    fs3.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 entries = parseSuggestionMarkdown(current).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (!status) {
+      return entries;
+    }
+    return entries.filter((item) => item.status === status);
+  }
+  async updateSuggestionStatus(id, status, metadata) {
+    await this.ensureWorkspace();
+    const { suggestionsPath } = this.resolveAll();
+    const current = fs3.existsSync(suggestionsPath) ? fs3.readFileSync(suggestionsPath, "utf-8") : "";
+    const entries = parseSuggestionMarkdown(current);
+    const idx = entries.findIndex((entry) => entry.id === id);
+    if (idx === -1) {
+      throw new Error(`Suggestion not found: ${id}`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...entries[idx],
+      status,
+      appliedAt: status === "applied" ? metadata?.appliedAt || now : void 0,
+      rejectedAt: status === "rejected" ? metadata?.rejectedAt || now : void 0,
+      reviewNote: metadata?.reviewNote
+    };
+    entries[idx] = updated;
+    fs3.writeFileSync(suggestionsPath, formatSuggestionsMarkdown(entries), "utf-8");
+    return updated;
+  }
+};
+var DbTasteStore = class {
+  backend = "db";
+  constructor(_) {
+  }
+  async ensureWorkspace() {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async readTaste() {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async writeTaste(_, __) {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async appendMemory(_) {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async queryMemory(_) {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async appendSuggestion(_) {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async listSuggestions(_) {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+  async updateSuggestionStatus(_, __, ___) {
+    throw new Error("DB backend is not implemented yet. Use --storage markdown.");
+  }
+};
+function normalizeStorageBackend(value) {
+  const lower = (value || process.env.TASTE_STORAGE_BACKEND || "markdown").toLowerCase();
+  if (lower === "db") {
+    return "db";
+  }
+  return "markdown";
+}
+function createTasteStore(params) {
+  const backend = normalizeStorageBackend(params.backend);
+  const paths = {
+    tasteFilePath: params.tasteFilePath,
+    memoryFilePath: params.memoryFilePath,
+    suggestionsFilePath: params.suggestionsFilePath
+  };
+  if (backend === "db") {
+    return new DbTasteStore(paths);
+  }
+  return new MarkdownTasteStore(paths);
+}
+
 // src/cli/server/api.ts
 var api = new Hono();
 var resolveSafePath = (relativePath) => safeResolveFromCwd(relativePath);
+function createStoreFromBody(body) {
+  return createTasteStore({
+    backend: body.storage ? String(body.storage) : void 0,
+    tasteFilePath: body.tasteFilePath ? String(body.tasteFilePath) : "taste/taste.md",
+    memoryFilePath: body.memoryFilePath ? String(body.memoryFilePath) : "taste/memory.md",
+    suggestionsFilePath: body.suggestionsFilePath ? String(body.suggestionsFilePath) : "taste/suggestions.md"
+  });
+}
 api.get("/fs/list", async (c) => {
   const cwd = process.cwd();
   try {
@@ -678,7 +1100,6 @@ api.get("/fs/list", async (c) => {
       name: f.name,
       isDirectory: f.isDirectory(),
       size: 0
-      // Simplification for now
     }));
     return c.json({ path: cwd, files: result });
   } catch (e) {
@@ -686,35 +1107,35 @@ api.get("/fs/list", async (c) => {
   }
 });
 api.get("/fs/read", async (c) => {
-  const path17 = c.req.query("path");
-  if (!path17) return c.json({ error: "Path required" }, 400);
+  const path19 = c.req.query("path");
+  if (!path19) return c.json({ error: "Path required" }, 400);
   try {
-    const fullPath = resolveSafePath(path17);
+    const fullPath = resolveSafePath(path19);
     const content = await readFile(fullPath, "utf-8");
-    if (path17.endsWith(".json")) {
+    if (path19.endsWith(".json")) {
       try {
         const json = JSON.parse(content);
         if (json.meta && Array.isArray(json.entities)) {
-          console.debug(`[API] Resolving scene: ${path17}`);
+          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 ${path17}:`, e.message);
+        console.error(`[API] Scene resolution failed for ${path19}:`, e.message);
       }
     }
     return c.json({ content });
   } catch (e) {
-    console.error(`[API] Error reading file ${path17}:`, e.message, e.stack);
+    console.error(`[API] Error reading file ${path19}:`, e.message, e.stack);
     return c.json({ error: e.message }, 500);
   }
 });
 api.post("/fs/write", async (c) => {
   const body = await c.req.json();
-  const { path: path17, content } = body;
-  if (!path17 || content === void 0) return c.json({ error: "Path and content required" }, 400);
+  const { path: path19, content } = body;
+  if (!path19 || content === void 0) return c.json({ error: "Path and content required" }, 400);
   try {
-    const fullPath = resolveSafePath(path17);
+    const fullPath = resolveSafePath(path19);
     const dir = dirname(fullPath);
     if (!existsSync(dir)) {
       await mkdir(dir, { recursive: true });
@@ -728,7 +1149,7 @@ api.post("/fs/write", async (c) => {
 api.post("/fs/upload", async (c) => {
   try {
     const body = await c.req.parseBody();
-    const file = body["file"];
+    const file = body.file;
     if (!file || !(file instanceof File)) {
       return c.json({ error: "File required" }, 400);
     }
@@ -736,7 +1157,7 @@ api.post("/fs/upload", async (c) => {
     if (!existsSync(assetsDir)) {
       await mkdir(assetsDir, { recursive: true });
     }
-    const fileName = body["name"] || file.name;
+    const fileName = body.name || file.name;
     const filePath = join(assetsDir, fileName);
     const bytes = Buffer.from(await file.arrayBuffer());
     await writeFile(filePath, bytes);
@@ -744,7 +1165,6 @@ api.post("/fs/upload", async (c) => {
       success: true,
       path: `assets/${fileName}`,
       url: `/api/fs/assets/assets/${fileName}`
-      // Adjust URL based on routing
     });
   } catch (e) {
     console.error(e);
@@ -752,10 +1172,10 @@ api.post("/fs/upload", async (c) => {
   }
 });
 api.get("/fs/assets/*", async (c) => {
-  const path17 = c.req.path;
+  const reqPath = c.req.path;
   const marker = "/fs/assets/";
-  const index = path17.lastIndexOf(marker);
-  const relativePath = path17.substring(index + marker.length);
+  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);
@@ -773,22 +1193,21 @@ api.get("/fs/assets/*", async (c) => {
       return c.json({ error: "Invalid path" }, 403);
     }
   }
-  console.log(`[Asset Server] Request: ${c.req.path} -> Resolved: ${fullPath} (exists: ${existsSync(fullPath)})`);
   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"
+    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 {
@@ -808,18 +1227,17 @@ api.post("/taste/chat", async (c) => {
   try {
     const body = await c.req.json();
     const message = String(body.message || "").trim();
-    const tasteFilePath = String(body.tasteFilePath || "taste/taste.md");
-    const memoryFilePath = String(body.memoryFilePath || "taste/memory.md");
     const model = body.model ? String(body.model) : void 0;
     const apiKey = body.apiKey || process.env.GEMINI_API_KEY;
     if (!message) return c.json({ error: "message is required" }, 400);
     if (!apiKey) return c.json({ error: "Missing GEMINI_API_KEY" }, 400);
-    const tasteContent = body.tasteContent ? String(body.tasteContent) : await readFile(resolveSafePath(tasteFilePath), "utf-8");
-    const memoryContent = body.memoryContent ? String(body.memoryContent) : await readFile(resolveSafePath(memoryFilePath), "utf-8");
-    const memories = parseTasteMemoryMarkdown(memoryContent);
+    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 runTasteChat({
       message,
-      tasteContent,
+      tasteContent: body.tasteContent ? String(body.tasteContent) : taste.content,
       memories,
       apiKey: String(apiKey),
       model
@@ -832,20 +1250,18 @@ api.post("/taste/chat", async (c) => {
 api.post("/taste/simulate", async (c) => {
   try {
     const body = await c.req.json();
-    const tasteFilePath = String(body.tasteFilePath || "taste/taste.md");
-    const memoryFilePath = String(body.memoryFilePath || "taste/memory.md");
     const mode = body.mode === "parallel" ? "parallel" : "sequential";
     const count = Math.max(1, Number(body.count || 1));
     const saveToMemory = Boolean(body.saveToMemory);
     const model = body.model ? String(body.model) : void 0;
     const apiKey = body.apiKey || process.env.GEMINI_API_KEY;
     if (!apiKey) return c.json({ error: "Missing GEMINI_API_KEY" }, 400);
-    const tasteContent = body.tasteContent ? String(body.tasteContent) : await readFile(resolveSafePath(tasteFilePath), "utf-8");
-    const memoryPath = resolveSafePath(memoryFilePath);
-    const memoryContent = body.memoryContent ? String(body.memoryContent) : await readFile(memoryPath, "utf-8");
-    const memories = parseTasteMemoryMarkdown(memoryContent);
+    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 simulateIdeas({
-      tasteContent,
+      tasteContent: body.tasteContent ? String(body.tasteContent) : taste.content,
       memories,
       count,
       mode,
@@ -854,27 +1270,114 @@ api.post("/taste/simulate", async (c) => {
     });
     let appendedIds = [];
     if (saveToMemory && result.ideas.length > 0) {
-      const appended = appendMemoryEntries(memoryContent, result.ideas);
-      appendedIds = appended.appendedIds;
-      await writeFile(memoryPath, appended.markdown, "utf-8");
+      for (const idea of result.ideas) {
+        const saved = await store.appendMemory({ ...idea, status: "generated" });
+        appendedIds.push(saved.id);
+      }
     }
     return c.json({ ...result, appendedIds });
   } catch (e) {
     return c.json({ error: e.message }, 500);
   }
 });
-api.post("/taste/memory/append", async (c) => {
+api.post("/taste/feedback", async (c) => {
+  try {
+    const body = await c.req.json();
+    const decision = String(body.decision || "").toLowerCase();
+    if (decision !== "accepted" && decision !== "rejected") {
+      return c.json({ error: "decision must be accepted or rejected" }, 400);
+    }
+    if (!body.title) {
+      return c.json({ error: "title is required" }, 400);
+    }
+    const store = createStoreFromBody(body);
+    await store.ensureWorkspace();
+    const item = {
+      id: body.ideaId ? String(body.ideaId) : void 0,
+      title: String(body.title),
+      format: body.format ? String(body.format) : "daily-reel",
+      tags: Array.isArray(body.tags) ? body.tags.map((x) => String(x)) : [],
+      freshnessTerms: [],
+      summary: body.summary ? String(body.summary) : "",
+      content: body.content ? String(body.content) : "",
+      status: decision,
+      reasonTags: Array.isArray(body.reasonTags) ? body.reasonTags.map((x) => String(x)) : [],
+      notes: body.notes ? String(body.notes) : ""
+    };
+    const saved = await store.appendMemory(item);
+    return c.json({ item: saved });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/taste/suggest", async (c) => {
   try {
     const body = await c.req.json();
-    const memoryFilePath = String(body.memoryFilePath || "taste/memory.md");
-    const entries = Array.isArray(body.entries) ? body.entries : [];
-    if (!entries.length) return c.json({ error: "entries are required" }, 400);
-    const fullPath = resolveSafePath(memoryFilePath);
-    const current = existsSync(fullPath) ? await readFile(fullPath, "utf-8") : "";
-    const appended = appendMemoryEntries(current, entries);
-    await mkdir(dirname(fullPath), { recursive: true });
-    await writeFile(fullPath, appended.markdown, "utf-8");
-    return c.json({ appendedIds: appended.appendedIds });
+    const memoryWindow = Math.max(1, Number(body.memoryWindow || 50));
+    const store = createStoreFromBody(body);
+    await store.ensureWorkspace();
+    const taste = await store.readTaste();
+    const memories = await store.queryMemory({ limit: memoryWindow });
+    const draft = buildTasteSuggestionFromMemory(taste.content, memories);
+    const suggestion = await store.appendSuggestion({
+      title: draft.title,
+      summary: draft.summary,
+      rationale: draft.rationale,
+      patch: draft.patch,
+      proposedTasteContent: draft.proposedTasteContent,
+      baseVersion: taste.version
+    });
+    return c.json({ suggestion });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/taste/suggestions/list", async (c) => {
+  try {
+    const body = await c.req.json();
+    const store = createStoreFromBody(body);
+    await store.ensureWorkspace();
+    const status = body.status ? String(body.status) : void 0;
+    const suggestions = await store.listSuggestions(
+      status === "pending" || status === "applied" || status === "rejected" ? status : void 0
+    );
+    return c.json({ suggestions });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/taste/apply", async (c) => {
+  try {
+    const body = await c.req.json();
+    const suggestionId = String(body.suggestionId || "").trim();
+    const rejectOnly = Boolean(body.reject);
+    if (!suggestionId) {
+      return c.json({ error: "suggestionId is required" }, 400);
+    }
+    const store = createStoreFromBody(body);
+    await store.ensureWorkspace();
+    const all = await store.listSuggestions();
+    const target = all.find((entry) => entry.id === suggestionId);
+    if (!target) {
+      return c.json({ error: `Suggestion not found: ${suggestionId}` }, 404);
+    }
+    if (target.status !== "pending") {
+      return c.json({ error: `Suggestion ${target.id} is already ${target.status}` }, 400);
+    }
+    if (rejectOnly) {
+      const suggestion2 = await store.updateSuggestionStatus(target.id, "rejected", {
+        reviewNote: body.note ? String(body.note) : void 0
+      });
+      return c.json({ suggestion: suggestion2 });
+    }
+    if (!target.proposedTasteContent.trim()) {
+      return c.json({ error: "Suggestion is missing proposedTasteContent" }, 400);
+    }
+    await store.writeTaste(target.proposedTasteContent, target.baseVersion);
+    const suggestion = await store.updateSuggestionStatus(target.id, "applied", {
+      reviewNote: body.note ? String(body.note) : void 0
+    });
+    return c.json({ suggestion });
   } catch (e) {
     return c.json({ error: e.message }, 500);
   }
@@ -882,32 +1385,46 @@ api.post("/taste/memory/append", async (c) => {
 api.post("/taste/memory/query", async (c) => {
   try {
     const body = await c.req.json();
-    const memoryFilePath = String(body.memoryFilePath || "taste/memory.md");
-    const fullPath = resolveSafePath(memoryFilePath);
-    const content = existsSync(fullPath) ? await readFile(fullPath, "utf-8") : "";
-    const items = parseTasteMemoryMarkdown(content);
-    const filtered = queryMemoryItems(items, {
+    const store = createStoreFromBody(body);
+    await store.ensureWorkspace();
+    const items = await store.queryMemory({
       tag: body.tag ? String(body.tag) : void 0,
+      status: body.status ? String(body.status) : void 0,
       since: body.since ? String(body.since) : void 0,
       text: body.text ? String(body.text) : void 0,
       limit: body.limit ? Number(body.limit) : void 0
     });
-    return c.json({ items: filtered });
+    return c.json({ items });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/cli/run", async (c) => {
+  try {
+    const body = await c.req.json();
+    const args = Array.isArray(body.args) ? body.args : [];
+    if (!args.length) {
+      return c.json({ error: "args array is required" }, 400);
+    }
+    const cwd = body.cwd ? resolveSafePath(String(body.cwd)) : process.cwd();
+    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 path3 from "path";
-import { fileURLToPath } from "url";
-import fs3 from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fs4 from "fs";
 var app = new Hono2();
 app.use("/*", cors());
 app.route("/api", api_default);
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
 var createServer = (staticRoot) => {
   const app2 = new Hono2();
   app2.use("/*", cors());
@@ -938,10 +1455,10 @@ var createServer = (staticRoot) => {
   };
   app2.get("/*", async (c) => {
     const requestPath = c.req.path === "/" ? "/index.html" : c.req.path;
-    const filePath = path3.join(staticRoot, requestPath);
+    const filePath = path5.join(staticRoot, requestPath);
     try {
-      if (fs3.existsSync(filePath)) {
-        const file = await fs3.promises.readFile(filePath);
+      if (fs4.existsSync(filePath)) {
+        const file = await fs4.promises.readFile(filePath);
         const mimeType = getMimeType(filePath);
         return new Response(file, {
           headers: {
@@ -953,9 +1470,9 @@ var createServer = (staticRoot) => {
     }
     if (!requestPath.includes(".")) {
       try {
-        const indexPath = path3.join(staticRoot, "index.html");
-        if (fs3.existsSync(indexPath)) {
-          const indexFile = await fs3.promises.readFile(indexPath);
+        const indexPath = path5.join(staticRoot, "index.html");
+        if (fs4.existsSync(indexPath)) {
+          const indexFile = await fs4.promises.readFile(indexPath);
           return new Response(indexFile, {
             headers: {
               "Content-Type": "text/html"
@@ -983,8 +1500,8 @@ function startServer(app2, port) {
 }
 
 // src/cli/commands/record.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path4.dirname(__filename2);
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path6.dirname(__filename3);
 function formatBytes(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -993,21 +1510,21 @@ function formatBytes(bytes) {
   return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
 }
 function getMissingUiAssets(staticRoot) {
-  const indexPath = path4.join(staticRoot, "index.html");
-  if (!fs4.existsSync(indexPath)) {
+  const indexPath = path6.join(staticRoot, "index.html");
+  if (!fs5.existsSync(indexPath)) {
     return {
       missingFiles: [indexPath],
       expectedUrls: []
     };
   }
-  const indexHtml = fs4.readFileSync(indexPath, "utf-8");
+  const indexHtml = fs5.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 = path4.join(staticRoot, assetPath.replace(/^\//, ""));
-    if (!fs4.existsSync(localPath)) {
+    const localPath = path6.join(staticRoot, assetPath.replace(/^\//, ""));
+    if (!fs5.existsSync(localPath)) {
       missingFiles.push(localPath);
       expectedUrls.push(assetPath);
     }
@@ -1097,17 +1614,17 @@ async function ensurePlaywrightReadyOrExit() {
 }
 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 = path4.resolve(process.cwd(), projectOption);
-  if (!fs4.existsSync(projectPath)) {
+  const projectPath = path6.resolve(process.cwd(), projectOption);
+  if (!fs5.existsSync(projectPath)) {
     console.error(`Project file not found at ${projectPath}`);
     process.exit(1);
   }
-  const projectDir = path4.dirname(projectPath);
+  const projectDir = path6.dirname(projectPath);
   process.chdir(projectDir);
   console.log(`Working in project directory: ${projectDir}`);
   let project;
   try {
-    const rawProject = JSON.parse(fs4.readFileSync(projectPath, "utf-8"));
+    const rawProject = JSON.parse(fs5.readFileSync(projectPath, "utf-8"));
     const resolvedCwd = process.cwd();
     project = await SceneResolver.resolve(rawProject, resolvedCwd);
   } catch (e) {
@@ -1128,9 +1645,9 @@ var recordCommand = new Command("record").description("Record the project to a v
     if (entity.src.startsWith("/")) {
       assetPath = entity.src;
     } else {
-      assetPath = path4.resolve(process.cwd(), entity.src);
+      assetPath = path6.resolve(process.cwd(), entity.src);
     }
-    if (!fs4.existsSync(assetPath)) {
+    if (!fs5.existsSync(assetPath)) {
       missingAssets.push(entity.src);
     }
   });
@@ -1154,10 +1671,10 @@ var recordCommand = new Command("record").description("Record the project to a v
 Assets(${allAssets.length}):`);
       allAssets.forEach((entity) => {
         if (!entity.src) return;
-        let assetPath = path4.resolve(process.cwd(), "assets", entity.src);
-        if (!fs4.existsSync(assetPath)) assetPath = path4.resolve(process.cwd(), entity.src);
-        if (fs4.existsSync(assetPath)) {
-          const stats = fs4.statSync(assetPath);
+        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})`);
         }
@@ -1191,11 +1708,11 @@ Ready to record. Run without --dry-run to start rendering.`);
   ensureFfmpegAvailableOrExit();
   await ensurePlaywrightReadyOrExit();
   console.log("Starting temporary server...");
-  let staticRoot = path4.resolve(__dirname2, "../../dist/ui");
-  if (!fs4.existsSync(staticRoot)) {
-    staticRoot = path4.resolve(__dirname2, "../ui");
+  let staticRoot = path6.resolve(__dirname3, "../../dist/ui");
+  if (!fs5.existsSync(staticRoot)) {
+    staticRoot = path6.resolve(__dirname3, "../ui");
   }
-  if (!fs4.existsSync(staticRoot)) {
+  if (!fs5.existsSync(staticRoot)) {
     console.error(`Error: UI assets not found at ${staticRoot}. Please run 'bun run build' first.`);
     process.exit(1);
   }
@@ -1251,14 +1768,14 @@ Ready to record. Run without --dry-run to start rendering.`);
       let assetPath = "";
       if (e.src.startsWith("/")) {
         if (e.src.startsWith("/api/fs/assets/")) {
-          assetPath = path4.resolve(process.cwd(), "assets", e.src.replace("/api/fs/assets/", ""));
+          assetPath = path6.resolve(process.cwd(), "assets", e.src.replace("/api/fs/assets/", ""));
         } else {
           assetPath = e.src;
         }
       } else {
-        assetPath = path4.resolve(process.cwd(), e.src);
+        assetPath = path6.resolve(process.cwd(), e.src);
       }
-      if (fs4.existsSync(assetPath)) {
+      if (fs5.existsSync(assetPath)) {
         e.src = assetPath;
         return true;
       } else {
@@ -1312,7 +1829,7 @@ Ready to record. Run without --dry-run to start rendering.`);
     if (debug) {
       console.log("FFmpeg args:", ffmpegArgs.join(" "));
     }
-    const ffmpeg = spawn3("ffmpeg", ffmpegArgs);
+    const ffmpeg = spawn4("ffmpeg", ffmpegArgs);
     ffmpeg.stderr.on("data", (data) => {
       if (debug) {
         console.error(`FFmpeg: ${data.toString()}`);
@@ -1368,7 +1885,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 = path4.relative(process.cwd(), projectPath);
+        const projectRelativePath = path6.relative(process.cwd(), projectPath);
         const targetUrl = `${url}?mode=render&time=${time}&project=${encodeURIComponent(projectRelativePath)}`;
         await page.goto(targetUrl, { waitUntil: "load" });
         await page.waitForSelector('canvas[data-ready="true"]', { timeout: 3e4 });
@@ -1406,12 +1923,12 @@ Ready to record. Run without --dry-run to start rendering.`);
 
 // src/cli/commands/inspect.ts
 import { Command as Command2 } from "commander";
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 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 = path5.resolve(process.cwd(), file);
-  if (!fs5.existsSync(filePath)) {
+  const filePath = path7.resolve(process.cwd(), file);
+  if (!fs6.existsSync(filePath)) {
     console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
@@ -1440,8 +1957,8 @@ inspectCommand.description("Inspect an asset file to get metadata (duration, for
 
 // src/cli/commands/validate.ts
 import { Command as Command3 } from "commander";
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path8 from "path";
 var validateCommand = new Command3("validate");
 function resolveRuntimeFit(fit, imageRatio, canvasRatio) {
   if (fit === "cover" || fit === "contain") return fit;
@@ -1449,13 +1966,13 @@ function resolveRuntimeFit(fit, imageRatio, canvasRatio) {
   return ratioDelta > 0.2 ? "contain" : "cover";
 }
 validateCommand.description("Validate a scene file").argument("<file>", "Path to the scene file").action(async (file) => {
-  const filePath = path6.resolve(process.cwd(), file);
-  if (!fs6.existsSync(filePath)) {
+  const filePath = path8.resolve(process.cwd(), file);
+  if (!fs7.existsSync(filePath)) {
     console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
   try {
-    const rawScene = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+    const rawScene = JSON.parse(fs7.readFileSync(filePath, "utf-8"));
     const data = await SceneResolver.resolve(rawScene, process.cwd());
     const errors = [];
     const warnings = [];
@@ -1495,13 +2012,13 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
               let fullPath = "";
               if (entity.src.startsWith("/api/fs/assets/")) {
                 const stripped = entity.src.replace("/api/fs/assets/", "");
-                fullPath = path6.resolve(process.cwd(), stripped);
+                fullPath = path8.resolve(process.cwd(), stripped);
               } else if (entity.src.startsWith("/")) {
                 fullPath = entity.src;
               } else {
-                fullPath = path6.resolve(process.cwd(), entity.src);
+                fullPath = path8.resolve(process.cwd(), entity.src);
               }
-              if (!fs6.existsSync(fullPath)) {
+              if (!fs7.existsSync(fullPath)) {
                 errors.push(`${prefix} asset not found at ${fullPath} (derived from src: "${entity.src}")`);
               } else {
                 try {
@@ -1535,13 +2052,13 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
             let fullPath = "";
             if (entity.src.startsWith("/api/fs/assets/")) {
               const stripped = entity.src.replace("/api/fs/assets/", "");
-              fullPath = path6.resolve(process.cwd(), stripped);
+              fullPath = path8.resolve(process.cwd(), stripped);
             } else if (entity.src.startsWith("/")) {
               fullPath = entity.src;
             } else {
-              fullPath = path6.resolve(process.cwd(), entity.src);
+              fullPath = path8.resolve(process.cwd(), entity.src);
             }
-            if (!fs6.existsSync(fullPath)) {
+            if (!fs7.existsSync(fullPath)) {
               errors.push(`${prefix} asset not found at ${fullPath} (derived from src: "${entity.src}")`);
             }
           }
@@ -1573,21 +2090,21 @@ validateCommand.description("Validate a scene file").argument("<file>", "Path to
 
 // src/cli/commands/set-scene.ts
 import { Command as Command4 } from "commander";
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 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 = path7.resolve(process.cwd(), file);
+  const targetPath = path9.resolve(process.cwd(), file);
   let contentStr = "";
   if (options.content) {
     contentStr = options.content;
   } else if (options.input) {
-    const inputPath = path7.resolve(process.cwd(), options.input);
-    if (!fs7.existsSync(inputPath)) {
+    const inputPath = path9.resolve(process.cwd(), options.input);
+    if (!fs8.existsSync(inputPath)) {
       console.error(`Input file not found: ${inputPath}`);
       process.exit(1);
     }
-    contentStr = fs7.readFileSync(inputPath, "utf-8");
+    contentStr = fs8.readFileSync(inputPath, "utf-8");
   } else {
     console.error("Error: Please provide --content <json> or --input <file>");
     process.exit(1);
@@ -1598,7 +2115,7 @@ setSceneCommand.description("Update or create a scene file with new content").ar
       console.error('Error: Invalid scene format. Missing "meta" or "entities".');
       process.exit(1);
     }
-    fs7.writeFileSync(targetPath, JSON.stringify(data, null, 2));
+    fs8.writeFileSync(targetPath, JSON.stringify(data, null, 2));
     console.log(`Scene updated at ${targetPath}`);
   } catch (e) {
     console.error("Error: Content is not valid JSON.", e.message);
@@ -1608,10 +2125,10 @@ setSceneCommand.description("Update or create a scene file with new content").ar
 
 // src/cli/commands/imagine.ts
 import { Command as Command5 } from "commander";
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path10 from "path";
 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").addHelpText("after", `
+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", `
 
 Examples:
   # Basic usage - saves to assets/generated.png
@@ -1659,18 +2176,26 @@ Note:
 `).action(async (promptOrFile, options) => {
   try {
     let prompt;
-    if (fs8.existsSync(promptOrFile)) {
+    if (fs9.existsSync(promptOrFile)) {
       console.log(`Reading prompt from file: ${promptOrFile}`);
-      prompt = fs8.readFileSync(promptOrFile, "utf-8").trim();
+      prompt = fs9.readFileSync(promptOrFile, "utf-8").trim();
     } else {
       prompt = promptOrFile;
     }
     if (!prompt) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "Prompt cannot be empty" }));
+        return;
+      }
       console.error("Error: Prompt cannot be empty");
       process.exit(1);
     }
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY;
     if (!apiKey) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "Missing Gemini API key" }));
+        return;
+      }
       console.error("Error: Missing Gemini API key");
       console.error("Please provide via:");
       console.error('  1. -k flag: feedeas imagine "prompt" -k YOUR_API_KEY');
@@ -1681,10 +2206,12 @@ Note:
     const numberOfImages = Math.max(1, parseInt(options.number) || 1);
     const imageSize = normalizeImageSize(options.imageSize);
     const aspectRatio = resolveAspectRatio(options.aspectRatio, options.project);
-    console.log("\u{1F3A8} Generating image with Gemini AI (Imagen)...");
-    console.log(`\u{1F4DD} Prompt: "${prompt.substring(0, 80)}${prompt.length > 80 ? "..." : ""}"`);
-    console.log(`\u{1F9ED} Aspect ratio: ${aspectRatio}`);
-    console.log(`\u{1F4D0} Image size: ${imageSize}`);
+    if (!options.json) {
+      console.log("\u{1F3A8} Generating image with Gemini AI (Imagen)...");
+      console.log(`\u{1F4DD} Prompt: "${prompt.substring(0, 80)}${prompt.length > 80 ? "..." : ""}"`);
+      console.log(`\u{1F9ED} Aspect ratio: ${aspectRatio}`);
+      console.log(`\u{1F4D0} Image size: ${imageSize}`);
+    }
     const images = await generateImages({
       prompt,
       numberOfImages,
@@ -1693,30 +2220,45 @@ Note:
       imageSize
     });
     let outputPath;
-    if (path8.isAbsolute(options.output)) {
+    if (path10.isAbsolute(options.output)) {
       outputPath = options.output;
     } else {
-      const assetsDir = path8.resolve(process.cwd(), "assets");
-      if (!fs8.existsSync(assetsDir)) {
+      const assetsDir = path10.resolve(process.cwd(), "assets");
+      if (!fs9.existsSync(assetsDir)) {
         console.log(`\u{1F4C1} Creating assets directory: ${assetsDir}`);
-        fs8.mkdirSync(assetsDir, { recursive: true });
+        fs9.mkdirSync(assetsDir, { recursive: true });
       }
-      outputPath = path8.join(assetsDir, options.output);
+      outputPath = path10.join(assetsDir, options.output);
     }
-    const outputDir = path8.dirname(outputPath);
-    const outputExt = path8.extname(outputPath) || ".png";
-    const outputBase = path8.basename(outputPath, outputExt);
-    if (!fs8.existsSync(outputDir)) {
-      fs8.mkdirSync(outputDir, { recursive: true });
+    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 savedFiles = [];
     for (let i = 0; i < images.length; i++) {
-      const filename = images.length > 1 ? path8.join(outputDir, `${outputBase}_${i + 1}${outputExt}`) : outputPath;
-      fs8.writeFileSync(filename, images[i]);
-      console.log(`\u2705 Image saved: ${filename}`);
+      const filename = images.length > 1 ? path10.join(outputDir, `${outputBase}_${i + 1}${outputExt}`) : outputPath;
+      fs9.writeFileSync(filename, images[i]);
+      if (!options.json) console.log(`\u2705 Image saved: ${filename}`);
+      savedFiles.push(filename);
+    }
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        files: savedFiles,
+        count: images.length,
+        prompt: prompt.substring(0, 80)
+      }, null, 2));
+      return;
     }
     console.log(`
 \u2728 Successfully generated ${images.length} image(s)!`);
   } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message || String(error) }));
+      return;
+    }
     console.error("\u274C Error generating image:", error.message);
     if (error.cause) {
       console.error("Details:", error.cause);
@@ -1805,10 +2347,10 @@ function resolveAspectRatio(input, projectFile) {
   return normalizeAspectRatio(input);
 }
 function inferAspectRatioFromProject(projectFile) {
-  const filePath = path8.resolve(process.cwd(), projectFile);
-  if (!fs8.existsSync(filePath)) return null;
+  const filePath = path10.resolve(process.cwd(), projectFile);
+  if (!fs9.existsSync(filePath)) return null;
   try {
-    const scene = JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+    const scene = JSON.parse(fs9.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) {
@@ -1848,51 +2390,51 @@ function gcd(a, b) {
 
 // src/cli/commands/audio.ts
 import { Command as Command6 } from "commander";
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path12 from "path";
 
 // src/cli/services/whisper.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path11 from "path";
 import os from "os";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import https from "https";
 var WhisperService = class {
   static getHomeDir() {
     return os.homedir();
   }
   static getBaseDir() {
-    return path9.join(this.getHomeDir(), ".feedeas");
+    return path11.join(this.getHomeDir(), ".feedeas");
   }
   static getBinDir() {
-    return path9.join(this.getBaseDir(), "bin");
+    return path11.join(this.getBaseDir(), "bin");
   }
   static getModelsDir() {
-    return path9.join(this.getBaseDir(), "models");
+    return path11.join(this.getBaseDir(), "models");
   }
   static getExecutablePath() {
-    const repoDir = path9.join(this.getBaseDir(), "whisper.cpp-repo");
+    const repoDir = path11.join(this.getBaseDir(), "whisper.cpp-repo");
     const possiblePaths = [
-      path9.join(repoDir, "build", "bin", "whisper-cli"),
-      path9.join(repoDir, "build", "bin", "main"),
-      path9.join(repoDir, "main"),
-      path9.join(this.getBinDir(), "whisper-main")
+      path11.join(repoDir, "build", "bin", "whisper-cli"),
+      path11.join(repoDir, "build", "bin", "main"),
+      path11.join(repoDir, "main"),
+      path11.join(this.getBinDir(), "whisper-main")
       // fallback to copied/downloaded
     ];
     for (const p of possiblePaths) {
-      if (fs9.existsSync(p)) return p;
+      if (fs10.existsSync(p)) return p;
     }
-    return path9.join(this.getBinDir(), "whisper-main");
+    return path11.join(this.getBinDir(), "whisper-main");
   }
   static getModelPath(modelName = "base.en") {
-    return path9.join(this.getModelsDir(), `ggml-${modelName}.bin`);
+    return path11.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 = fs9.createWriteStream(destPath);
+      const file = fs10.createWriteStream(destPath);
       https.get(url, (response) => {
         if (response.statusCode === 302 || response.statusCode === 301) {
           this.downloadFile(response.headers.location, destPath).then(resolve).catch(reject);
@@ -1908,7 +2450,7 @@ var WhisperService = class {
           resolve();
         });
       }).on("error", (err) => {
-        fs9.unlink(destPath, () => {
+        fs10.unlink(destPath, () => {
         });
         reject(err);
       });
@@ -1920,15 +2462,15 @@ var WhisperService = class {
   static async ensureReady() {
     const binDir = this.getBinDir();
     const modelsDir = this.getModelsDir();
-    if (!fs9.existsSync(binDir)) fs9.mkdirSync(binDir, { recursive: true });
-    if (!fs9.existsSync(modelsDir)) fs9.mkdirSync(modelsDir, { recursive: true });
+    if (!fs10.existsSync(binDir)) fs10.mkdirSync(binDir, { recursive: true });
+    if (!fs10.existsSync(modelsDir)) fs10.mkdirSync(modelsDir, { recursive: true });
     const execPath = this.getExecutablePath();
     const modelPath = this.getModelPath();
-    if (!fs9.existsSync(execPath)) {
+    if (!fs10.existsSync(execPath)) {
       console.log("\u2B07\uFE0F  Whisper binary not found. Attempting to build...");
       try {
-        const repoDir = path9.join(this.getBaseDir(), "whisper.cpp-repo");
-        if (!fs9.existsSync(repoDir)) {
+        const repoDir = path11.join(this.getBaseDir(), "whisper.cpp-repo");
+        if (!fs10.existsSync(repoDir)) {
           console.log("\u{1F4E6}  Cloning whisper.cpp...");
           await runCommand("git", ["clone", "https://github.com/ggerganov/whisper.cpp.git", repoDir]);
         } else {
@@ -1936,7 +2478,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 (fs9.existsSync(newPath)) {
+        if (fs10.existsSync(newPath)) {
           console.log(`\u2705 Whisper binary built at: ${newPath}`);
         } else {
           throw new Error("Build command finished but binary not found in expected paths.");
@@ -1947,7 +2489,7 @@ var WhisperService = class {
 Please install manually: 'brew install whisper-cpp'`);
       }
     }
-    if (!fs9.existsSync(modelPath)) {
+    if (!fs10.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);
@@ -1960,12 +2502,12 @@ Please install manually: 'brew install whisper-cpp'`);
   static async transcribe(audioPath) {
     const execPath = this.getExecutablePath();
     const modelPath = this.getModelPath();
-    const ext = path9.extname(audioPath).toLowerCase();
+    const ext = path11.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 = path9.join(path9.dirname(audioPath), `temp_${Date.now()}.wav`);
+      const tempWav = path11.join(path11.dirname(audioPath), `temp_${Date.now()}.wav`);
       await runCommand("ffmpeg", [
         "-i",
         audioPath,
@@ -1982,7 +2524,7 @@ Please install manually: 'brew install whisper-cpp'`);
       isTempFile = true;
     }
     try {
-      const outputBase = path9.join(path9.dirname(audioPath), path9.basename(audioPath, path9.extname(audioPath)));
+      const outputBase = path11.join(path11.dirname(audioPath), path11.basename(audioPath, path11.extname(audioPath)));
       const baseArgs = [
         "-m",
         modelPath,
@@ -2019,15 +2561,15 @@ Please install manually: 'brew install whisper-cpp'`);
         words
       };
     } finally {
-      if (isTempFile && fs9.existsSync(inputToWhisper)) {
-        fs9.unlinkSync(inputToWhisper);
+      if (isTempFile && fs10.existsSync(inputToWhisper)) {
+        fs10.unlinkSync(inputToWhisper);
       }
     }
   }
 };
 function runCommand(command, args, cwd) {
   return new Promise((resolve, reject) => {
-    const proc = spawn4(command, args, { cwd, stdio: "inherit" });
+    const proc = spawn5(command, args, { cwd, stdio: "inherit" });
     proc.on("close", (code) => {
       if (code === 0) resolve();
       else reject(new Error(`${command} exited with code ${code}`));
@@ -2037,7 +2579,7 @@ function runCommand(command, args, cwd) {
 }
 function runWhisper(execPath, args) {
   return new Promise((resolve, reject) => {
-    const proc = spawn4(execPath, args, { stdio: "inherit" });
+    const proc = spawn5(execPath, args, { stdio: "inherit" });
     proc.on("close", (code) => {
       if (code !== 0) {
         reject(new Error(`Whisper process exited with code ${code}`));
@@ -2046,12 +2588,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 || !fs9.existsSync(jsonPath)) {
+      if (!jsonPath || !fs10.existsSync(jsonPath)) {
         reject(new Error("Whisper output JSON not found"));
         return;
       }
       try {
-        const data = JSON.parse(fs9.readFileSync(jsonPath, "utf-8"));
+        const data = JSON.parse(fs10.readFileSync(jsonPath, "utf-8"));
         resolve(data);
       } catch (err) {
         reject(err);
@@ -2104,9 +2646,9 @@ 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 (fs10.existsSync(textOrFile)) {
+    if (fs11.existsSync(textOrFile)) {
       console.log(`\u{1F4D6} Reading text from file: ${textOrFile}`);
-      text = fs10.readFileSync(textOrFile, "utf-8").trim();
+      text = fs11.readFileSync(textOrFile, "utf-8").trim();
     } else {
       text = textOrFile;
     }
@@ -2122,10 +2664,10 @@ 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 = path10.join(path10.dirname(outputPath), `temp_${Date.now()}.pcm`);
-    fs10.writeFileSync(tempPcmPath, audioBuffer);
+    const tempPcmPath = path12.join(path12.dirname(outputPath), `temp_${Date.now()}.pcm`);
+    fs11.writeFileSync(tempPcmPath, audioBuffer);
     try {
-      console.log(`\u{1F504} Converting raw PCM to ${path10.extname(outputPath)}...`);
+      console.log(`\u{1F504} Converting raw PCM to ${path12.extname(outputPath)}...`);
       await new Promise((resolve, reject) => {
         const ffmpeg = __require("child_process").spawn("ffmpeg", [
           "-f",
@@ -2147,15 +2689,15 @@ audioCommand.alias("audio").description("Generate audio from text using Gemini A
       });
       console.log(`\u2705 Audio saved: ${outputPath}`);
     } finally {
-      if (fs10.existsSync(tempPcmPath)) fs10.unlinkSync(tempPcmPath);
+      if (fs11.existsSync(tempPcmPath)) fs11.unlinkSync(tempPcmPath);
     }
     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(path10.extname(outputPath), ".json");
-        fs10.writeFileSync(metaPath, JSON.stringify(metadata, null, 2));
+        const metaPath = outputPath.replace(path12.extname(outputPath), ".json");
+        fs11.writeFileSync(metaPath, JSON.stringify(metadata, null, 2));
         console.log(`\u2705 Metadata saved: ${metaPath}`);
       } catch (wErr) {
         console.warn("\u26A0\uFE0F  Whisper alignment failed:", wErr.message);
@@ -2167,10 +2709,10 @@ audioCommand.alias("audio").description("Generate audio from text using Gemini A
   }
 });
 function resolveOutputPath(outputOption) {
-  if (path10.isAbsolute(outputOption)) return outputOption;
-  const assetsDir = path10.resolve(process.cwd(), "assets");
-  if (!fs10.existsSync(assetsDir)) fs10.mkdirSync(assetsDir, { recursive: true });
-  return path10.join(assetsDir, 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`;
@@ -2211,11 +2753,11 @@ async function generateGeminiAudio(text, apiKey, voiceName) {
 
 // src/cli/commands/bgm.ts
 import { Command as Command7 } from "commander";
-import fs11 from "fs";
-import path11 from "path";
-import { spawn as spawn5 } from "child_process";
+import fs12 from "fs";
+import path13 from "path";
+import { spawn as spawn6 } from "child_process";
 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").action(async (promptOrFile, options) => {
+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 {
     const prompt = resolvePrompt(promptOrFile);
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY;
@@ -2235,22 +2777,36 @@ bgmCommand.alias("bgm").alias("music").description("Generate background music wi
       apiKey,
       seed
     };
-    console.log("\u{1F3B5} Generating BGM with Gemini Lyria...");
-    console.log(`\u{1F4DD} Prompt: "${request.prompt.substring(0, 100)}${request.prompt.length > 100 ? "..." : ""}"`);
-    console.log(`\u23F1\uFE0F  Duration: ${request.durationSec}s`);
-    if (typeof request.seed === "number") {
-      console.log(`\u{1F331} Seed: ${request.seed}`);
+    if (!options.json) {
+      console.log("\u{1F3B5} Generating BGM with Gemini Lyria...");
+      console.log(`\u{1F4DD} Prompt: "${request.prompt.substring(0, 100)}${request.prompt.length > 100 ? "..." : ""}"`);
+      console.log(`\u23F1\uFE0F  Duration: ${request.durationSec}s`);
+      if (typeof request.seed === "number") {
+        console.log(`\u{1F331} Seed: ${request.seed}`);
+      }
     }
     const pcmBuffer = await generateGeminiMusicPcm(request);
     await convertPcmToOutput(pcmBuffer, request.outputPath, request.format, request.durationSec);
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        file: request.outputPath,
+        durationSec: request.durationSec
+      }, null, 2));
+      return;
+    }
     console.log(`\u2705 BGM saved: ${request.outputPath}`);
   } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error?.message || String(error) }));
+      return;
+    }
     console.error("\u274C Error generating BGM:", error?.message || error);
     process.exit(1);
   }
 });
 function resolvePrompt(promptOrFile) {
-  const prompt = fs11.existsSync(promptOrFile) ? fs11.readFileSync(promptOrFile, "utf-8").trim() : String(promptOrFile).trim();
+  const prompt = fs12.existsSync(promptOrFile) ? fs12.readFileSync(promptOrFile, "utf-8").trim() : String(promptOrFile).trim();
   if (!prompt) {
     throw new Error("Prompt cannot be empty");
   }
@@ -2272,13 +2828,13 @@ function parseSeed(input) {
   return value;
 }
 function resolveOutputPath2(outputOption) {
-  if (path11.isAbsolute(outputOption)) return outputOption;
-  const assetsDir = path11.resolve(process.cwd(), "assets");
-  if (!fs11.existsSync(assetsDir)) fs11.mkdirSync(assetsDir, { recursive: true });
-  return path11.join(assetsDir, 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 = path11.extname(outputPath).toLowerCase();
+  const ext = path13.extname(outputPath).toLowerCase();
   if (ext === ".wav") return "wav";
   if (ext === ".mp3" || !ext) return "mp3";
   throw new Error("Invalid output format. Use .mp3 or .wav.");
@@ -2366,14 +2922,14 @@ async function generateGeminiMusicPcm(request) {
   });
 }
 async function convertPcmToOutput(pcmBuffer, outputPath, format, durationSec) {
-  const outputDir = path11.dirname(outputPath);
-  if (!fs11.existsSync(outputDir)) fs11.mkdirSync(outputDir, { recursive: true });
-  const tempPcmPath = path11.join(outputDir, `temp_bgm_${Date.now()}.pcm`);
-  fs11.writeFileSync(tempPcmPath, pcmBuffer);
+  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 = spawn5("ffmpeg", [
+      const ffmpeg = spawn6("ffmpeg", [
         "-f",
         "s16le",
         "-ar",
@@ -2395,25 +2951,25 @@ async function convertPcmToOutput(pcmBuffer, outputPath, format, durationSec) {
       ffmpeg.on("error", reject);
     });
   } finally {
-    if (fs11.existsSync(tempPcmPath)) fs11.unlinkSync(tempPcmPath);
+    if (fs12.existsSync(tempPcmPath)) fs12.unlinkSync(tempPcmPath);
   }
 }
 
 // src/cli/commands/asset.ts
 import { Command as Command8 } from "commander";
-import fs12 from "fs";
-import path12 from "path";
-import { spawn as spawn6 } from "child_process";
+import fs13 from "fs";
+import path14 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 = path12.resolve(process.cwd(), "assets", file);
-  if (!fs12.existsSync(assetPath)) {
+  const assetPath = path14.resolve(process.cwd(), "assets", file);
+  if (!fs13.existsSync(assetPath)) {
     console.error(`Asset not found: ${file}`);
     console.error(`Looked in: ${assetPath}`);
     process.exit(1);
   }
-  const stats = fs12.statSync(assetPath);
-  const ext = path12.extname(file).toLowerCase();
+  const stats = fs13.statSync(assetPath);
+  const ext = path14.extname(file).toLowerCase();
   console.log(`
 Asset: ${file}`);
   console.log(`Size: ${formatBytes2(stats.size)}`);
@@ -2436,11 +2992,11 @@ Asset: ${file}`);
       console.log(`Channels: ${audioInfo.channels}`);
       console.log(`Bitrate: ${audioInfo.bitrate}`);
       const metadataFile = file.replace(ext, ".json");
-      const metadataPath = path12.resolve(process.cwd(), "assets", metadataFile);
-      if (fs12.existsSync(metadataPath)) {
+      const metadataPath = path14.resolve(process.cwd(), "assets", metadataFile);
+      if (fs13.existsSync(metadataPath)) {
         console.log(`
 Metadata: ${metadataFile}`);
-        const metadata = JSON.parse(fs12.readFileSync(metadataPath, "utf-8"));
+        const metadata = JSON.parse(fs13.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];
@@ -2485,7 +3041,7 @@ async function getImageDimensions(filePath) {
 }
 async function getAudioInfo(filePath) {
   return new Promise((resolve, reject) => {
-    const ffprobe = spawn6("ffprobe", [
+    const ffprobe = spawn7("ffprobe", [
       "-v",
       "error",
       "-show_entries",
@@ -2524,9 +3080,9 @@ async function getAudioInfo(filePath) {
 
 // src/cli/index.ts
 import open2 from "open";
-import path16 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import fs16 from "fs";
+import path18 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import fs17 from "fs";
 
 // src/cli/commands/example.ts
 import { Command as Command9 } from "commander";
@@ -2819,14 +3375,14 @@ function printSchema(name, schema) {
 
 // src/cli/commands/create-scene.ts
 import { Command as Command11 } from "commander";
-import path13 from "path";
+import path15 from "path";
 
 // src/cli/services/scene-builder.ts
-import fs13 from "fs";
+import fs14 from "fs";
 function loadScene(filePath) {
-  if (fs13.existsSync(filePath)) {
+  if (fs14.existsSync(filePath)) {
     try {
-      return JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
     } catch (e) {
       throw new Error(`Failed to parse existing scene file: ${e}`);
     }
@@ -2842,7 +3398,7 @@ function loadScene(filePath) {
   }
 }
 function saveScene(filePath, scene) {
-  fs13.writeFileSync(filePath, JSON.stringify(scene, null, 2));
+  fs14.writeFileSync(filePath, JSON.stringify(scene, null, 2));
 }
 function addEntityToScene(scene, entity) {
   if (!entity.id) {
@@ -2862,10 +3418,10 @@ function addEntityToScene(scene, entity) {
 }
 
 // src/cli/commands/create-scene.ts
-import fs14 from "fs";
+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 = path13.resolve(process.cwd(), file);
+  const filePath = path15.resolve(process.cwd(), file);
   try {
     const scene = loadScene(filePath);
     saveScene(filePath, scene);
@@ -2877,8 +3433,8 @@ createSceneCommand.description("Create and modify scene files").argument("<file>
 });
 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 = path13.resolve(process.cwd(), file);
-  if (!fs14.existsSync(filePath)) {
+  const filePath = path15.resolve(process.cwd(), file);
+  if (!fs15.existsSync(filePath)) {
     console.error(`\u274C Scene file not found: ${filePath}`);
     process.exit(1);
   }
@@ -2909,7 +3465,7 @@ addEntityCommand.description("Add an entity to an existing scene file").argument
       startTime = 0;
     }
     if (options.duration === "auto" && options.src) {
-      const assetPath = path13.resolve(process.cwd(), options.src);
+      const assetPath = path15.resolve(process.cwd(), options.src);
       try {
         const metadata = await FFprobeService.getMetadata(assetPath);
         duration = metadata.duration;
@@ -2956,19 +3512,19 @@ addEntityCommand.description("Add an entity to an existing scene file").argument
 
 // src/cli/services/telemetry.ts
 import os2 from "os";
-import path14 from "path";
-import { createHash } from "crypto";
+import path16 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"]);
 var BUILT_POSTHOG_KEY = String(
-  ""
+  "phc_w3BnJp2sDXvSpIsMkofnwDSObboBd6DXhNetfZuyWVO"
 ).trim();
 var PostHogTelemetryService = class {
   trackFeedback(details) {
     if (!this.enabled) return;
     this.capture("cli_feedback", {
       details: String(details).slice(0, 2e3),
-      cwd_basename: path14.basename(process.cwd())
+      cwd_basename: path16.basename(process.cwd())
     });
   }
   apiKey;
@@ -2991,7 +3547,7 @@ var PostHogTelemetryService = class {
       command_name: this.getCommandPath(actionCommand),
       command_aliases: actionCommand.aliases(),
       options_used: this.getUsedOptionNames(actionCommand),
-      cwd_basename: path14.basename(process.cwd()),
+      cwd_basename: path16.basename(process.cwd()),
       node_version: process.version,
       platform: process.platform,
       arch: process.arch
@@ -3004,7 +3560,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: path14.basename(process.cwd())
+      cwd_basename: path16.basename(process.cwd())
     });
   }
   getCommandPath(command) {
@@ -3027,7 +3583,7 @@ var PostHogTelemetryService = class {
       os2.hostname(),
       os2.userInfo().username
     ].join("|");
-    return createHash("sha256").update(seed).digest("hex");
+    return createHash2("sha256").update(seed).digest("hex");
   }
   capture(event, properties) {
     if (!this.apiKey) return;
@@ -3057,26 +3613,26 @@ var PostHogTelemetryService = class {
 
 // src/cli/commands/taste.ts
 import { Command as Command12 } from "commander";
-import fs15 from "node:fs";
-import path15 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import fs16 from "node:fs";
+import path17 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import open from "open";
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path15.dirname(__filename3);
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = path17.dirname(__filename4);
 function resolveStaticRoot() {
-  let staticRoot = path15.resolve(__dirname3, "../../../dist/ui");
-  if (!fs15.existsSync(staticRoot)) {
-    staticRoot = path15.resolve(__dirname3, "../../ui");
+  let staticRoot = path17.resolve(__dirname4, "../../../dist/ui");
+  if (!fs16.existsSync(staticRoot)) {
+    staticRoot = path17.resolve(__dirname4, "../../ui");
   }
   return staticRoot;
 }
 function prepareWorkingDirectory(pathArg) {
   if (!pathArg) return;
-  const targetPath = path15.resolve(process.cwd(), pathArg);
-  if (fs15.existsSync(targetPath)) {
-    const stats = fs15.statSync(targetPath);
+  const targetPath = path17.resolve(process.cwd(), pathArg);
+  if (fs16.existsSync(targetPath)) {
+    const stats = fs16.statSync(targetPath);
     if (stats.isFile()) {
-      process.chdir(path15.dirname(targetPath));
+      process.chdir(path17.dirname(targetPath));
       return;
     }
     if (stats.isDirectory()) {
@@ -3084,20 +3640,33 @@ function prepareWorkingDirectory(pathArg) {
       return;
     }
   }
-  if (path15.extname(pathArg)) {
-    const dir = path15.dirname(targetPath);
-    fs15.mkdirSync(dir, { recursive: true });
+  if (path17.extname(pathArg)) {
+    const dir = path17.dirname(targetPath);
+    fs16.mkdirSync(dir, { recursive: true });
     process.chdir(dir);
     return;
   }
-  fs15.mkdirSync(targetPath, { recursive: true });
+  fs16.mkdirSync(targetPath, { recursive: true });
   process.chdir(targetPath);
 }
-var tasteCommand = new Command12("taste").description("Launch and automate the Taste workspace").argument("[path]", "Optional workspace directory").option("-p, --port <number>", "Port to run on", "3331").option("--no-open", "Do not open browser").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").action(async (pathArg, options) => {
+function createStoreFromOptions(options) {
+  return createTasteStore({
+    backend: options.storage,
+    tasteFilePath: options.tasteFile || "taste/taste.md",
+    memoryFilePath: options.memoryFile || "taste/memory.md",
+    suggestionsFilePath: options.suggestionsFile || "taste/suggestions.md"
+  });
+}
+function parseCsvList(value) {
+  if (!value) return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+var tasteCommand = new Command12("taste").description("Launch and automate the Taste workspace").argument("[path]", "Optional workspace directory").option("-p, --port <number>", "Port to run on", "3331").option("--no-open", "Do not open browser").option("--storage <backend>", "Storage backend: markdown|db", "markdown").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").action(async (pathArg, options) => {
   prepareWorkingDirectory(pathArg);
-  ensureTasteWorkspaceFiles(options.tasteFile, options.memoryFile);
+  const store = createStoreFromOptions(options);
+  await store.ensureWorkspace();
   const staticRoot = resolveStaticRoot();
-  if (!fs15.existsSync(staticRoot)) {
+  if (!fs16.existsSync(staticRoot)) {
     console.warn(`Warning: UI assets not found at ${staticRoot}. Did you run 'bun run build'?`);
   }
   const port = parseInt(options.port, 10);
@@ -3113,21 +3682,21 @@ var tasteCommand = new Command12("taste").description("Launch and automate the T
     await open(url);
   }
 });
-tasteCommand.command("generate").description("Generate fresh ideas from taste and memory files").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("-n, --count <number>", "How many ideas to generate", "1").option("--mode <mode>", "Generation mode: sequential|parallel", "sequential").option("--no-save", "Do not append accepted ideas into memory.md").option("--json", "Emit machine-readable JSON output").option("-k, --api-key <key>", "Gemini API key (or set GEMINI_API_KEY env var)").action(async (options) => {
+tasteCommand.command("generate").description("Generate fresh ideas from taste and memory files").option("--storage <backend>", "Storage backend: markdown|db").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").option("-n, --count <number>", "How many ideas to generate", "1").option("--memory-window <number>", "Recent memory window for generation context", "40").option("--mode <mode>", "Generation mode: sequential|parallel", "sequential").option("--no-save", "Do not append generated ideas into memory.md").option("--json", "Emit machine-readable JSON output").option("-k, --api-key <key>", "Gemini API key (or set GEMINI_API_KEY env var)").action(async (options) => {
   try {
-    ensureTasteWorkspaceFiles(options.tasteFile, options.memoryFile);
+    const store = createStoreFromOptions(options);
+    await store.ensureWorkspace();
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY;
     if (!apiKey) {
       throw new Error("Missing Gemini API key. Set GEMINI_API_KEY or pass --api-key.");
     }
-    const tastePath = safeResolveFromCwd(options.tasteFile);
-    const memoryPath = safeResolveFromCwd(options.memoryFile);
-    const tasteContent = fs15.readFileSync(tastePath, "utf-8");
-    const memoryContent = fs15.existsSync(memoryPath) ? fs15.readFileSync(memoryPath, "utf-8") : "";
-    const memories = parseTasteMemoryMarkdown(memoryContent);
+    const taste = await store.readTaste();
+    const memories = await store.queryMemory({
+      limit: Math.max(1, parseInt(options.memoryWindow, 10) || 40)
+    });
     const mode = options.mode === "parallel" ? "parallel" : "sequential";
     const result = await simulateIdeas({
-      tasteContent,
+      tasteContent: taste.content,
       memories,
       count: Math.max(1, parseInt(options.count, 10) || 1),
       mode,
@@ -3135,9 +3704,10 @@ tasteCommand.command("generate").description("Generate fresh ideas from taste an
     });
     let appendedIds = [];
     if (options.save && result.ideas.length > 0) {
-      const appended = appendMemoryEntries(memoryContent, result.ideas);
-      fs15.writeFileSync(memoryPath, appended.markdown, "utf-8");
-      appendedIds = appended.appendedIds;
+      for (const idea of result.ideas) {
+        const saved = await store.appendMemory({ ...idea, status: "generated" });
+        appendedIds.push(saved.id);
+      }
     }
     const output = {
       ...result,
@@ -3163,13 +3733,124 @@ tasteCommand.command("generate").description("Generate fresh ideas from taste an
     process.exit(1);
   }
 });
-var tasteMemoryQueryCommand = new Command12("query").description("Query structured taste memories").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--tag <tag>", "Filter by tag").option("--since <date>", "Filter by created_at >= YYYY-MM-DD").option("--limit <number>", "Maximum number of results", "20").option("--text <text>", "Search term in title/summary/content").option("--json", "Emit machine-readable JSON output").action((options) => {
+tasteCommand.command("feedback").description("Append accept/reject feedback into memory").option("--storage <backend>", "Storage backend: markdown|db").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").requiredOption("--decision <status>", "accepted|rejected").option("--idea-id <id>", "Optional original idea id").requiredOption("--title <text>", "Idea title").option("--format <text>", "Idea format", "daily-reel").option("--tags <csv>", "Comma separated tags").option("--reason-tags <csv>", "Comma separated reason tags").option("--summary <text>", "Optional summary", "").option("--content <text>", "Optional content", "").option("--notes <text>", "Optional reviewer notes", "").option("--json", "Emit machine-readable JSON output").action(async (options) => {
   try {
-    const fullPath = safeResolveFromCwd(options.memoryFile);
-    const content = fs15.existsSync(fullPath) ? fs15.readFileSync(fullPath, "utf-8") : "";
-    const items = parseTasteMemoryMarkdown(content);
-    const filtered = queryMemoryItems(items, {
+    const decision = String(options.decision || "").toLowerCase();
+    if (decision !== "accepted" && decision !== "rejected") {
+      throw new Error("Invalid --decision. Use accepted|rejected.");
+    }
+    const store = createStoreFromOptions(options);
+    await store.ensureWorkspace();
+    const entry = {
+      id: options.ideaId,
+      title: options.title,
+      format: options.format || "daily-reel",
+      tags: parseCsvList(options.tags),
+      freshnessTerms: [],
+      summary: options.summary || "",
+      content: options.content || "",
+      status: decision,
+      reasonTags: parseCsvList(options.reasonTags),
+      notes: options.notes || ""
+    };
+    const saved = await store.appendMemory(entry);
+    if (options.json) {
+      console.log(JSON.stringify({ item: saved }, null, 2));
+      return;
+    }
+    console.log(`Saved feedback: ${saved.id} (${saved.status || decision})`);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+tasteCommand.command("suggest").description("Generate pending taste suggestions from memory feedback").option("--storage <backend>", "Storage backend: markdown|db").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").option("--memory-window <number>", "Recent memory window for suggestion generation", "50").option("--json", "Emit machine-readable JSON output").action(async (options) => {
+  try {
+    const store = createStoreFromOptions(options);
+    await store.ensureWorkspace();
+    const taste = await store.readTaste();
+    const memories = await store.queryMemory({
+      limit: Math.max(1, parseInt(options.memoryWindow, 10) || 50)
+    });
+    const draft = buildTasteSuggestionFromMemory(taste.content, memories);
+    const suggestion = await store.appendSuggestion({
+      title: draft.title,
+      summary: draft.summary,
+      rationale: draft.rationale,
+      patch: draft.patch,
+      proposedTasteContent: draft.proposedTasteContent,
+      baseVersion: taste.version
+    });
+    if (options.json) {
+      console.log(JSON.stringify({ suggestion }, null, 2));
+      return;
+    }
+    console.log(`Created suggestion: ${suggestion.id} (${suggestion.status})`);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+tasteCommand.command("apply").description("Apply or reject a suggestion entry").requiredOption("--suggestion <id>", "Suggestion id").option("--reject", "Mark suggestion as rejected without applying").option("--note <text>", "Optional reviewer note").option("--storage <backend>", "Storage backend: markdown|db").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").option("--json", "Emit machine-readable JSON output").action(async (options) => {
+  try {
+    const store = createStoreFromOptions(options);
+    await store.ensureWorkspace();
+    const suggestions = await store.listSuggestions();
+    const target = suggestions.find((item) => item.id === options.suggestion);
+    if (!target) {
+      throw new Error(`Suggestion not found: ${options.suggestion}`);
+    }
+    if (target.status !== "pending") {
+      throw new Error(`Suggestion ${target.id} is already ${target.status}.`);
+    }
+    if (options.reject) {
+      const updated2 = await store.updateSuggestionStatus(target.id, "rejected", { reviewNote: options.note });
+      if (options.json) {
+        console.log(JSON.stringify({ suggestion: updated2 }, null, 2));
+        return;
+      }
+      console.log(`Rejected suggestion: ${updated2.id}`);
+      return;
+    }
+    if (!target.proposedTasteContent.trim()) {
+      throw new Error("Suggestion is missing proposed taste content.");
+    }
+    await store.writeTaste(target.proposedTasteContent, target.baseVersion);
+    const updated = await store.updateSuggestionStatus(target.id, "applied", { reviewNote: options.note });
+    if (options.json) {
+      console.log(JSON.stringify({ suggestion: updated }, null, 2));
+      return;
+    }
+    console.log(`Applied suggestion: ${updated.id}`);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+tasteCommand.command("read").description("Read the taste file and output its content (useful for agents)").option("--storage <backend>", "Storage backend: markdown|db").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").option("--json", "Emit machine-readable JSON output").action(async (options) => {
+  try {
+    const store = createStoreFromOptions(options);
+    const taste = await store.readTaste();
+    if (!taste.content) {
+      const fullPath = safeResolveFromCwd(options.tasteFile);
+      console.warn(`Taste file not found or empty at: ${fullPath}`);
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ content: taste.content, version: taste.version }, null, 2));
+    } else {
+      console.log(taste.content);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+var tasteMemoryQueryCommand = new Command12("query").description("Query structured taste memories").option("--storage <backend>", "Storage backend: markdown|db").option("--taste-file <path>", "Taste file path", "taste/taste.md").option("--memory-file <path>", "Memory file path", "taste/memory.md").option("--suggestions-file <path>", "Suggestions file path", "taste/suggestions.md").option("--tag <tag>", "Filter by tag").option("--status <status>", "Filter by status (generated|accepted|rejected)").option("--since <date>", "Filter by created_at >= YYYY-MM-DD").option("--limit <number>", "Maximum number of results", "20").option("--text <text>", "Search term in title/summary/content").option("--json", "Emit machine-readable JSON output").action(async (options) => {
+  try {
+    const store = createStoreFromOptions(options);
+    const filtered = await store.queryMemory({
       tag: options.tag,
+      status: options.status,
       since: options.since,
       text: options.text,
       limit: parseInt(options.limit, 10) || 20
@@ -3184,6 +3865,7 @@ var tasteMemoryQueryCommand = new Command12("query").description("Query structur
     }
     for (const item of filtered) {
       console.log(`${item.id} | ${item.createdAt} | ${item.title}`);
+      if (item.status) console.log(`  status: ${item.status}`);
       if (item.tags.length) console.log(`  tags: ${item.tags.join(", ")}`);
       if (item.summary) console.log(`  summary: ${item.summary}`);
     }
@@ -3210,8 +3892,8 @@ function createFeedbackCommand(telemetry2) {
 }
 
 // src/cli/index.ts
-var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = path16.dirname(__filename4);
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname5 = path18.dirname(__filename5);
 var program = new Command14();
 var telemetry = new PostHogTelemetryService();
 var commandStartTimes = /* @__PURE__ */ new WeakMap();
@@ -3228,12 +3910,12 @@ program.command("edit [path]").alias("start").alias("init").description("Start t
   const port = parseInt(options.port);
   let sceneFile;
   if (pathArg) {
-    const targetPath = path16.resolve(process.cwd(), pathArg);
-    if (fs16.existsSync(targetPath)) {
-      const stats = fs16.statSync(targetPath);
+    const targetPath = path18.resolve(process.cwd(), pathArg);
+    if (fs17.existsSync(targetPath)) {
+      const stats = fs17.statSync(targetPath);
       if (stats.isFile()) {
-        sceneFile = path16.basename(targetPath);
-        const dir = path16.dirname(targetPath);
+        sceneFile = path18.basename(targetPath);
+        const dir = path18.dirname(targetPath);
         process.chdir(dir);
         console.log(`Opening scene file: ${sceneFile}`);
       } else if (stats.isDirectory()) {
@@ -3241,28 +3923,28 @@ program.command("edit [path]").alias("start").alias("init").description("Start t
       }
     } else {
       if (pathArg.endsWith(".json")) {
-        sceneFile = path16.basename(pathArg);
-        const dir = path16.dirname(path16.resolve(process.cwd(), pathArg));
-        if (!fs16.existsSync(dir)) {
+        sceneFile = path18.basename(pathArg);
+        const dir = path18.dirname(path18.resolve(process.cwd(), pathArg));
+        if (!fs17.existsSync(dir)) {
           console.log(`Creating directory ${dir}...`);
-          fs16.mkdirSync(dir, { recursive: true });
+          fs17.mkdirSync(dir, { recursive: true });
         }
         process.chdir(dir);
         console.log(`Will create new scene file: ${sceneFile}`);
       } else {
         console.log(`Creating directory ${targetPath}...`);
-        fs16.mkdirSync(targetPath, { recursive: true });
+        fs17.mkdirSync(targetPath, { recursive: true });
         process.chdir(targetPath);
       }
     }
   }
   const cwd = process.cwd();
   console.log(`Starting Feedeas in ${cwd}...`);
-  let staticRoot = path16.resolve(__dirname4, "../../dist/ui");
-  if (!fs16.existsSync(staticRoot)) {
-    staticRoot = path16.resolve(__dirname4, "../ui");
+  let staticRoot = path18.resolve(__dirname5, "../../dist/ui");
+  if (!fs17.existsSync(staticRoot)) {
+    staticRoot = path18.resolve(__dirname5, "../ui");
   }
-  if (!fs16.existsSync(staticRoot)) {
+  if (!fs17.existsSync(staticRoot)) {
     console.warn(`Warning: UI assets not found at ${staticRoot}. Did you run 'bun run build'?`);
   }
   const app2 = createServer(staticRoot);
@@ -3365,7 +4047,12 @@ Guided Flow (Agent-Friendly, End-to-End):
 Agent Conversation Example:
   User: Create a nice reel about small life habits that heal us.
   Agent: I'll draft a short storyline, generate assets, build the scene, validate, and render.
-  Agent: Let me create the narration script first.
+  Agent: Let me create the narration script first, first check if the user has any taste preferences.
+  Agent (tool): feedeas taste memory query --tag "content preferences" --limit 5
+  Agent: Based on past preferences, I'll go with a warm, hopeful tone.
+  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 audio "Life changes in small daily choices..." -o narration.mp3 --no-transcribe
@@ -3449,8 +4136,12 @@ Interactive Workflow (for Humans):
   $ feedeas snap 2.5 -o frame.png          # Take snapshot at 2.5s
 
 Taste Workflow:
-  $ feedeas taste
+  $ feedeas taste                          # Start UI Workspace
+  $ feedeas taste read --json              # Read instructions/taste definitions
   $ feedeas taste generate -n 3 --mode sequential --json
+  $ feedeas taste feedback --decision accepted --title "Idea title"
+  $ feedeas taste suggest --json
+  $ feedeas taste apply --suggestion <id>
   $ feedeas taste memory query --tag podcast --limit 10
 `);
 if (!process.argv.slice(2).length) {