@aicopycoders/exodus 2026.7.200-beta.8 → 2026.8.1100

package/dist/bin/exodus.js

@@ -16,9 +16,12 @@ const OTHER_COMMANDS = new Set([
     "drive",
     "doctor",
     "init",
+    "update",
     "migrate",
     "segment",
     "workflow",
+    "session",
+    "bank",
 ]);
 const HIDDEN_COMMANDS = new Set([
     "creative",

package/dist/commands/bank.d.ts

@@ -0,0 +1,88 @@
+import { type ApiResponse } from "../lib/client.js";
+import { type Channel } from "../lib/channel.js";
+export declare const helpText: string;
+export declare const AWARENESS_PAIRS: readonly ["unawareProblemAware", "solutionProductAware", "mostAware"];
+export type AwarenessPair = (typeof AWARENESS_PAIRS)[number];
+export interface BankSummary {
+    key: string;
+    name: string;
+    type: string;
+    awarenessPair?: AwarenessPair;
+    entryCount: number;
+}
+export interface BankWinMetrics {
+    spend?: number;
+    roas?: number;
+    ctr?: number;
+    note?: string;
+}
+export interface BankProvenance {
+    workflowRunId?: string;
+    genesisRunId?: string;
+    nodeId?: string;
+    variantIndex?: number;
+    artifactKind?: string;
+}
+export interface BankEntry {
+    _id: string;
+    text: string;
+    source: string;
+    awarenessPair?: AwarenessPair;
+    winMetrics?: BankWinMetrics;
+    humanEdited?: boolean;
+    provenance?: BankProvenance;
+    createdAt: number | string;
+}
+export interface BankShowResponse {
+    bank: {
+        key: string;
+        name: string;
+        type: string;
+        awarenessPair?: AwarenessPair;
+    };
+    entries: BankEntry[];
+}
+export interface BankPromoteBody {
+    bankKey: string;
+    text: string;
+    awarenessPair?: AwarenessPair;
+    winMetrics?: BankWinMetrics;
+    provenance?: BankProvenance;
+}
+export interface BankPromoteResponse {
+    entryId: string;
+    bankName: string;
+    event?: string;
+}
+export interface FlowResult {
+    code: number;
+    lines: string[];
+}
+export interface BankDeps {
+    get: (path: string) => Promise<ApiResponse<unknown>>;
+    post: (path: string, body: unknown) => Promise<ApiResponse<unknown>>;
+    readFile: (path: string) => string;
+    readStdin: () => string;
+    stdinIsTTY: () => boolean;
+    channel: Channel;
+}
+export declare function relativeAge(value: number | string, now?: number): string;
+export declare function formatBankList(banks: BankSummary[]): string;
+export declare function formatBankShow(res: BankShowResponse): string;
+interface PromoteTextSources {
+    arg?: string;
+    file?: string;
+    readFile: (path: string) => string;
+    readStdin: () => string;
+    stdinIsTTY: () => boolean;
+}
+export declare function resolvePromoteText(opts: PromoteTextSources): string;
+export declare function parseWinMetrics(flags: Record<string, string | boolean>): BankWinMetrics | undefined;
+export declare function parseProvenance(flags: Record<string, string | boolean>): BankProvenance | undefined;
+export declare function parseAwareness(flags: Record<string, string | boolean>): AwarenessPair | undefined;
+export declare function buildPromoteBody(bankKey: string, text: string, flags: Record<string, string | boolean>): BankPromoteBody;
+export declare function listFlow(json: boolean, deps: BankDeps): Promise<FlowResult>;
+export declare function showFlow(key: string, json: boolean, deps: BankDeps): Promise<FlowResult>;
+export declare function promoteFlow(key: string, arg: string | undefined, flags: Record<string, string | boolean>, json: boolean, deps: BankDeps): Promise<FlowResult>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export {};

package/dist/commands/bank.js

@@ -0,0 +1,346 @@
+import fs from "node:fs";
+import { apiGet, apiPost } from "../lib/client.js";
+import { formatApiError } from "../lib/format.js";
+import { getChannel } from "../lib/channel.js";
+import { missingRouteLine } from "../lib/route-support.js";
+export const helpText = `
+exodus bank — List, inspect, and promote entries into this brand's copy banks
+
+Usage:
+  exodus bank list [--json]
+  exodus bank show <key> [--json]
+  exodus bank promote <key> [text] [--file <path>] [options] [--json]
+
+Flags:
+  --json                 Machine-readable JSON output (includes ids + provenance)
+  --file <path>          (promote) Read the entry text from a file instead of an
+                         argument; piping text on stdin is a third option. A text
+                         argument and --file conflict (provide one, not both);
+                         stdin is read only when neither is given.
+  --awareness <pair>     (promote) Tag a body-bank entry with an awareness pair:
+                         unawareProblemAware | solutionProductAware | mostAware
+  --spend <n>            (promote) Win metric: ad spend (number)
+  --roas <n>             (promote) Win metric: return on ad spend (number)
+  --ctr <n>              (promote) Win metric: click-through rate (number)
+  --note <s>             (promote) Win metric: freeform note
+  --run <runId>          (promote) Provenance: the run this copy came from
+  --node <nodeId>        (promote) Provenance: the node this copy came from
+
+Banks are addressed by their well-known KEY (shown by \`bank list\`), never by an
+internal id. A fresh brand starts with six banks, all empty. \`bank show\` numbers
+entries newest-first with their source, win metrics, and age. \`bank promote\`
+appends a winning line to a bank; the server rejects an unknown key (listing the
+valid ones), empty/over-long text, and a bank that has hit its 2000-entry cap —
+those messages print verbatim.
+
+Examples:
+  exodus bank list
+  exodus bank show hooks
+  exodus bank promote hooks "Stop scrolling — your knees will thank you"
+  exodus bank promote body:solutionProductAware --file winner.txt --awareness solutionProductAware
+  cat winner.txt | exodus bank promote hooks
+  exodus bank promote hooks "..." --spend 4200 --roas 3.1 --ctr 1.8 --note "Q3 winner"
+  exodus bank promote hooks "..." --run wr_123 --node bot-4
+`.trim();
+export const AWARENESS_PAIRS = [
+    "unawareProblemAware",
+    "solutionProductAware",
+    "mostAware",
+];
+const LIST_PATH = "/api/v2/banks";
+const SHOW_PATH = "/api/v2/banks/show";
+const PROMOTE_PATH = "/api/v2/banks/promote";
+const FLYWHEEL_LINE = 'Winner Flywheel: "winner-promoted" dispatched — any workflow with an enabled ' +
+    "trigger starts a background run (watch: exodus workflow inbox)";
+const VALUE_FLAGS = new Set(["file", "awareness", "spend", "roas", "ctr", "note", "run", "node"]);
+const defaultDeps = {
+    get: (path) => apiGet(path),
+    post: (path, body) => apiPost(path, body),
+    readFile: (path) => fs.readFileSync(path, "utf-8"),
+    readStdin: () => fs.readFileSync(0, "utf-8"),
+    stdinIsTTY: () => !!process.stdin.isTTY,
+    channel: getChannel(),
+};
+function asErrorResult(res, json) {
+    return {
+        code: 1,
+        lines: json
+            ? [JSON.stringify({ ok: false, status: res.status, data: res.data })]
+            : [formatApiError(res)],
+    };
+}
+function table(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i]?.length ?? 0)));
+    const fmt = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+    return [fmt(headers), fmt(headers.map((h) => "-".repeat(h.length))), ...rows.map(fmt)].join("\n");
+}
+export function relativeAge(value, now = Date.now()) {
+    const t = typeof value === "number" ? value : Date.parse(value);
+    if (!t || Number.isNaN(t))
+        return "unknown";
+    const diff = now - t;
+    if (diff < 0)
+        return "just now";
+    const sec = Math.floor(diff / 1000);
+    if (sec < 45)
+        return "just now";
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const day = Math.floor(hr / 24);
+    if (day < 7)
+        return `${day}d ago`;
+    const wk = Math.floor(day / 7);
+    if (wk < 5)
+        return `${wk}w ago`;
+    const mo = Math.floor(day / 30);
+    if (mo < 12)
+        return `${mo}mo ago`;
+    return `${Math.floor(day / 365)}y ago`;
+}
+function winMetricsLine(wm) {
+    if (!wm)
+        return null;
+    const parts = [];
+    if (typeof wm.spend === "number")
+        parts.push(`spend=${wm.spend}`);
+    if (typeof wm.roas === "number")
+        parts.push(`roas=${wm.roas}`);
+    if (typeof wm.ctr === "number")
+        parts.push(`ctr=${wm.ctr}`);
+    if (wm.note)
+        parts.push(`note="${wm.note}"`);
+    return parts.length > 0 ? `     win: ${parts.join("  ")}` : null;
+}
+function textBlock(text) {
+    const lines = text.split("\n");
+    return lines.map((l) => `     ${l}`);
+}
+export function formatBankList(banks) {
+    if (banks.length === 0)
+        return "No banks found for the active brand.";
+    return table(["key", "name", "type", "entries"], banks.map((b) => [b.key, b.name, b.type, String(b.entryCount)]));
+}
+export function formatBankShow(res) {
+    const lines = [];
+    const { bank, entries } = res;
+    lines.push(`Bank — ${bank.name}`);
+    lines.push(`key:      ${bank.key}`);
+    lines.push(`type:     ${bank.type}`);
+    if (bank.awarenessPair)
+        lines.push(`awareness: ${bank.awarenessPair}`);
+    lines.push(`entries:  ${entries.length}`);
+    if (entries.length === 0) {
+        lines.push("");
+        lines.push("  (no entries yet — promote a winner with `exodus bank promote`)");
+        return lines.join("\n");
+    }
+    entries.forEach((entry, i) => {
+        lines.push("");
+        const badges = [`[${entry.source}]`];
+        if (entry.awarenessPair)
+            badges.push(entry.awarenessPair);
+        if (entry.humanEdited)
+            badges.push("edited");
+        badges.push(relativeAge(entry.createdAt));
+        lines.push(`${i + 1}. ${badges.join(" · ")}`);
+        lines.push(...textBlock(entry.text));
+        const win = winMetricsLine(entry.winMetrics);
+        if (win)
+            lines.push(win);
+    });
+    return lines.join("\n");
+}
+export function resolvePromoteText(opts) {
+    if (opts.arg !== undefined && opts.file !== undefined) {
+        throw new Error("provide exactly ONE entry text source, got 2: text argument + --file.");
+    }
+    if (opts.arg !== undefined)
+        return opts.arg;
+    if (opts.file !== undefined) {
+        try {
+            return opts.readFile(opts.file);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`could not read --file "${opts.file}": ${msg}`);
+        }
+    }
+    if (!opts.stdinIsTTY()) {
+        const text = opts.readStdin();
+        if (text.trim() !== "")
+            return text;
+    }
+    throw new Error("no entry text — pass it as an argument, with --file <path>, or pipe it on stdin.");
+}
+export function parseWinMetrics(flags) {
+    const wm = {};
+    const num = (name) => {
+        const raw = flags[name];
+        if (raw === undefined)
+            return undefined;
+        if (typeof raw !== "string" || raw.trim() === "") {
+            throw new Error(`--${name} must be a number (got "${String(raw)}")`);
+        }
+        const n = Number(raw);
+        if (Number.isNaN(n))
+            throw new Error(`--${name} must be a number (got "${raw}")`);
+        return n;
+    };
+    const spend = num("spend");
+    const roas = num("roas");
+    const ctr = num("ctr");
+    if (spend !== undefined)
+        wm.spend = spend;
+    if (roas !== undefined)
+        wm.roas = roas;
+    if (ctr !== undefined)
+        wm.ctr = ctr;
+    if (typeof flags["note"] === "string")
+        wm.note = flags["note"];
+    return Object.keys(wm).length > 0 ? wm : undefined;
+}
+export function parseProvenance(flags) {
+    const prov = {};
+    if (typeof flags["run"] === "string")
+        prov.workflowRunId = flags["run"];
+    if (typeof flags["node"] === "string")
+        prov.nodeId = flags["node"];
+    return Object.keys(prov).length > 0 ? prov : undefined;
+}
+export function parseAwareness(flags) {
+    const raw = flags["awareness"];
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "string" || !AWARENESS_PAIRS.includes(raw)) {
+        throw new Error(`--awareness must be one of: ${AWARENESS_PAIRS.join(", ")} (got "${String(raw)}").`);
+    }
+    return raw;
+}
+export function buildPromoteBody(bankKey, text, flags) {
+    const body = { bankKey, text };
+    const awarenessPair = parseAwareness(flags);
+    if (awarenessPair)
+        body.awarenessPair = awarenessPair;
+    const winMetrics = parseWinMetrics(flags);
+    if (winMetrics)
+        body.winMetrics = winMetrics;
+    const provenance = parseProvenance(flags);
+    if (provenance)
+        body.provenance = provenance;
+    return body;
+}
+export async function listFlow(json, deps) {
+    const res = await deps.get(LIST_PATH);
+    const unsupported = missingRouteLine(res, "bank list", deps.channel);
+    if (unsupported)
+        return { code: 1, lines: [unsupported] };
+    if (!res.ok)
+        return asErrorResult(res, json);
+    const banks = res.data ?? [];
+    return { code: 0, lines: json ? [JSON.stringify(res.data)] : [formatBankList(banks)] };
+}
+export async function showFlow(key, json, deps) {
+    const res = await deps.get(`${SHOW_PATH}?key=${encodeURIComponent(key)}`);
+    const unsupported = missingRouteLine(res, "bank show", deps.channel);
+    if (unsupported)
+        return { code: 1, lines: [unsupported] };
+    if (!res.ok)
+        return asErrorResult(res, json);
+    return {
+        code: 0,
+        lines: json ? [JSON.stringify(res.data)] : [formatBankShow(res.data)],
+    };
+}
+export async function promoteFlow(key, arg, flags, json, deps) {
+    let body;
+    try {
+        const text = resolvePromoteText({
+            arg,
+            file: typeof flags["file"] === "string" ? flags["file"] : undefined,
+            readFile: deps.readFile,
+            readStdin: deps.readStdin,
+            stdinIsTTY: deps.stdinIsTTY,
+        });
+        body = buildPromoteBody(key, text, flags);
+    }
+    catch (e) {
+        return { code: 1, lines: [`Error: ${e instanceof Error ? e.message : String(e)}`] };
+    }
+    const res = await deps.post(PROMOTE_PATH, body);
+    const unsupported = missingRouteLine(res, "bank promote", deps.channel);
+    if (unsupported)
+        return { code: 1, lines: [unsupported] };
+    if (!res.ok)
+        return asErrorResult(res, json);
+    const data = res.data;
+    if (json)
+        return { code: 0, lines: [JSON.stringify(res.data)] };
+    return {
+        code: 0,
+        lines: [
+            `✓ Promoted to ${data.bankName}.`,
+            `entryId:  ${data.entryId}`,
+            FLYWHEEL_LINE,
+        ],
+    };
+}
+function parsePositional(args = process.argv.slice(3)) {
+    const out = [];
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2).split("=", 1)[0] ?? "";
+            if (!arg.includes("=") && VALUE_FLAGS.has(key))
+                i += 2;
+            else
+                i++;
+            continue;
+        }
+        out.push(arg);
+        i++;
+    }
+    return out;
+}
+async function printResult(result) {
+    for (const line of result.lines)
+        console.log(line);
+    if (result.code !== 0)
+        process.exit(result.code);
+}
+export async function run(flags) {
+    const positional = parsePositional();
+    const [sub, ...rest] = positional;
+    const json = !!flags["json"];
+    if (!sub) {
+        console.log(helpText);
+        return;
+    }
+    if (sub === "list")
+        return printResult(await listFlow(json, defaultDeps));
+    if (sub === "show") {
+        const key = rest[0];
+        if (!key) {
+            console.error("Error: bank show requires <key>.");
+            console.log("Usage: exodus bank show <key> [--json]");
+            process.exit(1);
+        }
+        return printResult(await showFlow(key, json, defaultDeps));
+    }
+    if (sub === "promote") {
+        const key = rest[0];
+        if (!key) {
+            console.error("Error: bank promote requires <key>.");
+            console.log("Usage: exodus bank promote <key> [text] [--file <path>] [--json]");
+            process.exit(1);
+        }
+        return printResult(await promoteFlow(key, rest[1], flags, json, defaultDeps));
+    }
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}

package/dist/commands/browse.js

@@ -1,5 +1,6 @@
 import { apiGet } from "../lib/client.js";
 import { formatBrowse, formatError } from "../lib/format.js";
+import { isActiveRunStatus } from "../lib/runStatus.js";
 export const helpText = `
 exodus browse — List recent pipeline runs (hooks, ads, image concepts, etc.)
 
@@ -119,7 +120,7 @@ export async function run(flags) {
         ? all
         : all.filter((g) => {
             const status = g["status"];
-            if (status !== "running" && status !== "pending")
+            if (!status || !isActiveRunStatus(status))
                 return true;
             const created = normalizeCreatedAt(g);
             return created > 0 && now - created < STUCK_THRESHOLD_MS;

package/dist/commands/creative.js

@@ -1,5 +1,5 @@
 import { apiGet, apiGetDashboard, apiPost, getDashboardUrl, } from "../lib/client.js";
-import { formatError } from "../lib/format.js";
+import { displayRunStatus, formatError } from "../lib/format.js";
 export const helpText = `
 exodus creative — Creative-suite engines (native, copy-derived, ref-match)
 
@@ -165,7 +165,7 @@ async function runStatus(flags) {
         console.log(`name:         ${d.name}`);
     if (d.engine)
         console.log(`engine:       ${d.engine}`);
-    console.log(`status:       ${d.status ?? "—"}${d.isTerminal ? " (terminal)" : ""}`);
+    console.log(`status:       ${displayRunStatus(d.status, "—")}${d.isTerminal ? " (terminal)" : ""}`);
     if (d.completedImages !== undefined || d.totalImages !== undefined) {
         console.log(`progress:     ${d.completedImages ?? 0} / ${d.totalImages ?? "?"} completed${d.failedImages ? `, ${d.failedImages} failed` : ""}`);
     }

package/dist/commands/genesis.js

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { apiGet, apiPost, getDashboardUrl } from "../lib/client.js";
 import { pollUntilDone } from "../lib/poll.js";
-import { formatGenesisRun, formatError } from "../lib/format.js";
+import { displayRunStatus, formatGenesisRun, formatError, tickerRunStatus } from "../lib/format.js";
 import { formatCcCommand } from "../lib/cc-command.js";
 import { resolveActiveBrand } from "../lib/layout.js";
 import { captureReelAndWrite } from "../lib/reel-write.js";
@@ -16,9 +16,21 @@ Google Doc). Write from a typed brief.
 
 Usage:
   exodus genesis run --brief <file|"text">   Write from a typed brief
+  exodus genesis hook-pref [manual|auto]     Read (no arg) or save your default
+                                             hook-gate choice
+  exodus genesis hooks --id <runId>          Show the hook pool of a run paused
+                                             at the hook gate
+  exodus genesis continue --id <runId> --hooks 1,3,5   Pick hooks and resume
+  exodus genesis regenerate --id <runId> [--steering "…"]   Re-roll the hook pool
+
+Every run must know whether you review hooks: pass --stop-at-hooks or
+--auto-hooks, or save a default once with hook-pref. A flagless run with no
+saved preference is refused.
 
 Options:
   --brief <file|"text">       Typed brief (file path or inline string)
+  --stop-at-hooks             Pause at the hook gate to review/pick hooks
+  --auto-hooks                Auto-pick hooks and write straight through
   --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.
@@ -441,7 +453,7 @@ async function waitForGenesisRun(runId) {
             const status = data["status"];
             const currentStep = data["currentStep"];
             if (status) {
-                process.stdout.write(`\r  ${status}${currentStep ? ` — ${currentStep}` : ""}        `);
+                process.stdout.write(`\r  ${tickerRunStatus(status)}${currentStep ? ` — ${currentStep}` : ""}        `);
             }
         },
     });
@@ -515,7 +527,7 @@ async function runHooks(flags) {
         process.exit(1);
     }
     if (res.data.status !== "awaiting_hook_selection") {
-        console.log(`Run ${runId} is not awaiting hook selection (status: ${res.data.status ?? "unknown"}).`);
+        console.log(`Run ${runId} is not awaiting hook selection (status: ${displayRunStatus(res.data.status)}).`);
         return;
     }
     const pool = Array.isArray(res.data.hookPool) ? res.data.hookPool : [];
@@ -677,7 +689,7 @@ async function pollScrape(runId, noWait, timeoutMs) {
                 ? ` captured=${captured ?? 0} qualified=${qualified ?? 0}`
                 : "";
             if (status)
-                process.stdout.write(`\r  status: ${status}${counts}              `);
+                process.stdout.write(`\r  status: ${tickerRunStatus(status)}${counts}              `);
         },
     });
     console.log();

package/dist/commands/keys.js

@@ -26,6 +26,7 @@ const PROVIDER_LABEL = {
     kie: "Kie.ai",
     imgflip: "Imgflip",
     scrapecreators: "ScrapeCreators",
+    apify: "Apify",
 };
 async function status() {
     let remote;

package/dist/commands/meme.js

@@ -19,11 +19,14 @@ Flow:
   2. run        → pass the picked recommendation objects straight into --formats
                   (a JSON array; both recommendation-shape and run-shape entries
                   are accepted, 1–50). Returns { runId } — the whole batch renders
-                  server-side via Trigger.dev; closing your session won't kill it.
-  3. poll       → exodus status --id <runId> --type creative
-                  (terminal: complete | partial-error | error)
+                  server-side; closing your session won't kill it.
+  3. poll       → exodus workflow status --id <runId>
+                  Memes render through the Image Rig now, so a meme run IS a
+                  workflow run — the workflow verb is the one that can read it.
   4. regenerate → re-render a single miss using the format fields from the
                   recommend output. Synchronous; returns the new image URL.
+                  Its optional --id takes a CREATIVE-SUITE run id, which the id
+                  from step 2 is not — omit --id and use the returned URL.
 
 Keys (strict BYOK — checked server-side before anything starts):
   classic (layer 1) memes need your Imgflip login; AI (layer 2/3) memes need
@@ -32,10 +35,10 @@ Keys (strict BYOK — checked server-side before anything starts):
 Examples:
   exodus meme recommend --brief "grounding sheets reduce inflammation"
   exodus meme run --brief "grounding sheets reduce inflammation" --formats '[{"layer":2,"name":"Group Chat","format_id":"group-chat"}]'
-  exodus meme regenerate --brief "grounding sheets reduce inflammation" --layer 2 --format group-chat --hint "make the last message land the product" --id <runId>
+  exodus meme regenerate --brief "grounding sheets reduce inflammation" --layer 2 --format group-chat --hint "make the last message land the product"
 `.trim();
 function dashboardUrlForRun(runId) {
-    return `${getDashboardUrl()}/creative-suite/runs/${runId}`;
+    return `${getDashboardUrl()}/runs/${runId}`;
 }
 function flagString(flags, name) {
     const v = flags[name];
@@ -185,7 +188,7 @@ async function runRun(flags) {
     console.log(`  memes:        ${formats.length} queued`);
     console.log(`  dashboard:    ${dashboardUrlForRun(res.data.runId)}`);
     console.log("");
-    console.log(`Poll: exodus status --id ${res.data.runId} --type creative`);
+    console.log(`Poll: exodus workflow status --id ${res.data.runId}`);
     console.log("(The batch renders server-side — closing this session won't kill it.)");
 }
 async function runRegenerate(flags) {

package/dist/commands/primer.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { apiGetDashboard, apiPostDashboard } from "../lib/client.js";
 import { promptChoice, promptMultiline, openInEditor } from "../lib/prompts.js";
+import { normalizeRunStatus } from "../lib/runStatus.js";
 import { refreshBrandProfileMd } from "./brand.js";
 export const helpText = `
 exodus primer — Build a brand's primer (the single foundation step)
@@ -152,7 +153,7 @@ async function buildPrimer(submission) {
             process.stdout.write("·");
             continue;
         }
-        if (data.status === "failed") {
+        if (normalizeRunStatus(data.status) === "failed") {
             console.log("");
             fail(`primer build failed: ${data.error ?? "unknown error"}`);
         }

package/dist/commands/session.d.ts

@@ -0,0 +1,55 @@
+import { type ApiResponse } from "../lib/client.js";
+import { type Channel } from "../lib/channel.js";
+export declare const helpText: string;
+export interface SessionSummary {
+    _id: string;
+    title: string;
+    botSlug: string;
+    runId?: string;
+    nodeId?: string;
+    archived: boolean;
+    lastTouchedAt: number | string;
+    createdAt: number | string;
+}
+export interface SessionListResponse {
+    sessions: SessionSummary[];
+}
+export type SessionMessageRole = "system" | "user" | "assistant";
+export interface SessionMessage {
+    role: SessionMessageRole;
+    body: string;
+    createdAt: number | string;
+}
+export interface SessionShowResponse {
+    session: SessionSummary & {
+        promptText?: string;
+        model?: string;
+    };
+    messages: SessionMessage[];
+}
+export interface SessionChatResponse {
+    reply: string;
+}
+export interface SessionDeps {
+    get: (path: string) => Promise<ApiResponse<unknown>>;
+    postDashboard: (path: string, body: unknown, opts?: {
+        timeoutMs?: number;
+    }) => Promise<ApiResponse<unknown>>;
+    channel: Channel;
+}
+export interface FlowResult {
+    code: number;
+    lines: string[];
+}
+export declare function shortId(id: string): string;
+export declare function formatAge(value: number | string | undefined, now?: number): string;
+export declare function formatSessionList(sessions: SessionSummary[], now?: number): string;
+export declare function formatSessionShow(data: SessionShowResponse): string;
+export declare function listFlow(json: boolean, deps: SessionDeps): Promise<FlowResult>;
+export declare function showFlow(sessionId: string, opts: {
+    json: boolean;
+}, deps: SessionDeps): Promise<FlowResult>;
+export declare function chatFlow(sessionId: string, message: string, opts: {
+    json: boolean;
+}, deps: SessionDeps): Promise<FlowResult>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;