@koda-sl/baker-cli 0.99.1-dev.5b1957cc → 0.100.0-dev.63a14d2d

package/dist/cli.js

@@ -516,14 +516,140 @@ ${description}`;
   return SCHEDULE_SIGNALS.some((re) => re.test(haystack));
 }
 
+// src/commands/actions/skillCatalog.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+var DESCRIPTION_MAX = 600;
+var SKILLS_SUBPATH = join(".claude", "skills");
+var EXCLUDED_SKILLS = /* @__PURE__ */ new Set(["actions"]);
+function stripQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n");
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/''/g, "'");
+  }
+  return trimmed;
+}
+function extractFrontmatterLines(md) {
+  if (!md.startsWith("---")) return null;
+  const end = md.indexOf("\n---", 3);
+  if (end === -1) return null;
+  return md.slice(md.indexOf("\n", 3) + 1, end).split("\n");
+}
+var BLOCK_SCALAR = /^([|>])[+-]?$/;
+function collectBlockLines(lines, start) {
+  const collected = [];
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") {
+      collected.push("");
+    } else if (/^\s/.test(line)) {
+      collected.push(line.trim());
+    } else {
+      break;
+    }
+  }
+  while (collected.length > 0 && collected.at(-1) === "") collected.pop();
+  return collected;
+}
+function foldLines(collected) {
+  const paragraphs = [];
+  let buffer = [];
+  for (const line of collected) {
+    if (line === "") {
+      if (buffer.length > 0) paragraphs.push(buffer.join(" "));
+      buffer = [];
+    } else {
+      buffer.push(line);
+    }
+  }
+  if (buffer.length > 0) paragraphs.push(buffer.join(" "));
+  return paragraphs.join("\n");
+}
+function readBlockScalar(lines, start, style) {
+  const collected = collectBlockLines(lines, start);
+  return style === "|" ? collected.join("\n") : foldLines(collected);
+}
+function readField(lines, field) {
+  for (let i = 0; i < lines.length; i++) {
+    const match = (lines[i] ?? "").match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match || match[1] !== field) continue;
+    const inline = (match[2] ?? "").trim();
+    const scalar = inline.match(BLOCK_SCALAR);
+    if (scalar) {
+      return readBlockScalar(lines, i + 1, scalar[1]);
+    }
+    return stripQuotes(inline);
+  }
+  return null;
+}
+function parseSkillFrontmatter(md) {
+  const lines = extractFrontmatterLines(md);
+  if (!lines) return null;
+  const name = readField(lines, "name");
+  const description = readField(lines, "description");
+  if (!name || !description) return null;
+  const trimmed = description.length > DESCRIPTION_MAX ? `${description.slice(0, DESCRIPTION_MAX)}\u2026` : description;
+  return { name, description: trimmed };
+}
+function findSkillsDir(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    const candidate = join(dir, SKILLS_SUBPATH);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readSkillCatalog(startDir) {
+  const skillsDir = findSkillsDir(startDir);
+  if (!skillsDir) return [];
+  const entries = [];
+  for (const dirent of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!dirent.isDirectory() || EXCLUDED_SKILLS.has(dirent.name)) continue;
+    const skillFile = join(skillsDir, dirent.name, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    try {
+      const parsed = parseSkillFrontmatter(readFileSync(skillFile, "utf8"));
+      if (parsed) entries.push(parsed);
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+
 // src/commands/actions/claim.ts
 registerSchema({
   command: "actions.claim",
-  description: "Claim an action for the current chat (live \u2014 visible to other chats immediately). Returns action details with tags and description to help decide which skills to load.",
+  description: "Claim an action for the current chat (live \u2014 visible to other chats immediately). Returns action details plus a fast-model recommendation of which skills to load for the work (`recommendedSkills`).",
   args: {
     id: { type: "string", description: "Action ID", required: true }
   }
 });
+async function recommendSkills(actionId) {
+  const skills = readSkillCatalog(process.cwd());
+  if (skills.length === 0) return [];
+  const response = await apiPost(
+    "/api/actions/recommend-skills",
+    { actionId, skills }
+  );
+  return response.data?.recommendations ?? [];
+}
+function buildHints(recommendations) {
+  if (recommendations.length === 0) {
+    return [
+      "Review the action name, description, and tags above \u2014 then load any skills that would help you complete this work."
+    ];
+  }
+  return [
+    "Recommended skills for this action (load the ones you'll use):",
+    ...recommendations.map((r) => `  /${r.name} \u2014 ${r.reason}`),
+    "Suggestions from the action's name/description/tags \u2014 load others if the work needs them."
+  ];
+}
 var claimCommand = defineCommand({
   meta: {
     name: "claim",
@@ -545,10 +671,13 @@ var claimCommand = defineCommand({
         actionId: id,
         chatId
       });
-      const hints = [
-        "Review the action name, description, and tags above \u2014 then load any skills that would help you complete this work."
-      ];
-      writeJson({ ...response, hints });
+      let recommendedSkills = [];
+      try {
+        recommendedSkills = await recommendSkills(id);
+      } catch {
+      }
+      const data = response.data ? { ...response.data, recommendedSkills } : response.data;
+      writeJson({ ok: response.ok, data, hints: buildHints(recommendedSkills) });
     } catch (err) {
       failApi(err);
     }
@@ -1396,12 +1525,12 @@ import { defineCommand as defineCommand19 } from "citty";
 
 // src/commands/ads/cache.ts
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-var CACHE_DIR = join(homedir(), ".baker", "cache", "ads");
+import { join as join2 } from "path";
+var CACHE_DIR = join2(homedir(), ".baker", "cache", "ads");
 function ensureDir(dir) {
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 }
@@ -1409,17 +1538,17 @@ function hashKey(key) {
   return createHash("sha256").update(key).digest("hex").slice(0, 16);
 }
 function cachePath(category, key) {
-  const dir = join(CACHE_DIR, category);
+  const dir = join2(CACHE_DIR, category);
   ensureDir(dir);
-  return join(dir, `${hashKey(key)}.json`);
+  return join2(dir, `${hashKey(key)}.json`);
 }
 function cacheGet(category, key) {
   const path11 = cachePath(category, key);
-  if (!existsSync(path11)) {
+  if (!existsSync2(path11)) {
     return null;
   }
   try {
-    const raw = readFileSync(path11, "utf-8");
+    const raw = readFileSync2(path11, "utf-8");
     const entry = JSON.parse(raw);
     if (entry.expiresAt < Date.now()) {
       rmSync(path11, { force: true });
@@ -3166,7 +3295,7 @@ var library = defineCommand27({
 });
 
 // src/commands/ads/google/query.ts
-import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 import { defineCommand as defineCommand28 } from "citty";
 
@@ -3443,7 +3572,7 @@ function extractFields(rows) {
 function writeRowsToFile(filePath, rows, fields, append) {
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync2(filePath)) {
+    if (!append || !existsSync3(filePath)) {
       writeFileSync2(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -3452,15 +3581,15 @@ function writeRowsToFile(filePath, rows, fields, append) {
 `, "utf-8");
   } else if (ext === "jsonl") {
     const lines = rows.map((row) => JSON.stringify(row));
-    if (append && existsSync2(filePath)) {
+    if (append && existsSync3(filePath)) {
       appendFileSync(filePath, `${lines.join("\n")}
 `, "utf-8");
     } else {
       writeFileSync2(filePath, `${lines.join("\n")}
 `, "utf-8");
     }
-  } else if (append && existsSync2(filePath)) {
-    const existing = JSON.parse(readFileSync2(filePath, "utf-8"));
+  } else if (append && existsSync3(filePath)) {
+    const existing = JSON.parse(readFileSync3(filePath, "utf-8"));
     writeFileSync2(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync2(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -4596,7 +4725,7 @@ Examples \u2014 common AI questions:
 });
 
 // src/commands/ads/linkedin/audience-size.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { defineCommand as defineCommand33 } from "citty";
 function loadTargeting(args) {
   const inline = args.targeting;
@@ -4610,7 +4739,7 @@ function loadTargeting(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync3(file, "utf-8"));
+      return JSON.parse(readFileSync4(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -4789,7 +4918,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/bid-pricing.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { defineCommand as defineCommand35 } from "citty";
 function loadTargeting2(args) {
   const inline = args.targeting;
@@ -4803,7 +4932,7 @@ function loadTargeting2(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync4(file, "utf-8"));
+      return JSON.parse(readFileSync5(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -5367,7 +5496,7 @@ Subcommands:
 });
 
 // src/commands/ads/linkedin/forecast.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { defineCommand as defineCommand43 } from "citty";
 function loadTargeting3(args) {
   const inline = args.targeting;
@@ -5381,7 +5510,7 @@ function loadTargeting3(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync5(file, "utf-8"));
+      return JSON.parse(readFileSync6(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -8849,7 +8978,7 @@ import { defineCommand as defineCommand83 } from "citty";
 import { execFile as execFile2 } from "child_process";
 import { mkdtemp, readdir as readdir2, readFile as readFile4, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 var PYSCENEDETECT_THRESHOLD = 18;
@@ -8892,7 +9021,7 @@ function parsePySceneDetectCsvCuts(csv) {
   return [...new Set(cuts)].sort((a, b) => a - b);
 }
 async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs) {
-  const outDir = await mkdtemp(join2(tmpdir(), "baker-scenedetect-"));
+  const outDir = await mkdtemp(join3(tmpdir(), "baker-scenedetect-"));
   try {
     await execFileAsync2(
       "scenedetect",
@@ -8913,7 +9042,7 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
     );
     const csvName = (await readdir2(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
-    return parsePySceneDetectCsvCuts(await readFile4(join2(outDir, csvName), "utf-8"));
+    return parsePySceneDetectCsvCuts(await readFile4(join3(outDir, csvName), "utf-8"));
   } finally {
     await rm2(outDir, { recursive: true, force: true });
   }
@@ -11012,15 +11141,15 @@ function xfadeSpineArgs(clips) {
   let cur = "c0";
   let accLen = clipInputLen(clips[0]);
   for (let k = 0; k < n - 1; k++) {
-    const join4 = clips[k].out;
+    const join5 = clips[k].out;
     const next = `c${k + 1}`;
     const out = k === n - 2 ? "v" : `j${k + 1}`;
-    if (join4) {
-      const offset = Math.max(0, accLen - join4.dur);
+    if (join5) {
+      const offset = Math.max(0, accLen - join5.dur);
       filt.push(
-        `[${cur}][${next}]xfade=transition=${join4.xfade}:duration=${join4.dur.toFixed(3)}:offset=${offset.toFixed(3)}[${out}]`
+        `[${cur}][${next}]xfade=transition=${join5.xfade}:duration=${join5.dur.toFixed(3)}:offset=${offset.toFixed(3)}[${out}]`
       );
-      accLen = accLen - join4.dur + clipInputLen(clips[k + 1]);
+      accLen = accLen - join5.dur + clipInputLen(clips[k + 1]);
     } else {
       filt.push(`[${cur}][${next}]concat=n=2:v=1[${out}]`);
       accLen += clipInputLen(clips[k + 1]);
@@ -11457,9 +11586,9 @@ function videoReport(input, elementsInput) {
 }
 
 // src/commands/canvas/composition-path.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import path6 from "path";
-function resolveShippedCanvasDir(name, startDir, exists = existsSync3, maxDepth = 8) {
+function resolveShippedCanvasDir(name, startDir, exists = existsSync4, maxDepth = 8) {
   const rel = path6.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
@@ -11969,7 +12098,6 @@ Subcommands:
 import { defineCommand as defineCommand88 } from "citty";
 
 // src/commands/creatives/publish.ts
-import { extname as extname2 } from "path";
 import { defineCommand as defineCommand87 } from "citty";
 
 // src/commands/images/api.ts
@@ -12016,6 +12144,9 @@ async function uploadLocalImage(args, deps = defaultImageApiDeps) {
 function getImage(deps, imageId) {
   return deps.get("/api/images/get", { id: imageId });
 }
+function publishImageAsCreative(deps, args) {
+  return deps.post("/api/creatives/publish", args);
+}
 async function waitForReadyImage(deps, imageId, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? imageProcessingTimeoutMs;
   const pollIntervalMs = opts.pollIntervalMs ?? imageReadyPollIntervalMs;
@@ -12036,222 +12167,93 @@ async function waitForReadyImage(deps, imageId, opts = {}) {
 }
 
 // src/commands/creatives/publish.ts
-var creativeTag = "creative";
-var winningAdsTag = "winning-ads";
-var creativeTags = [creativeTag, winningAdsTag];
-var creativeImageContentTypes = ["image/png", "image/jpeg", "image/webp"];
-var creativeVideoContentTypesByExtension = {
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".webm": "video/webm"
-};
-var videoProcessingTimeoutMs = 5 * 60 * 1e3;
-var videoReadyPollIntervalMs = 5e3;
-var defaultCreativePublishDeps = {
-  ...defaultImageApiDeps,
-  fetch
-};
+var creativeContentTypes = ["image/png", "image/jpeg", "image/webp"];
 registerSchema({
   command: "creatives.publish",
-  description: "Publish a final creative image or video, apply creative and winning-ads tags, and return an asset reference.",
+  description: "Publish a final static creative image to Baker Creatives and return a creative reference.",
   args: {
-    file: { type: "string", description: "Local PNG/JPG/WebP/MP4/MOV/WebM creative path", required: true },
+    file: { type: "string", description: "Local PNG/JPG/WebP creative image path", required: true },
     title: { type: "string", description: "Human title for the creative output", required: true },
-    body: { type: "string", description: "Reference traceability body for the creative output", required: true }
+    context: { type: "string", description: "Optional describe context for the image asset", required: false },
+    sourceReferenceUrl: {
+      type: "string",
+      description: "Optional URL of the original reference ad",
+      required: false
+    }
   }
 });
-function uniqueTags(tags) {
-  return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
-}
-function requiredMetadata(args) {
-  const title = args.title.trim();
-  const body = args.body.trim();
-  if (!title) {
-    throw new ApiError("VALIDATION_ERROR", "--title is required");
-  }
-  if (!body) {
-    throw new ApiError("VALIDATION_ERROR", "--body is required");
-  }
-  return { title, body };
-}
 function detectCreativeContentType(filePath) {
-  const ext = extname2(filePath).toLowerCase();
-  const videoContentType = creativeVideoContentTypesByExtension[ext];
-  if (videoContentType) {
-    return videoContentType;
-  }
   return detectImageContentType(filePath, {
-    allowedContentTypes: creativeImageContentTypes,
-    unsupportedMessage: "Unsupported creative extension. Use PNG, JPG, WebP, MP4, MOV, or WebM."
+    allowedContentTypes: creativeContentTypes,
+    unsupportedMessage: "Unsupported creative image extension. Use PNG, JPG, or WebP."
   });
 }
-function isVideoContentType(contentType) {
-  return contentType.startsWith("video/");
-}
-function imageToCreativeReference(image, title) {
-  if (!image.imageUrl) {
-    throw new ApiError("IMAGE_PROCESSING_ERROR", "Published image is missing imageUrl");
+function parseOptionalUrl(value) {
+  if (value === void 0 || value.trim() === "") {
+    return void 0;
   }
-  const tags = uniqueTags([...image.tags ?? [], ...creativeTags]);
-  return {
-    type: "image",
-    slug: image._id,
-    title,
-    body: image.description,
-    tags,
-    imageUrl: image.imageUrl,
-    thumbnailUrl: image.thumbnailUrl ?? image.imageUrl,
-    storageKey: image.storageKey,
-    width: image.width,
-    height: image.height,
-    aspectRatio: image.aspectRatio,
-    source: image.source
-  };
-}
-function videoToCreativeReference(video, title) {
-  const tags = uniqueTags([...video.tags, ...creativeTags]);
-  return {
-    type: "video",
-    slug: video._id,
-    title,
-    body: video.description,
-    tags,
-    thumbnailUrl: video.thumbnailUrl,
-    muxPlaybackId: video.muxPlaybackId,
-    playbackUrl: video.muxPlaybackId ? `https://stream.mux.com/${video.muxPlaybackId}.m3u8` : void 0,
-    duration: video.duration,
-    width: video.width,
-    height: video.height,
-    aspectRatio: video.aspectRatio,
-    source: video.source
-  };
-}
-async function updateImageMetadata(deps, args) {
-  await deps.post("/api/images/update-description", {
-    imageId: args.imageId,
-    name: args.title,
-    description: args.body,
-    tags: args.tags
-  });
-}
-function createVideoUpload(deps) {
-  return deps.post("/api/videos/upload", {});
-}
-function getVideo(deps, videoId) {
-  return deps.get("/api/videos/get", { id: videoId });
-}
-async function updateVideoMetadata(deps, args) {
-  await deps.post("/api/videos/update-description", {
-    videoId: args.videoId,
-    name: args.title,
-    description: args.body,
-    tags: args.tags
-  });
-}
-async function waitForReadyVideo(deps, videoId, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;
-  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;
-  const deadline = Date.now() + timeoutMs;
-  let lastStatus = "unknown";
-  while (Date.now() <= deadline) {
-    const video = await getVideo(deps, videoId);
-    lastStatus = video.status ?? "unknown";
-    if (video.status === "ready") {
-      return video;
-    }
-    if (video.status === "error") {
-      throw new ApiError(
-        "INTERNAL_ERROR",
-        `Video processing failed for videoId ${videoId}: ${video.errorMessage ?? "unknown error"}`
-      );
-    }
-    await deps.sleep(pollIntervalMs);
+  try {
+    return new URL(value).toString();
+  } catch {
+    throw new ApiError("VALIDATION_ERROR", "--source-reference-url must be a valid URL");
   }
-  throw new ApiError("TIMEOUT", `Video was not ready before timeout; videoId: ${videoId}; last status: ${lastStatus}`);
 }
-async function uploadLocalVideo(args, deps) {
-  const { uploadUrl, videoId } = await createVideoUpload(deps);
-  const fileBuffer = await deps.readFile(args.file);
-  const uploadResponse = await deps.fetch(uploadUrl, {
-    method: "PUT",
-    headers: { "Content-Type": args.contentType },
-    body: fileBuffer
-  });
-  if (!uploadResponse.ok) {
-    throw new ApiError(
-      "INTERNAL_ERROR",
-      `Mux upload failed: HTTP ${uploadResponse.status} ${uploadResponse.statusText}`
-    );
+async function publishCreative(args, deps = defaultImageApiDeps) {
+  const title = args.title.trim();
+  if (!title) {
+    throw new ApiError("VALIDATION_ERROR", "--title is required");
   }
-  return { videoId };
-}
-async function publishCreativeImage(args, deps) {
+  const sourceReferenceUrl = parseOptionalUrl(args.sourceReferenceUrl);
+  const contentType = detectCreativeContentType(args.file);
   const upload = await uploadLocalImage(
     {
       file: args.file,
-      contentType: args.contentType,
+      contentType,
       source: "ai_generated",
-      descriptionContext: args.body
+      descriptionContext: args.context ?? `Static ad creative: ${title}`
     },
     deps
   );
-  const readyImage = await waitForReadyImage(deps, upload.imageId, { timeoutMs: imageProcessingTimeoutMs });
-  const tags = uniqueTags([...readyImage.tags ?? [], ...creativeTags]);
-  await updateImageMetadata(deps, { imageId: upload.imageId, title: args.title, body: args.body, tags });
-  const taggedImage = await getImage(deps, upload.imageId);
-  return {
+  await waitForReadyImage(deps, upload.imageId, { timeoutMs: imageProcessingTimeoutMs });
+  return publishImageAsCreative(deps, {
     imageId: upload.imageId,
-    reference: imageToCreativeReference({ ...readyImage, ...taggedImage }, args.title)
-  };
-}
-async function publishCreativeVideo(args, deps) {
-  const { videoId } = await uploadLocalVideo({ file: args.file, contentType: args.contentType }, deps);
-  const readyVideo = await waitForReadyVideo(deps, videoId);
-  const tags = uniqueTags([...readyVideo.tags, ...creativeTags]);
-  await updateVideoMetadata(deps, { videoId, title: args.title, body: args.body, tags });
-  const taggedVideo = await getVideo(deps, videoId);
-  return { videoId, reference: videoToCreativeReference(taggedVideo, args.title) };
-}
-function publishCreative(args, deps = defaultCreativePublishDeps) {
-  try {
-    const metadata = requiredMetadata(args);
-    const contentType = detectCreativeContentType(args.file);
-    if (isVideoContentType(contentType)) {
-      return publishCreativeVideo({ file: args.file, ...metadata, contentType }, deps);
-    }
-    return publishCreativeImage({ file: args.file, ...metadata, contentType }, deps);
-  } catch (error) {
-    return Promise.reject(error);
-  }
+    title,
+    sourceReferenceUrl
+  });
 }
 var publishCommand = defineCommand87({
   meta: {
     name: "publish",
-    description: "Publish a final creative image or video, tag it as creative and winning-ads, and print the asset reference JSON."
+    description: "Publish a final static creative image to Baker Creatives and print the creative reference JSON."
   },
   args: {
-    file: { type: "positional", description: "Local PNG/JPG/WebP/MP4/MOV/WebM creative path", required: false },
+    file: { type: "positional", description: "Local PNG/JPG/WebP creative image path", required: false },
     title: { type: "string", description: "Human title for the creative output", required: false },
-    body: { type: "string", description: "Reference traceability body for the creative output", required: false }
+    context: { type: "string", description: "Optional describe context for the image asset", required: false },
+    sourceReferenceUrl: {
+      type: "string",
+      description: "Optional URL of the original reference ad",
+      required: false
+    }
   },
   run: async ({ args }) => {
     try {
       const file = args.file;
       const title = args.title;
-      const body = args.body;
       if (!file) {
-        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "File path is required" } });
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Image path is required" } });
         process.exit(1);
       }
       if (!title) {
         writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "--title is required" } });
         process.exit(1);
       }
-      if (!body) {
-        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "--body is required" } });
-        process.exit(1);
-      }
-      const data = await publishCreative({ file, title, body });
+      const data = await publishCreative({
+        file,
+        title,
+        context: args.context,
+        sourceReferenceUrl: args.sourceReferenceUrl
+      });
       writeJson({ ok: true, data });
     } catch (err) {
       if (err instanceof ApiError) {
@@ -12268,13 +12270,12 @@ var publishCommand = defineCommand87({
 var creativesCommand3 = defineCommand88({
   meta: {
     name: "creatives",
-    description: `Publish ad creatives as first-class Baker outputs.
+    description: `Publish static ad creatives as first-class Baker outputs.
 
-Creative handoff:
-  baker creatives publish ./canvas/run/final.png --title "Winning Ads: Offer + Meta 4:5 + Angle" --body "Reference: Advertiser[ad_id]: https://example.com/ad.mp4
-Angle adapted: Client-safe angle"
+Static creative handoff:
+  baker creatives publish ./canvas/run/final.png --title "Spring Offer Static Ad"
 
-Publishing routes images to Images and videos to the video library, applies creative + winning-ads tags, and returns an asset reference for chat previews.`
+Publishing uploads the image to the Company image library, applies the official creative tag, and returns an image reference for chat previews.`
   },
   subCommands: {
     publish: publishCommand
@@ -12456,7 +12457,7 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
 import { defineCommand as defineCommand91 } from "citty";
 
@@ -12530,7 +12531,7 @@ function writeRowsToFile2(filePath, rows, append) {
   const fields = extractFields2(rows);
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync4(filePath)) {
+    if (!append || !existsSync5(filePath)) {
       writeFileSync4(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -12541,13 +12542,13 @@ function writeRowsToFile2(filePath, rows, append) {
     const lines = rows.map((row) => JSON.stringify(row));
     const content = `${lines.join("\n")}
 `;
-    if (append && existsSync4(filePath)) {
+    if (append && existsSync5(filePath)) {
       appendFileSync2(filePath, content, "utf-8");
     } else {
       writeFileSync4(filePath, content, "utf-8");
     }
-  } else if (append && existsSync4(filePath)) {
-    const existing = JSON.parse(readFileSync6(filePath, "utf-8"));
+  } else if (append && existsSync5(filePath)) {
+    const existing = JSON.parse(readFileSync7(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync4(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -12687,7 +12688,7 @@ Examples:
 import { defineCommand as defineCommand96 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
 import { defineCommand as defineCommand93 } from "citty";
 
@@ -12816,7 +12817,7 @@ function writeRowsToFile3(filePath, rows, append) {
   const fields = extractFields3(rows);
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync5(filePath)) {
+    if (!append || !existsSync6(filePath)) {
       writeFileSync5(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -12826,13 +12827,13 @@ function writeRowsToFile3(filePath, rows, append) {
   } else if (ext === "jsonl") {
     const content = `${rows.map((row) => JSON.stringify(row)).join("\n")}
 `;
-    if (append && existsSync5(filePath)) {
+    if (append && existsSync6(filePath)) {
       appendFileSync3(filePath, content, "utf-8");
     } else {
       writeFileSync5(filePath, content, "utf-8");
     }
-  } else if (append && existsSync5(filePath)) {
-    const existing = JSON.parse(readFileSync7(filePath, "utf-8"));
+  } else if (append && existsSync6(filePath)) {
+    const existing = JSON.parse(readFileSync8(filePath, "utf-8"));
     writeFileSync5(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync5(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -13112,7 +13113,7 @@ function cropSprite(input, region) {
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
 import { glob as fsGlob, readFile as readFile10, rename, stat as stat2, writeFile as writeFile4 } from "fs/promises";
-import { dirname, extname as extname3, join as join3, resolve as resolve4 } from "path";
+import { dirname as dirname2, extname as extname2, join as join4, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
 function isRemoteUrl(value) {
@@ -13158,18 +13159,18 @@ async function isDirectory(path11) {
   }
 }
 async function resolveOutputPath(inputPath, outputArg, options) {
-  const base = options.newExtension ? inputPath.slice(0, -extname3(inputPath).length) + options.newExtension : inputPath;
+  const base = options.newExtension ? inputPath.slice(0, -extname2(inputPath).length) + options.newExtension : inputPath;
   if (!outputArg) return base;
   if (options.multipleInputs || await isDirectory(outputArg)) {
     const filename = base.split("/").pop() ?? "out.png";
-    return join3(outputArg, filename);
+    return join4(outputArg, filename);
   }
   return outputArg;
 }
 async function atomicWrite(targetPath, data) {
   const absolute = resolve4(targetPath);
-  const dir = dirname(absolute);
-  const tmp = join3(dir, `.baker-image-${randomBytes(8).toString("hex")}.tmp`);
+  const dir = dirname2(absolute);
+  const tmp = join4(dir, `.baker-image-${randomBytes(8).toString("hex")}.tmp`);
   await writeFile4(tmp, data);
   await rename(tmp, absolute);
 }
@@ -17471,7 +17472,7 @@ var tagsCommand4 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
 import { readFile as readFile12, stat as stat3 } from "fs/promises";
-import { extname as extname4 } from "path";
+import { extname as extname3 } from "path";
 import { defineCommand as defineCommand147 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
@@ -17499,7 +17500,7 @@ registerSchema({
   }
 });
 function detectContentType(filePath) {
-  const ext = extname4(filePath).toLowerCase();
+  const ext = extname3(filePath).toLowerCase();
   const mime = MIME_MAP[ext];
   if (!mime) {
     throw new ApiError("VALIDATION_ERROR", `Cannot detect content type for extension "${ext}". Use --content-type.`);
@@ -17651,7 +17652,6 @@ var advertisersCommand2 = defineCommand149({
 
 // src/commands/winning-ads/search.ts
 import { defineCommand as defineCommand150 } from "citty";
-import { z as z4 } from "zod";
 registerSchema({
   command: "winning-ads.search",
   description: "Search the ad-dna corpus of scored winning ads. Returns a lean shortlist (advertiser, summary, scores, media_url) to pick a reference to reproduce.",
@@ -17759,38 +17759,6 @@ function buildSearchBody(args) {
   }
   return body;
 }
-function toOutputRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return Object.fromEntries(Object.entries(value));
-}
-var winningAdsSearchResponseSchema = z4.object({
-  results: z4.array(z4.unknown()).optional(),
-  pool_size: z4.number().nullable().optional(),
-  match_confidence: z4.string().nullable().optional(),
-  ownAdvertiserExclusion: z4.object({
-    status: z4.enum(["applied", "unresolved", "skipped"]),
-    excludedIds: z4.array(z4.string())
-  }).nullable().optional()
-});
-function parseWinningAdsSearchResponse(data) {
-  const parsed = winningAdsSearchResponseSchema.safeParse(data);
-  if (!parsed.success) {
-    throw new ApiError("INTERNAL_ERROR", "Invalid winning ads search response");
-  }
-  return parsed.data;
-}
-function buildSearchOutputData(data, options) {
-  const rawResults = Array.isArray(data?.results) ? data.results : [];
-  const results = rawResults.map((r) => winningAdNormalizer(toOutputRecord(r), options.full));
-  return {
-    results,
-    pool_size: data?.pool_size ?? null,
-    match_confidence: data?.match_confidence ?? null,
-    ownAdvertiserExclusion: data?.ownAdvertiserExclusion ?? null
-  };
-}
 var searchCommand4 = defineCommand150({
   meta: {
     name: "search",
@@ -17869,12 +17837,19 @@ var searchCommand4 = defineCommand150({
         });
         process.exit(1);
       }
-      const data = parseWinningAdsSearchResponse(await apiPost("/api/winning-ads/search", body));
+      const data = await apiPost(
+        "/api/winning-ads/search",
+        body
+      );
       const output = args.output || "json";
       const full = args.full;
       const rawResults = Array.isArray(data?.results) ? data.results : [];
       if (output === "json") {
-        writeJson({ ok: true, data: buildSearchOutputData(data, { full }) });
+        const results = rawResults.map((r) => winningAdNormalizer(r, full));
+        writeJson({
+          ok: true,
+          data: { results, pool_size: data?.pool_size ?? null, match_confidence: data?.match_confidence ?? null }
+        });
         return;
       }
       writeOutput(
@@ -17920,7 +17895,7 @@ Examples:
 });
 
 // src/version.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 function packageJsonUrl() {
   return new URL("../package.json", import.meta.url);
 }
@@ -17932,7 +17907,7 @@ function parsePackageVersion(raw) {
   throw new Error("Invalid CLI package.json: missing version");
 }
 function getCliVersion() {
-  return parsePackageVersion(readFileSync8(packageJsonUrl(), "utf8"));
+  return parsePackageVersion(readFileSync9(packageJsonUrl(), "utf8"));
 }
 
 // src/cli.ts