@aicopycoders/exodus 2026.6.2400

package/dist/bin/exodus.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import { loadWorkspaceEnv } from "../lib/load-env.js";
+loadWorkspaceEnv();
+import { readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { getVersion } from "../lib/version.js";
+const OTHER_COMMANDS = new Set([
+    "browse",
+    "status",
+    "read-doc",
+    "whoami",
+    "brand",
+    "primer",
+    "foundation",
+    "drive",
+    "doctor",
+    "init",
+    "migrate",
+    "idea",
+]);
+const HIDDEN_COMMANDS = new Set([
+    "creative",
+    "template",
+]);
+const EXAMPLES = [
+    'exodus genesis run --brief "joint pain relief in 30 days" --variants 6',
+    'exodus genesis run --brief brief.txt --seeds seeds.txt',
+    'exodus genesis --list-swipes',
+    'exodus genesis --swipe <id>',
+    'exodus image --ad "grounding sheets reduce inflammation"',
+    'exodus image --type template --input "1. first ad ... 2. second ad ..."',
+    'exodus image --type ref-match --refs k57abc123,k57def456 --subject "morning routine"',
+    'exodus template ad-types',
+    'exodus meme recommend --brief "grounding sheets reduce inflammation"',
+    'exodus meme run --brief "grounding sheets reduce inflammation" --formats \'[...]\'',
+    'exodus browse',
+    'exodus status --id <runId> --type genesis',
+];
+function installedCommands() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const cmdDir = join(here, "..", "commands");
+    try {
+        return readdirSync(cmdDir)
+            .filter((f) => f.endsWith(".js"))
+            .map((f) => f.slice(0, -3));
+    }
+    catch {
+        return [];
+    }
+}
+function summaryOf(helpText) {
+    if (!helpText)
+        return "";
+    const firstLine = helpText.split("\n").map((s) => s.trim()).find(Boolean) ?? "";
+    const m = firstLine.match(/—\s*(.+)$/);
+    return m ? m[1].trim() : "";
+}
+async function buildHelp() {
+    const names = installedCommands().sort();
+    const present = new Set(names);
+    const pipeline = [];
+    const other = [];
+    for (const name of names) {
+        if (HIDDEN_COMMANDS.has(name))
+            continue;
+        let summary = "";
+        try {
+            const mod = await import(`../commands/${name}.js`);
+            summary = summaryOf(mod.helpText);
+        }
+        catch {
+        }
+        (OTHER_COMMANDS.has(name) ? other : pipeline).push([name, summary]);
+    }
+    other.push(["help", "Show this help message"]);
+    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",
+        "  --wait                 Wait for completion (default)",
+        "  --no-wait              Return immediately after starting",
+        "  --help, -h             Show help (top-level or per-subcommand)",
+        "  --version, -v          Print the installed exodus version",
+    ].join("\n");
+    const examples = EXAMPLES.filter((ex) => {
+        const cmd = ex.replace(/^exodus\s+/, "").split(/\s+/)[0];
+        return present.has(cmd);
+    });
+    const sections = [
+        [
+            "exodus — CLI for the Viral Ad Dashboard API",
+            "",
+            "Usage:",
+            "  exodus <command> [options]",
+            "  exodus <command> --help",
+        ].join("\n"),
+        `Pipeline Commands:\n${fmt(pipeline)}`,
+        `Other Commands:\n${fmt(other)}`,
+        commonOptions,
+        `Examples:\n${examples.map((e) => `  ${e}`).join("\n")}`,
+    ];
+    return sections.filter((s) => s.trim() !== "").join("\n\n");
+}
+function parseArgs(argv) {
+    const [, , rawCommand = "help", ...rest] = argv;
+    const command = ["--help", "-h", "-help"].includes(rawCommand) ? "help" : rawCommand;
+    const flags = {};
+    let i = 0;
+    while (i < rest.length) {
+        const arg = rest[i];
+        if (arg === "--help" || arg === "-h") {
+            flags["help"] = true;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = rest[i + 1];
+            if (key.startsWith("no-")) {
+                flags[key.slice(3)] = false;
+                i++;
+            }
+            else if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i += 2;
+            }
+            else {
+                flags[key] = true;
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return { command, flags };
+}
+async function main() {
+    const { command, flags } = parseArgs(process.argv);
+    if (["--version", "-v", "-V", "version"].includes(command)) {
+        console.log(getVersion());
+        process.exit(0);
+    }
+    if (!command || command === "help") {
+        console.log(await buildHelp());
+        process.exit(0);
+    }
+    let commandModule;
+    try {
+        commandModule = await import(`../commands/${command}.js`);
+    }
+    catch {
+        console.error(`Unknown command: "${command}"\n`);
+        console.log(await buildHelp());
+        process.exit(1);
+    }
+    if (flags["help"] === true) {
+        if (commandModule.helpText) {
+            console.log(commandModule.helpText);
+        }
+        else {
+            console.log(`No detailed help is available for "${command}" yet.\n`);
+            console.log(await buildHelp());
+        }
+        process.exit(0);
+    }
+    if (typeof commandModule.run !== "function") {
+        console.error(`Command "${command}" does not export a run() function.`);
+        process.exit(1);
+    }
+    await commandModule.run(flags);
+}
+main().catch((err) => {
+    console.error("Fatal error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/commands/__tests__/genesis.hookgate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/genesis.hookgate.test.js

@@ -0,0 +1,12 @@
+import { describe, it, expect } from "vitest";
+import { buildBriefBody } from "../genesis.js";
+describe("buildBriefBody stopAtHooks", () => {
+    it("omits stopAtHooks when unset", () => {
+        const b = buildBriefBody("brief text", { awarenessLevel: "problem-aware" });
+        expect("stopAtHooks" in b).toBe(false);
+    });
+    it("includes stopAtHooks:true when set", () => {
+        const b = buildBriefBody("brief text", { awarenessLevel: "problem-aware", stopAtHooks: true });
+        expect(b.stopAtHooks).toBe(true);
+    });
+});

package/dist/commands/brand.d.ts

@@ -0,0 +1,24 @@
+export declare const helpText: string;
+interface Brand {
+    id: string;
+    slug: string;
+    name: string;
+    owned?: boolean;
+}
+interface MineResp {
+    role: "admin" | "member" | "unknown";
+    activeBrandId: string | null;
+    activeBrandSlug: string | null;
+    brands: Brand[];
+}
+export declare function fetchMine(): Promise<MineResp>;
+export declare function fetchMineOrThrow(): Promise<MineResp>;
+export declare function refreshBrandProfileMd(opts?: {
+    slug?: string;
+}): Promise<{
+    written: boolean;
+    pathRel: string;
+    reason?: string;
+}>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export {};

package/dist/commands/brand.js

@@ -0,0 +1,292 @@
+import fs from "node:fs";
+import path from "node:path";
+import { apiGetDashboard, apiPostDashboard } from "../lib/client.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";
+const AUTO_END_MARKER = "<!-- exodus:auto-section-end — manual brand notes below survive `brand use` refreshes -->";
+export const helpText = `
+exodus brand — list, switch, and inspect brands available to your CLI
+
+Subcommands:
+  exodus brand list             Show all brands your key has access to
+  exodus brand create "<name>"  Create a new brand you own and switch into it
+  exodus brand use <slug>       Set the active brand for this CLI
+  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)
+
+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
+same brand name). Your key gives access to every brand you own; switch with
+\`brand use\` (admins also see every brand). The only "locked to one brand"
+case is a brand someone ELSE invited you into: you don't own it, so it's the
+single brand your key sees and you can't switch away from it.
+
+When the active brand is set, every CLI command (genesis, image, creative,
+foundation, etc.) targets it via the X-Active-Brand header. In a
+multi-brand install, running a command from inside a brand's subfolder
+targets that brand automatically — the folder wins over \`brand use\`.
+The dashboard's brand-switcher in the top-right is independent — your
+CLI active brand and your dashboard active brand can differ.
+`.trim();
+function fail(msg, code = 1) {
+    console.error(`exodus brand: ${msg}`);
+    process.exit(code);
+}
+export async function fetchMine() {
+    const res = await apiGetDashboard("/api/brands/mine");
+    if (!res.ok) {
+        const body = res.data;
+        fail(body?.hint ?? body?.error ?? `HTTP ${res.status}`);
+    }
+    return res.data;
+}
+export async function fetchMineOrThrow() {
+    const res = await apiGetDashboard("/api/brands/mine");
+    if (!res.ok) {
+        const body = res.data;
+        throw new Error(body?.hint ?? body?.error ?? `HTTP ${res.status}`);
+    }
+    return res.data;
+}
+async function runList() {
+    const data = await fetchMine();
+    const resolved = resolveActiveBrand();
+    const effective = resolved.slug ?? data.activeBrandSlug;
+    if (data.brands.length === 0) {
+        console.log("No brands available for this key.");
+        if (data.role === "member") {
+            console.log("Ask an admin to assign you to a brand in Settings → Team.");
+        }
+        return;
+    }
+    console.log(`\nRole: ${data.role}`);
+    const sourceNote = resolved.source === "folder" ? " (from this brand folder)" : "";
+    console.log(`Active: ${effective ?? "(none — using key default)"}${sourceNote}\n`);
+    const slugWidth = Math.max(...data.brands.map((b) => b.slug.length), 4);
+    for (const b of data.brands) {
+        const marker = b.slug === effective ? "★" : " ";
+        console.log(`  ${marker} ${b.slug.padEnd(slugWidth)}  ${b.name}`);
+    }
+    if (resolved.source === "folder") {
+        const pointer = getActiveBrand();
+        if (pointer && pointer !== resolved.slug) {
+            console.log(`\nNote: you're inside the "${resolved.slug}" brand folder, which`);
+            console.log(`overrides the \`brand use\` pointer ("${pointer}") while you're here.`);
+        }
+    }
+    if (effective && !data.brands.some((b) => b.slug === effective)) {
+        console.log(`\n⚠ Active brand "${effective}" is set locally but you don't have access to it.`);
+        console.log(`  Run \`exodus brand use <slug>\` to pick a different brand,`);
+        console.log(`  or \`exodus brand clear\` to fall back to the key default.`);
+    }
+    console.log("");
+}
+export async function refreshBrandProfileMd(opts) {
+    const res = await apiGetDashboard("/api/brands/profile-md", opts?.slug ? { activeBrandOverride: opts.slug } : undefined);
+    const root = findWorkspaceRoot();
+    const stateDir = brandStateDir({ slug: opts?.slug, root });
+    const filePath = path.join(stateDir, "brand-profile.md");
+    const pathRel = path.relative(root, filePath);
+    if (!res.ok) {
+        const body = res.data;
+        return {
+            written: false,
+            pathRel,
+            reason: body?.hint ?? body?.error ?? `HTTP ${res.status}`,
+        };
+    }
+    const data = res.data;
+    let next;
+    if (!fs.existsSync(filePath)) {
+        next = `${data.autoSection}\n${data.manualTemplate}`;
+    }
+    else {
+        const existing = fs.readFileSync(filePath, "utf-8");
+        const idx = existing.indexOf(AUTO_END_MARKER);
+        if (idx >= 0) {
+            const manual = existing.slice(idx + AUTO_END_MARKER.length);
+            next = `${data.autoSection}${manual}`;
+        }
+        else {
+            next = `${data.autoSection}\n\n${existing.trimStart()}`;
+        }
+    }
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.writeFileSync(filePath, next, "utf-8");
+    return { written: true, pathRel };
+}
+async function runUse(slug) {
+    if (!slug)
+        fail("missing slug. usage: exodus brand use <slug>");
+    const data = await fetchMine();
+    const match = data.brands.find((b) => b.slug === slug);
+    if (!match) {
+        const available = data.brands.map((b) => b.slug).join(", ") || "(none)";
+        fail(`brand "${slug}" is not in your accessible list. available: ${available}`);
+    }
+    setActiveBrand(slug);
+    console.log(`✓ Active brand set to ${slug} (${match.name}).`);
+    const root = findWorkspaceRoot();
+    if (detectLayout(root) === "v2") {
+        const ensured = ensureBrandDir(root, { slug, name: match.name });
+        if (ensured.created) {
+            console.log(`✓ Created brand folder ${path.relative(root, ensured.dir) || ensured.dir}/.`);
+        }
+    }
+    const refresh = await refreshBrandProfileMd({ slug });
+    if (refresh.written) {
+        console.log(`✓ Refreshed ${refresh.pathRel} from the dashboard foundation.`);
+    }
+    else {
+        console.log(`⚠ Could not refresh ${refresh.pathRel}: ${refresh.reason}.`);
+        console.log("  The brand was switched locally; Genesis may use stale brand context");
+        console.log("  until you re-run `exodus brand use` with network access.");
+    }
+    const resolved = resolveActiveBrand();
+    if (resolved.source === "folder" && resolved.slug !== slug) {
+        console.log(`\nHeads up: you're currently inside the "${resolved.slug}" brand folder,`);
+        console.log(`which takes precedence while you're here. Commands run from this folder`);
+        console.log(`still target ${resolved.slug}; run from the install root (or`);
+        console.log(`the ${slug} folder) to target ${slug}.`);
+    }
+}
+async function runCreate(name) {
+    if (!name)
+        fail('missing name. usage: exodus brand create "<name>"');
+    const res = await apiPostDashboard("/api/brands/create", { name });
+    if (!res.ok || !res.data?.slug) {
+        fail(res.data?.error ?? `HTTP ${res.status}`);
+    }
+    const slug = res.data.slug;
+    const createdName = res.data.name ?? name;
+    console.log(`✓ Brand "${createdName}" created (slug: ${slug}).`);
+    setActiveBrand(slug);
+    console.log(`✓ Active brand set to ${slug}.`);
+    const root = findWorkspaceRoot();
+    if (detectLayout(root) === "v2") {
+        const ensured = ensureBrandDir(root, { slug, name: createdName });
+        if (ensured.created) {
+            console.log(`✓ Created brand folder ${path.relative(root, ensured.dir) || ensured.dir}/.`);
+        }
+    }
+    const refresh = await refreshBrandProfileMd({ slug });
+    if (refresh.written) {
+        console.log(`✓ Wrote ${refresh.pathRel}.`);
+    }
+    console.log(`\nNext: set up the brand's primer to unlock the pipelines —\n` +
+        `  say "exodus, set up my brand primer" (or run \`npx @aicopycoders/exodus primer\`).`);
+}
+async function runDelete(slug, flags) {
+    if (!slug)
+        fail("missing slug. usage: exodus brand delete <slug>");
+    const skipConfirm = flags.yes === true || flags.y === true;
+    const purgeLocal = flags["purge-local"] === true || skipConfirm;
+    if (!skipConfirm) {
+        const ok = await confirmSlugTyped(slug);
+        if (!ok) {
+            console.log("Aborted — nothing was deleted.");
+            return;
+        }
+    }
+    const res = await apiPostDashboard("/api/brands/delete", {
+        slug,
+        confirmSlug: slug,
+    });
+    if (!res.ok) {
+        fail(res.data?.error ?? `HTTP ${res.status}`);
+    }
+    console.log(`✓ Brand '${slug}' deleted (server).`);
+    if (getActiveBrand() === slug) {
+        clearActiveBrand();
+        console.log("✓ Cleared local active-brand pointer (it pointed at this brand).");
+    }
+    const root = findWorkspaceRoot();
+    if (detectLayout(root) === "v2") {
+        const dir = brandDirFor(root, slug);
+        if (fs.existsSync(dir)) {
+            const rel = path.relative(root, dir) || dir;
+            const remove = purgeLocal
+                ? true
+                : await promptYesNo(`Also remove the local folder ${rel}/?`, false);
+            if (remove) {
+                fs.rmSync(dir, { recursive: true, force: true });
+                console.log(`✓ Removed local folder ${rel}/.`);
+            }
+            else {
+                console.log(`ℹ Left local folder ${rel}/ in place — delete it yourself if you don't need the files.`);
+            }
+        }
+    }
+}
+async function confirmSlugTyped(slug) {
+    const { createInterface } = await import("node:readline");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(`This permanently deletes the brand "${slug}".\nType "${slug}" to confirm: `, resolve);
+        });
+        return answer.trim() === slug;
+    }
+    finally {
+        rl.close();
+    }
+}
+function runCurrent() {
+    const resolved = resolveActiveBrand();
+    if (resolved.slug) {
+        const source = resolved.source === "folder"
+            ? "from this brand folder"
+            : "from `brand use`";
+        console.log(`${resolved.slug} (${source})`);
+        if (resolved.source === "folder") {
+            const pointer = getActiveBrand();
+            if (pointer && pointer !== resolved.slug) {
+                console.log(`pointer: ${pointer} (overridden while inside this folder)`);
+            }
+        }
+    }
+    else {
+        console.log("(none — falling back to the key's default brand)");
+    }
+}
+function runClear() {
+    clearActiveBrand();
+    console.log("✓ Cleared local active brand. Falling back to the key's default.");
+    const resolved = resolveActiveBrand();
+    if (resolved.source === "folder") {
+        console.log(`Note: you're inside the "${resolved.slug}" brand folder — commands run`);
+        console.log("from here still target it (the folder wins over the pointer).");
+    }
+}
+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 "list":
+        case undefined:
+            await runList();
+            return;
+        case "create":
+            await runCreate(positionals.slice(1).join(" ").trim());
+            return;
+        case "use":
+            await runUse(arg ?? "");
+            return;
+        case "delete":
+            await runDelete(arg ?? "", flags);
+            return;
+        case "current":
+            runCurrent();
+            return;
+        case "clear":
+            runClear();
+            return;
+        default:
+            console.error(`exodus brand: unknown subcommand "${sub}"\n`);
+            console.log(helpText);
+            process.exit(1);
+    }
+}

package/dist/commands/browse.d.ts

@@ -0,0 +1,9 @@
+export declare const helpText: string;
+export declare function computeFetchLimit(userLimit: number, pipeline: string | undefined): number;
+export declare function matchesPipeline(item: Record<string, unknown>, pipeline: string): boolean;
+declare const EXTRA_PIPELINES: readonly ["creative", "template"];
+type ExtraPipeline = (typeof EXTRA_PIPELINES)[number];
+export declare function shouldFetchExtra(filter: string | undefined, pipeline: ExtraPipeline): boolean;
+export declare function resolvePipelineFilter(flags: Record<string, string | boolean>): string | undefined;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export {};

package/dist/commands/browse.js

@@ -0,0 +1,132 @@
+import { apiGet } from "../lib/client.js";
+import { formatBrowse, formatError } from "../lib/format.js";
+export const helpText = `
+exodus browse — List recent pipeline runs (hooks, ads, image concepts, etc.)
+
+Usage:
+  exodus browse [options]
+
+Options:
+  --limit <n>            Max runs to list (default 20)
+  --agent <name>         Filter by agent: genesis | creative | template | meme
+`.trim();
+export function computeFetchLimit(userLimit, pipeline) {
+    if (!pipeline)
+        return userLimit;
+    const overfetch = Math.min(userLimit * 10, 100);
+    return Math.max(userLimit, overfetch);
+}
+export function matchesPipeline(item, pipeline) {
+    const needle = pipeline.toLowerCase();
+    const fields = ["pipeline", "agentName", "agent", "agentId"];
+    for (const f of fields) {
+        const v = item[f];
+        if (typeof v !== "string")
+            continue;
+        const value = v.toLowerCase();
+        if (value === needle || value.startsWith(`${needle}:`) || value.startsWith(`${needle}-`)) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizeCreatedAt(item) {
+    const raw = item["createdAt"] ?? item["_creationTime"];
+    if (typeof raw === "number")
+        return raw;
+    if (typeof raw === "string")
+        return new Date(raw).getTime();
+    return 0;
+}
+const EXTRA_PIPELINES = ["creative", "template"];
+export function shouldFetchExtra(filter, pipeline) {
+    if (!filter)
+        return true;
+    const needle = filter.toLowerCase();
+    if (pipeline === "creative")
+        return needle === "creative" || needle === "meme";
+    return needle === pipeline;
+}
+export function resolvePipelineFilter(flags) {
+    return (flags["agent"] ??
+        flags["pipeline"]);
+}
+async function fetchExtraRuns(pipeline, fetchLimit) {
+    const res = await apiGet(`/api/v2/${pipeline}?limit=${fetchLimit}`);
+    if (!res.ok)
+        return [];
+    const runs = res.data.runs ?? [];
+    return runs.map((r) => {
+        const doc = r.latestDocUrl ??
+            r.phase2DocUrl ??
+            r.userPhase2DocUrl ??
+            r.phase1DocUrl ??
+            r.userPhase1DocUrl ??
+            r.sheetUrl ??
+            undefined;
+        const label = pipeline === "creative" && r.engine === "meme"
+            ? "meme"
+            : pipeline;
+        return {
+            ...r,
+            _id: r.id ?? r._id,
+            agentId: label,
+            pipeline: label,
+            ...(doc ? { googleDocUrl: doc } : {}),
+        };
+    });
+}
+export async function run(flags) {
+    const limit = parseInt(flags["limit"] ?? "20", 10);
+    const pipeline = resolvePipelineFilter(flags);
+    const fetchLimit = computeFetchLimit(limit, pipeline);
+    const genRes = await apiGet(`/api/v2/generations?limit=${fetchLimit}`);
+    if (!genRes.ok) {
+        console.log(formatError(genRes));
+        process.exit(1);
+    }
+    let generations = [];
+    if (Array.isArray(genRes.data)) {
+        generations = genRes.data;
+    }
+    else if (genRes.data &&
+        typeof genRes.data === "object" &&
+        Array.isArray(genRes.data["generations"])) {
+        generations = genRes.data["generations"];
+    }
+    const genesisRes = await apiGet(`/api/v2/genesis?limit=${fetchLimit}`);
+    if (!genesisRes.ok) {
+        console.log(formatError(genesisRes));
+        process.exit(1);
+    }
+    const genesisRuns = genesisRes.data.runs ?? [];
+    const normalizedGenesis = genesisRuns.map((r) => ({
+        ...r,
+        agentName: r.inputMethod ? `genesis:${r.inputMethod}` : "genesis",
+        pipeline: "genesis",
+    }));
+    const extraFetches = await Promise.all(EXTRA_PIPELINES.map((p) => shouldFetchExtra(pipeline, p) ? fetchExtraRuns(p, fetchLimit) : Promise.resolve([])));
+    const all = [
+        ...generations.map((g) => g),
+        ...normalizedGenesis.map((g) => g),
+        ...extraFetches.flat(),
+    ];
+    all.sort((a, b) => normalizeCreatedAt(b) - normalizeCreatedAt(a));
+    const showAll = flags["all"] === true;
+    const STUCK_THRESHOLD_MS = 30 * 60 * 1000;
+    const now = Date.now();
+    const notStuck = showAll
+        ? all
+        : all.filter((g) => {
+            const status = g["status"];
+            if (status !== "running" && status !== "pending")
+                return true;
+            const created = normalizeCreatedAt(g);
+            return created > 0 && now - created < STUCK_THRESHOLD_MS;
+        });
+    const filtered = pipeline
+        ? notStuck.filter((g) => matchesPipeline(g, pipeline))
+        : notStuck;
+    const capped = filtered.slice(0, limit);
+    console.log(formatBrowse(capped));
+}

package/dist/commands/creative.d.ts

@@ -0,0 +1,2 @@
+export declare const helpText: string;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;