@aicopycoders/exodus 2026.7.200-beta.3 → 2026.7.200-beta.4

package/dist/bin/exodus.js

@@ -17,6 +17,7 @@ const OTHER_COMMANDS = new Set([
     "doctor",
     "init",
     "migrate",
+    "segment",
 ]);
 const HIDDEN_COMMANDS = new Set([
     "creative",
@@ -76,7 +77,7 @@ async function buildHelp() {
     const fmt = (rows) => rows.map(([n, s]) => `  ${n.padEnd(18)} ${s}`.trimEnd()).join("\n");
     const commonOptions = [
         "Common Options:",
-        "  --awareness <level>    Awareness level: unaware, problem-aware, solution-aware, product-aware",
+        "  --awareness <level>    Awareness level: unaware, problem-aware, solution-aware, product-aware, most-aware",
         "  --wait                 Wait for completion (default)",
         "  --no-wait              Return immediately after starting",
         "  --help, -h             Show help (top-level or per-subcommand)",

package/dist/commands/brand.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { apiGetDashboard, apiPostDashboard } from "../lib/client.js";
+import { sniffImageType, BRAND_IMAGE_MAX_BYTES } from "../lib/image-sniff.js";
 import { getActiveBrand, setActiveBrand, clearActiveBrand, findWorkspaceRoot, } from "../lib/state.js";
 import { detectLayout, ensureBrandDir, resolveActiveBrand, brandStateDir, brandDirFor, } from "../lib/layout.js";
 import { promptYesNo } from "../lib/prompts.js";
@@ -15,6 +16,9 @@ Subcommands:
   exodus brand current          Print the active brand
   exodus brand clear            Stop overriding the brand (use the key's default)
   exodus brand delete <slug>    Delete a brand you own (asks before removing the local folder)
+  exodus brand images add <files...> --kind founder|product|reference
+                                Upload brand-identity images (png/jpg/webp, max 15MB each)
+  exodus brand images list      Show the active brand's uploaded identity images
 
 Any user can create and own unlimited brands (\`brand create\`) — you do NOT
 need to be an admin, and brands are scoped to you (two users can have the
@@ -260,11 +264,166 @@ function runClear() {
         console.log("from here still target it (the folder wins over the pointer).");
     }
 }
+const BRAND_IMAGE_KINDS = ["founder", "product", "reference"];
+async function runImagesAdd(files, flags) {
+    const kind = typeof flags["kind"] === "string" ? flags["kind"] : "";
+    if (!BRAND_IMAGE_KINDS.includes(kind)) {
+        console.error(`Error: brand images add requires --kind ${BRAND_IMAGE_KINDS.join("|")}. ` +
+            `(Logo stays a dashboard upload — it replaces rather than appends.)`);
+        process.exit(1);
+        return;
+    }
+    if (files.length === 0) {
+        console.error("Error: brand images add requires at least one file.");
+        process.exit(1);
+        return;
+    }
+    const valid = [];
+    const skipped = [];
+    for (const file of files) {
+        let buf;
+        try {
+            buf = fs.readFileSync(file);
+        }
+        catch {
+            skipped.push({ file, reason: "unreadable (does the path exist?)" });
+            continue;
+        }
+        if (buf.length > BRAND_IMAGE_MAX_BYTES) {
+            skipped.push({
+                file,
+                reason: `too large (${(buf.length / 1024 / 1024).toFixed(1)}MB > 15MB)`,
+            });
+            continue;
+        }
+        const sniffed = sniffImageType(buf);
+        if (!sniffed) {
+            skipped.push({ file, reason: "not a png/jpg/webp (content check failed)" });
+            continue;
+        }
+        valid.push({ file, buf, mime: sniffed.mime });
+    }
+    for (const s of skipped) {
+        console.error(`  skipped ${path.basename(s.file)}: ${s.reason}`);
+    }
+    if (valid.length === 0) {
+        console.error("Error: no valid image files to upload.");
+        process.exit(1);
+        return;
+    }
+    const mint = await apiPostDashboard("/api/brands/images/upload-url", { count: valid.length });
+    if (!mint.ok || !Array.isArray(mint.data.urls)) {
+        console.error(`Error: ${mint.data.error ?? `HTTP ${mint.status} minting upload URLs`}`);
+        process.exit(1);
+        return;
+    }
+    const storageIds = [];
+    const uploadedFiles = [];
+    for (let i = 0; i < valid.length; i++) {
+        const { file, buf, mime } = valid[i];
+        try {
+            const res = await fetch(mint.data.urls[i], {
+                method: "POST",
+                headers: { "Content-Type": mime },
+                body: new Uint8Array(buf),
+            });
+            const body = JSON.parse(await res.text());
+            if (!res.ok || !body.storageId)
+                throw new Error(`HTTP ${res.status}`);
+            storageIds.push(body.storageId);
+            uploadedFiles.push(file);
+        }
+        catch (err) {
+            console.error(`  skipped ${path.basename(file)}: storage upload failed (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    if (storageIds.length === 0) {
+        console.error("Error: every storage upload failed.");
+        process.exit(1);
+        return;
+    }
+    const attach = await apiPostDashboard("/api/brands/images", {
+        kind,
+        storageIds,
+    });
+    if (!attach.ok) {
+        console.error(`Error: ${attach.data.error ?? `HTTP ${attach.status} attaching images`}`);
+        process.exit(1);
+        return;
+    }
+    for (const s of attach.data.skipped ?? []) {
+        console.error(`  server skipped ${s.storageId}: ${s.reason}`);
+    }
+    for (const f of uploadedFiles)
+        console.log(`  uploaded ${path.basename(f)}`);
+    console.log(`✓ ${kind}: ${attach.data.added} added (brand now has ${attach.data.total} ${kind} image${attach.data.total === 1 ? "" : "s"})`);
+}
+async function runImagesList() {
+    const res = await apiGetDashboard("/api/brands/images");
+    if (!res.ok) {
+        console.error(`Error: ${res.data.error ?? `HTTP ${res.status}`}`);
+        process.exit(1);
+        return;
+    }
+    console.log(`brand: ${res.data.brand}`);
+    for (const kind of BRAND_IMAGE_KINDS) {
+        const entries = res.data[kind] ?? [];
+        console.log(`${kind}: ${entries.length}`);
+        for (const e of entries) {
+            console.log(`  ${e.url ?? e.storageId}`);
+        }
+    }
+}
+function imagesPositionals() {
+    const rest = process.argv.slice(3);
+    const out = [];
+    let i = 0;
+    while (i < rest.length) {
+        const arg = rest[i];
+        if (arg === "--help" || arg === "-h") {
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = rest[i + 1];
+            if (key.startsWith("no-")) {
+                i++;
+            }
+            else if (next !== undefined && !next.startsWith("--")) {
+                i += 2;
+            }
+            else {
+                i++;
+            }
+            continue;
+        }
+        out.push(arg);
+        i++;
+    }
+    return out;
+}
+async function runImages(args, flags) {
+    const sub = args[0];
+    if (sub === "add") {
+        await runImagesAdd(args.slice(1), flags);
+        return;
+    }
+    if (sub === "list" || sub === undefined) {
+        await runImagesList();
+        return;
+    }
+    console.error(`exodus brand images: unknown subcommand "${sub}" (use add | list)`);
+    process.exit(1);
+}
 export async function run(flags) {
     const positionals = process.argv.slice(3).filter((a) => !a.startsWith("--"));
     const sub = positionals[0];
     const arg = positionals[1];
     switch (sub) {
+        case "images":
+            await runImages(imagesPositionals().slice(1), flags);
+            return;
         case "list":
         case undefined:
             await runList();

package/dist/commands/genesis.js

@@ -22,7 +22,7 @@ Options:
   --seeds <file|"text">       Per-run creative seeds. File: one per line OR a
                               JSON array. Inline: a single seed.
   --steering "<text>"         With regenerate: re-roll guidance for the hook pool.
-  --awareness <level>         unaware | problem-aware (default) | solution-aware | product-aware
+  --awareness <level>         unaware | problem-aware (default) | solution-aware | product-aware | most-aware
   --passes <n>                Writing passes per bot — Mario + Infeed (1-5, default 1 = 2 variants)
   --variants <n>              Advanced: raw total variant count (1-10); overrides --passes
   --ad-account <id>           Meta ad account ID for the top-ads-biased track

package/dist/commands/primer.js

@@ -36,8 +36,8 @@ Genesis writer for that primer honors it on every run.
 
   <lane> is one of: bodyUnaware | bodyAware | hooks | headlines
   (aliases: body-unaware/unaware/problem-aware, body-aware/solution-aware/
-   product-aware, hook, headline). Setting just one of --always / --never
-   leaves the other field as-is.
+   product-aware/most-aware, hook, headline). Setting just one of --always /
+   --never leaves the other field as-is.
 
 Interactive build flags:
   --file <path>   Read the submission (winning ads + product info) from a file
@@ -397,6 +397,8 @@ const LANE_ALIASES = {
     solutionaware: "bodyAware",
     "product-aware": "bodyAware",
     productaware: "bodyAware",
+    "most-aware": "bodyAware",
+    mostaware: "bodyAware",
     hooks: "hooks",
     hook: "hooks",
     headlines: "headlines",

package/dist/commands/segment.d.ts

@@ -0,0 +1,57 @@
+export declare const helpText: string;
+interface NValue {
+    slug: string;
+    name: string;
+}
+interface MapOutcome {
+    slug: string;
+    name: string;
+    lens?: "Type" | "Location" | "Function" | "Moment" | "Severity";
+    subs: NValue[];
+}
+interface MapGroup {
+    name: string;
+    values: NValue[];
+}
+export interface SegmentMap {
+    productWord: string;
+    brandLabel: string;
+    outcomes: MapOutcome[];
+    demoGroups: MapGroup[];
+    facetFamilies: MapGroup[];
+}
+export interface ImportSummary {
+    added: string[];
+    keptRenamed: string[];
+    deleted: string[];
+    subsDeleted: string[];
+    demoValuesDeleted: string[];
+    facetValuesDeleted: string[];
+    personasArchived: string[];
+    personasDeleted: string[];
+}
+export declare function asSummary(data: unknown): ImportSummary;
+export declare function isDestructive(summary: ImportSummary): boolean;
+export declare function formatImportSummary(summary: ImportSummary): string;
+export declare function formatMapSummary(map: SegmentMap): string;
+export interface ImportDeps {
+    post: (path: string, body: unknown) => Promise<{
+        ok: boolean;
+        status: number;
+        data: unknown;
+    }>;
+    readFile: (path: string) => string;
+}
+export interface ImportFlowResult {
+    code: number;
+    lines: string[];
+    calls: Array<{
+        dryRun: boolean;
+    }>;
+}
+export declare function importFlow(file: string, opts: {
+    yes: boolean;
+    json: boolean;
+}, deps: ImportDeps): Promise<ImportFlowResult>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export {};

package/dist/commands/segment.js

@@ -0,0 +1,274 @@
+import fs from "node:fs";
+import { apiGet, apiPost } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+export const helpText = `
+exodus segment — Segment map + personas (WHAT / WHO / WHY), agentic I/O
+
+The JSON contract is the edit surface: export the map, edit the file, import it
+back. Import is a FULL REPLACE, slug-stable by name-match — existing outcomes and
+values keep their slugs, new names get new ones, and names absent from the file
+are deleted. Personas the new map orphans are ARCHIVED (never deleted).
+
+Usage:
+  exodus segment show                       Human-readable summary of the map
+  exodus segment show --json                Raw normalized map JSON
+  exodus segment export [--out <file>]      Contract JSON (map + personas) to stdout or a file
+  exodus segment import <file> [--yes]      Import a contract JSON file (dry-run first)
+  exodus segment personas                   List saved personas (incl. archived)
+  exodus segment personas --json            Raw persona list JSON
+
+Flags:
+  --json                 Machine-readable JSON output (show / personas)
+  --out <file>           Write export to a file instead of stdout
+  --yes                  Apply a destructive import (deletes segments / archives personas)
+
+Notes:
+  • All operations scope to your active brand. Check with: exodus brand current
+  • 'import' ALWAYS previews via a server dry-run first and prints what would
+    change. If anything would be deleted at ANY layer (outcome, sub-slice,
+    demo/facet value) or a persona archived/deleted, it refuses to apply
+    without --yes and exits non-zero (never prompts — agents hang on prompts).
+  • 'import' on a workspace with no map yet just creates it.
+  • 'export' output imports back unchanged — it is the contract document.
+
+Examples:
+  exodus segment show
+  exodus segment export --out segments.json
+  exodus segment import segments.json
+  exodus segment import segments.json --yes
+  exodus segment personas --json
+`.trim();
+export function asSummary(data) {
+    const d = (typeof data === "object" && data !== null ? data : {});
+    const list = (v) => (Array.isArray(v) ? v : []);
+    return {
+        added: list(d.added),
+        keptRenamed: list(d.keptRenamed),
+        deleted: list(d.deleted),
+        subsDeleted: list(d.subsDeleted),
+        demoValuesDeleted: list(d.demoValuesDeleted),
+        facetValuesDeleted: list(d.facetValuesDeleted),
+        personasArchived: list(d.personasArchived),
+        personasDeleted: list(d.personasDeleted),
+    };
+}
+export function isDestructive(summary) {
+    return (summary.deleted.length > 0 ||
+        summary.subsDeleted.length > 0 ||
+        summary.demoValuesDeleted.length > 0 ||
+        summary.facetValuesDeleted.length > 0 ||
+        summary.personasArchived.length > 0 ||
+        summary.personasDeleted.length > 0);
+}
+function line(label, names) {
+    const detail = names.length > 0 ? `  (${names.join(", ")})` : "";
+    return `  ${label.padEnd(24)} ${String(names.length).padStart(3)}${detail}`;
+}
+export function formatImportSummary(summary) {
+    return [
+        "Import preview:",
+        line("+ outcomes added", summary.added),
+        line("~ outcomes kept", summary.keptRenamed),
+        line("- outcomes deleted", summary.deleted),
+        line("- subs deleted", summary.subsDeleted),
+        line("- demo values deleted", summary.demoValuesDeleted),
+        line("- facet values deleted", summary.facetValuesDeleted),
+        line("personas archived", summary.personasArchived),
+        line("personas deleted", summary.personasDeleted),
+    ].join("\n");
+}
+export function formatMapSummary(map) {
+    const lines = [];
+    lines.push(`Segment map — ${map.brandLabel} (product: ${map.productWord})`);
+    lines.push(`\nOutcomes (${map.outcomes.length}):`);
+    for (const o of map.outcomes) {
+        const lens = o.lens ? ` [${o.lens}]` : "";
+        const subs = o.subs.length > 0 ? `  · subs: ${o.subs.map((s) => s.name).join(", ")}` : "";
+        lines.push(`  ${o.slug.padEnd(24)} ${o.name}${lens}${subs}`);
+    }
+    const groupBlock = (title, groups) => {
+        lines.push(`\n${title}:`);
+        for (const g of groups) {
+            const vals = g.values.length > 0 ? g.values.map((val) => val.name).join(", ") : "—";
+            lines.push(`  ${g.name} (${g.values.length}): ${vals}`);
+        }
+    };
+    groupBlock("Demographics (WHO)", map.demoGroups);
+    groupBlock("Facets (WHY)", map.facetFamilies);
+    return lines.join("\n");
+}
+const IMPORT_PATH = "/api/v2/segments/import";
+export async function importFlow(file, opts, deps) {
+    const calls = [];
+    let text;
+    try {
+        text = deps.readFile(file);
+    }
+    catch {
+        return { code: 1, lines: [`Error: file not found: ${file}`], calls };
+    }
+    let contract;
+    try {
+        contract = JSON.parse(text);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { code: 1, lines: [`Error: ${file} is not valid JSON: ${msg}`], calls };
+    }
+    if (typeof contract !== "object" || contract === null || Array.isArray(contract)) {
+        return { code: 1, lines: [`Error: ${file} is not a segment map (expected a JSON object).`], calls };
+    }
+    const clean = { ...contract };
+    delete clean.dryRun;
+    calls.push({ dryRun: true });
+    const dry = await deps.post(IMPORT_PATH, { ...clean, dryRun: true });
+    if (!dry.ok) {
+        const lines = opts.json
+            ? [JSON.stringify({ ok: false, status: dry.status, data: dry.data })]
+            : [formatError({ ok: dry.ok, status: dry.status, data: dry.data })];
+        return { code: 1, lines, calls };
+    }
+    const summary = asSummary(dry.data);
+    const destructive = isDestructive(summary);
+    if (destructive && !opts.yes) {
+        const lines = opts.json
+            ? [JSON.stringify({ ok: false, applied: false, destructive: true, summary })]
+            : [
+                formatImportSummary(summary),
+                "",
+                "This import is destructive (deletes outcomes, sub-slices, or values,",
+                "and/or archives or deletes personas). Re-run with --yes to apply it.",
+            ];
+        return { code: 1, lines, calls };
+    }
+    calls.push({ dryRun: false });
+    const real = await deps.post(IMPORT_PATH, clean);
+    if (!real.ok) {
+        const lines = opts.json
+            ? [JSON.stringify({ ok: false, status: real.status, data: real.data })]
+            : [formatError({ ok: real.ok, status: real.status, data: real.data })];
+        return { code: 1, lines, calls };
+    }
+    const applied = asSummary(real.data);
+    const lines = opts.json
+        ? [JSON.stringify({ ok: true, applied: true, destructive, summary: applied })]
+        : [formatImportSummary(applied), "", "Imported."];
+    return { code: 0, lines, calls };
+}
+export async function run(flags) {
+    const positional = parsePositional();
+    const [sub, ...rest] = positional;
+    if (!sub || sub === "show")
+        return runShow(flags);
+    if (sub === "export")
+        return runExport(flags);
+    if (sub === "import")
+        return runImport(rest, flags);
+    if (sub === "personas")
+        return runPersonas(flags);
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}
+function parsePositional() {
+    const args = process.argv.slice(3);
+    const out = [];
+    let i = 0;
+    while (i < args.length) {
+        const a = args[i];
+        if (a.startsWith("--")) {
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                i += 2;
+            }
+            else {
+                i++;
+            }
+            continue;
+        }
+        out.push(a);
+        i++;
+    }
+    return out;
+}
+async function runShow(flags) {
+    const json = !!flags["json"];
+    const res = await apiGet("/api/v2/segments");
+    if (!res.ok) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, status: res.status, data: res.data }));
+        else
+            console.log(formatError(res));
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify(res.data.map));
+        return;
+    }
+    if (!res.data.map) {
+        console.log("No segment map yet for the active brand.");
+        console.log("Build one and import it:  exodus segment import <file>");
+        return;
+    }
+    console.log(formatMapSummary(res.data.map));
+}
+async function runExport(flags) {
+    const out = typeof flags["out"] === "string" ? flags["out"] : undefined;
+    const res = await apiGet("/api/v2/segments/export");
+    if (!res.ok) {
+        console.log(formatError(res));
+        process.exit(1);
+    }
+    const doc = JSON.stringify(res.data, null, 2);
+    if (out) {
+        fs.writeFileSync(out, doc + "\n", "utf-8");
+        console.log(`Wrote segment contract to ${out}.`);
+        return;
+    }
+    console.log(doc);
+}
+async function runImport(positional, flags) {
+    const file = positional[0];
+    if (!file) {
+        console.error("Error: a contract JSON file is required");
+        console.log("Usage: exodus segment import <file> [--yes]");
+        process.exit(1);
+    }
+    const result = await importFlow(file, { yes: !!flags["yes"], json: !!flags["json"] }, {
+        post: (path, body) => apiPost(path, body),
+        readFile: (p) => fs.readFileSync(p, "utf-8"),
+    });
+    for (const l of result.lines)
+        console.log(l);
+    if (result.code !== 0)
+        process.exit(result.code);
+}
+async function runPersonas(flags) {
+    const json = !!flags["json"];
+    const res = await apiGet("/api/v2/segments/personas");
+    if (!res.ok) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, status: res.status, data: res.data }));
+        else
+            console.log(formatError(res));
+        process.exit(1);
+    }
+    const personas = res.data.personas ?? [];
+    if (json) {
+        console.log(JSON.stringify({ personas }));
+        return;
+    }
+    if (personas.length === 0) {
+        console.log("No personas saved yet for the active brand.");
+        return;
+    }
+    console.log(`Personas (${personas.length}):`);
+    for (const p of personas) {
+        const tag = p.archived ? "  [archived]" : "";
+        const code = p.code ? `${p.code}  ` : "";
+        const type = p.type ? `  (${p.type})` : "";
+        console.log(`  ${code}${p.name}${type}${tag}`);
+        if (p.description)
+            console.log(`    ${p.description}`);
+    }
+}

package/dist/lib/image-sniff.d.ts

@@ -0,0 +1,6 @@
+export declare const BRAND_IMAGE_MAX_BYTES: number;
+export interface SniffedImageType {
+    ext: "png" | "jpg" | "webp";
+    mime: "image/png" | "image/jpeg" | "image/webp";
+}
+export declare function sniffImageType(buf: Uint8Array): SniffedImageType | null;

package/dist/lib/image-sniff.js

@@ -0,0 +1,18 @@
+export const BRAND_IMAGE_MAX_BYTES = 15 * 1024 * 1024;
+export function sniffImageType(buf) {
+    if (buf.length >= 8) {
+        const png = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+        if (png.every((b, i) => buf[i] === b)) {
+            return { ext: "png", mime: "image/png" };
+        }
+    }
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+        return { ext: "jpg", mime: "image/jpeg" };
+    }
+    if (buf.length >= 12 &&
+        buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 &&
+        buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50) {
+        return { ext: "webp", mime: "image/webp" };
+    }
+    return null;
+}

package/dist/lib/template-constants.d.ts

@@ -1,4 +1,4 @@
-export declare const AD_TYPES: readonly ["before-after", "native-news", "testimonial", "bold", "meme", "screenshot", "hero", "holding-sign", "handwritten", "comment", "breaking-news", "lofi", "comparison", "infographic", "headline", "collage", "product-breakdown", "scientific", "animation", "founder-note", "carousel", "statistics", "post-it-notes", "happy-avatar", "problem-solution", "writing-on-body", "multi-testimonial", "receipt", "step-by-step", "sale-promotional-offer", "cost-of-inaction", "ugc", "quiz-interactive", "action-figure", "at-home-routine", "billboard", "black-and-white", "blurred", "choose", "cutout", "drawing", "facetime", "marker", "notes", "photo", "quadrant", "search", "thumbnail", "xray", "zoom-bubble"];
+export declare const AD_TYPES: readonly ["before-after", "native-news", "testimonial", "bold", "meme", "screenshot", "hero", "holding-sign", "handwritten", "comment", "breaking-news", "lofi", "comparison", "infographic", "headline", "collage", "product-breakdown", "scientific", "animation", "founder-note", "carousel", "statistics", "post-it-notes", "happy-avatar", "problem-solution", "writing-on-body", "multi-testimonial", "receipt", "step-by-step", "sale-promotional-offer", "cost-of-inaction", "ugc", "quiz-interactive", "action-figure", "at-home-routine", "billboard", "black-and-white", "blurred", "choose", "cutout", "drawing", "facetime", "marker", "notes", "photo", "quadrant", "search", "thumbnail", "xray", "zoom-bubble", "advice-cacophony", "annotated-testimonial", "body-morph", "body-portal", "bundle-showcase", "clay-world", "colossus-product", "cost-receipt", "cultural-icon-dressup", "effect-field", "fine-art-intervention", "flavor-story", "giant-tiny", "half-face-reveal", "hero-vs-villain", "horror-illustration", "horror-object-interior", "illustrated-cutaway", "impossible-physics", "ingredient-warrior", "lifestyle-colorway-array", "material-state", "mirror-reveal", "object-launch", "organ-buddy", "polaroid-sticky", "pop-art-comic", "product-as-body", "product-as-hero", "retro-game-screen", "sequential-state-strip", "sketch-equation", "spotlight-hero", "stat-surround-flatlay", "stat-surround-hero", "street-find", "street-poster", "stuffed-container", "surrogate-character", "symbol-swap", "symptom-collage", "threat-map", "tiny-universe", "tiny-world", "toxic-assemblage", "toxic-emanation", "trophy-moment", "villain-pour", "vintage-reframe", "whiteboard", "zipper-reveal"];
 export type AdType = (typeof AD_TYPES)[number];
 export declare const AD_TYPE_NAMES: Record<AdType, string>;
 export declare const REPTILE_TRIGGERS: readonly ["ultra-real", "bizarre", "voyeur", "suffering", "gory", "sexual", "primal-fear", "odd-contrast", "inside-joke", "time-warp", "victory-lap", "selfie", "uncanny-objects"];

package/dist/lib/template-constants.js

@@ -49,6 +49,57 @@ export const AD_TYPES = [
     "thumbnail",
     "xray",
     "zoom-bubble",
+    "advice-cacophony",
+    "annotated-testimonial",
+    "body-morph",
+    "body-portal",
+    "bundle-showcase",
+    "clay-world",
+    "colossus-product",
+    "cost-receipt",
+    "cultural-icon-dressup",
+    "effect-field",
+    "fine-art-intervention",
+    "flavor-story",
+    "giant-tiny",
+    "half-face-reveal",
+    "hero-vs-villain",
+    "horror-illustration",
+    "horror-object-interior",
+    "illustrated-cutaway",
+    "impossible-physics",
+    "ingredient-warrior",
+    "lifestyle-colorway-array",
+    "material-state",
+    "mirror-reveal",
+    "object-launch",
+    "organ-buddy",
+    "polaroid-sticky",
+    "pop-art-comic",
+    "product-as-body",
+    "product-as-hero",
+    "retro-game-screen",
+    "sequential-state-strip",
+    "sketch-equation",
+    "spotlight-hero",
+    "stat-surround-flatlay",
+    "stat-surround-hero",
+    "street-find",
+    "street-poster",
+    "stuffed-container",
+    "surrogate-character",
+    "symbol-swap",
+    "symptom-collage",
+    "threat-map",
+    "tiny-universe",
+    "tiny-world",
+    "toxic-assemblage",
+    "toxic-emanation",
+    "trophy-moment",
+    "villain-pour",
+    "vintage-reframe",
+    "whiteboard",
+    "zipper-reveal",
 ];
 export const AD_TYPE_NAMES = {
     "before-after": "Before / After",
@@ -101,6 +152,57 @@ export const AD_TYPE_NAMES = {
     thumbnail: "Thumbnail",
     xray: "X-ray",
     "zoom-bubble": "Zoom Bubble",
+    "advice-cacophony": "Advice Cacophony",
+    "annotated-testimonial": "Highlighted / Annotated Testimonial",
+    "body-morph": "Body Morph",
+    "body-portal": "Body Portal",
+    "bundle-showcase": "Bundle Showcase + Benefit Bar",
+    "clay-world": "Clay World",
+    "colossus-product": "Colossus Product",
+    "cost-receipt": "Cost Receipt",
+    "cultural-icon-dressup": "Cultural Icon Dress-Up",
+    "effect-field": "Effect Field",
+    "fine-art-intervention": "Fine Art Intervention",
+    "flavor-story": "Flavor Story / Tastes Like",
+    "giant-tiny": "Giant / Tiny",
+    "half-face-reveal": "Half-Face Reveal",
+    "hero-vs-villain": "Hero vs Villain",
+    "horror-illustration": "Horror Illustration",
+    "horror-object-interior": "Horror Object Interior",
+    "illustrated-cutaway": "Illustrated Cutaway",
+    "impossible-physics": "Impossible Physics",
+    "ingredient-warrior": "Ingredient Warrior",
+    "lifestyle-colorway-array": "Lifestyle Action + Product Colorway Array",
+    "material-state": "Material State",
+    "mirror-reveal": "Mirror Reveal",
+    "object-launch": "Object Launch",
+    "organ-buddy": "Organ Buddy",
+    "polaroid-sticky": "Polaroid + Sticky",
+    "pop-art-comic": "Pop Art / Comic",
+    "product-as-body": "Product as Body",
+    "product-as-hero": "Product as Hero",
+    "retro-game-screen": "Retro Game Screen",
+    "sequential-state-strip": "Sequential State Strip",
+    "sketch-equation": "Sketch Equation",
+    "spotlight-hero": "Spotlight Hero",
+    "stat-surround-flatlay": "Stat Surround / Callout Radial (Lifestyle Flatlay)",
+    "stat-surround-hero": "Stat Surround / Callout Radial (Product Hero)",
+    "street-find": "Street Find",
+    "street-poster": "Street Poster",
+    "stuffed-container": "Stuffed Container",
+    "surrogate-character": "Surrogate Character",
+    "symbol-swap": "Symbol Swap",
+    "symptom-collage": "Symptom Collage",
+    "threat-map": "Threat Map",
+    "tiny-universe": "Tiny Universe",
+    "tiny-world": "Tiny World",
+    "toxic-assemblage": "Toxic Assemblage",
+    "toxic-emanation": "Toxic Emanation",
+    "trophy-moment": "Trophy Moment",
+    "villain-pour": "Villain Pour",
+    "vintage-reframe": "Vintage Reframe",
+    "whiteboard": "Whiteboard",
+    "zipper-reveal": "Zipper Reveal",
 };
 export const REPTILE_TRIGGERS = [
     "ultra-real",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicopycoders/exodus",
-  "version": "2026.7.200-beta.3",
+  "version": "2026.7.200-beta.4",
   "description": "CLI + Claude Code skills for the Copycoders Exodus ad pipeline",
   "repository": {
     "type": "git",