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

package/assets/skills/exodus/SKILL.md

@@ -18,6 +18,7 @@ This skill ROUTES. Read what the user wants, name the destination skill, and han
 | Static image ads ("make images", "statics", "render this ad") | `exodus-image` (the image front door — it menus engines and confirms before firing) |
 | A specific image engine they already chose | `exodus-creative` (native / copy-derived / ref-match) or `exodus-template` (33 ad-type formats) |
 | Meme ads ("exodus, meme this offer", "make me meme ads") | `exodus-meme` |
+| Run / chain / build / edit a saved workflow ("run my workflow", "what does this workflow need", "build a workflow that…", "list my workflows") | `exodus-workflow` |
 | Onboard a new brand / build the primer | `exodus-primer` (with winning ads) or `exodus-foundation` (no ads yet) |
 | List/switch/troubleshoot brands | `exodus-brand` |
 | See past runs / find an output | `exodus-browse` |

package/assets/skills/exodus-workflow/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: exodus-workflow
+description: Run, chain, build, and edit saved Exodus Workflows — the multi-node automations that wire Genesis bots, primers, briefs, and image nodes together on the dashboard canvas — from the CLI. Use it to list a brand's workflows, describe what a workflow needs before running it (inputs, per-workspace primer prerequisites, outputs), run one and collect its outputs, chain one workflow's output into another's input, browse the bot catalog, and author or update a workflow contract via export → edit → import. Only invoke when the user has explicitly invoked Exodus: they said "exodus" in the request ("exodus, run my launch workflow", "exodus, what does this workflow need", "exodus, build a workflow that turns a swipe into hooks then ads", "list my exodus workflows", "exodus, edit that workflow"), named this skill or /exodus-workflow, ran an `npx @aicopycoders/exodus workflow` command, or the `exodus` hub skill routed here. Never claim generic "workflow"/"automation" requests ("automate this", "build me a workflow") without Exodus context — in shared folders those may belong to the user's other tools; if the user did not say exodus, this skill is not for them. The bare word "Genesis" without "exodus" refers to the member's own Genesis API key and personal bot recipes, NOT to Exodus.
+---
+
+```operator-guide
+Subcommands:
+  exodus workflow list [--json]                              List the brand's saved workflows
+  exodus workflow describe <workflowId|name> [--json]        Inputs, prerequisites, outputs
+  exodus workflow bots [--category <cat>] [--slug <slug>] [--json]   Bot catalog / one bot's spec
+  exodus workflow run <workflowId|name> [--input key=value ...] [--wait] [--json]   Run it
+  exodus workflow status [--id <runId>] [--json]             Poll a run / read its outputs
+  exodus workflow export <workflowId|name> [--out <file>]    Dump the contract JSON
+  exodus workflow import <file> [--update <workflowId>] [--dry-run] [--json]   Author/edit
+
+Key flags:
+  --input key=value    Repeatable run input; the value may contain "="
+  --input key=@path    Load the value from a file (path resolved from the cwd);
+                       use key=@@text to keep a leading "@" as a literal character
+  --wait               Poll until the run reaches a terminal status, then print outputs
+  --id <runId>         Run id for `status` detail
+  --category <cat>     (bots) Filter the catalog to one category id
+  --slug <slug>        (bots) Show a single bot's full port + param spec
+  --out <file>         (export) Write JSON to a file instead of stdout
+  --update <workflowId> (import) Update this workflow in place (optimistic-concurrency
+                       guarded by the export's updatedAt — a 409 means re-export first)
+  --dry-run            (import) Validate + resolve refs without writing; returns issues
+
+Auth: Bearer (EXODUS_API_KEY). The canvas lives on the dashboard at /workflows.
+```
+
+# Workflow — Run, Chain, and Build Saved Automations
+
+An Exodus **Workflow** is a saved graph the member builds on the dashboard canvas (`/workflows`): brief and primer sources feed Genesis bots, bots feed other bots or an image node, and an Output node collects the deliverables. This skill is the CLI operator for those graphs — discover and run them, chain one into the next, and author or edit the contract without opening a browser.
+
+Three jobs, three sections below. Read the request and jump to the one that fits; don't walk all three when the user just wants a run.
+
+## 1. Discover & run
+
+The mistake to avoid is firing a run blind and wasting it on a missing input or an unmet prerequisite. Always **`describe` before `run`**.
+
+### Step 1 — List
+
+```bash
+npx @aicopycoders/exodus workflow list
+```
+
+Prints the brand's saved workflows (name, id, node/edge counts, timestamps). If the user named the workflow already, skip straight to `describe`.
+
+### Step 2 — Describe (read inputs, prereqs, outputs)
+
+```bash
+npx @aicopycoders/exodus workflow describe "Launch Flow"
+```
+
+Accepts a workflow id **or** a name. It reports three things:
+
+- **Inputs** — each free input the run needs: field name, source (`text`, `swipe-ad`, `swipe-bundle`, `organic-url`, `ad-url`), whether it's required, and a description. These are the `--input key=value` pairs you'll pass.
+- **Prerequisites** — the per-workspace primer markers the graph's primer nodes depend on, each shown **✓ stored** or **✗ missing** for *this brand*. **If any prerequisite is ✗, warn the user before running** — the run will not produce good output (or will fail) without it. Route them to the `exodus-primer` / `exodus-foundation` skill to fill the gap first, rather than burning a run.
+- **Outputs** — the deliverables the Output node collects (text or image, with labels), so you know what to expect back.
+
+### Step 3 — Gather inputs
+
+Fill every required input. For a free-text brief you can compose a **bespoke brief from in-session research** — the winning angle you just worked out, the swipe you analyzed — and pass it inline (`--input brief="..."`) or, if it's long, write it to a project file and pass it with `@file` (see Chain, below). For URL/swipe sources, pass the value the source expects.
+
+### Step 4 — Run and collect
+
+```bash
+npx @aicopycoders/exodus workflow run "Launch Flow" --input brief="new cortisol offer, problem-aware" --wait
+```
+
+`--wait` polls to a terminal status and prints the run's collected outputs — text inline, image URLs. Without `--wait` the command returns the `runId` and you poll it yourself:
+
+```bash
+npx @aicopycoders/exodus workflow status --id <runId>
+```
+
+Report the outputs plus a short take. Don't call a run "done" off the kickoff line alone — a run reaches `completed`, `partial`, or `failed`; a `partial` means some nodes were skipped or failed, so read the status before declaring victory.
+
+## 2. Chain — feed one workflow's output into the next
+
+The chaining surface is the run's flattened outputs. After a `--wait` run (or once `status` shows terminal), pull the machine-readable outputs:
+
+```bash
+npx @aicopycoders/exodus workflow status --id <runId> --json
+```
+
+The response carries a top-level `outputs` array — each entry is `{ nodeId, botSlug?, type, label, text?, imageUrl?, imageId? }`. Extract the text you want (e.g. `.outputs[].text`) and pass it into the next workflow's input:
+
+```bash
+# Inline, for short outputs
+npx @aicopycoders/exodus workflow run "Ad Writer" --input hooks="<text from run A>" --wait
+```
+
+**The file-as-persistence convention.** For anything reusable or long — a brief, a sales letter, a hook pool — write the text to a **markdown file in the project** and pass it with `@file`. This is the deliberate v1 alternative to a server-side store: the file *is* the persistence layer, versioned in the project alongside the brand's other artifacts.
+
+```bash
+# Save run A's text output to a project file, then feed it to workflow B
+npx @aicopycoders/exodus workflow status --id <runId> --json   # copy .outputs[].text into state/hooks.md
+npx @aicopycoders/exodus workflow run "Ad Writer" --input hooks=@state/hooks.md --wait
+```
+
+`@path` is resolved from the current directory. If the literal value you need actually starts with `@`, escape it as `@@` (e.g. `--input handle=@@brand` passes the string `@brand`).
+
+Use this pattern to compose pipelines the canvas doesn't wire directly: run the research/hook workflow, persist its best output as a file, then run the writing workflow off that file — reproducibly, because the file stays.
+
+## 3. Build & edit — author a workflow contract
+
+The documented way to learn the contract format is to **export an existing workflow and study it** — there is no separate schema doc. The loop is: learn the bots → learn the format → compose → dry-run until clean → import → review on the canvas.
+
+### Step 1 — Learn the bot catalog
+
+```bash
+npx @aicopycoders/exodus workflow bots                     # full catalog, grouped by category
+npx @aicopycoders/exodus workflow bots --category writing  # one category
+npx @aicopycoders/exodus workflow bots --slug new-hook-bot # one bot's full port + param spec
+npx @aicopycoders/exodus workflow bots --json              # raw catalog for machine use
+```
+
+Per bot you get its **input ports** (id, what it accepts — `text` / `primer` / `image`, whether it's required, and for primer ports which `primerKinds` gate it — `body` / `hook` / `headline` / `summary`), its **params** (select/text/toggle/number/multiselect, with options and defaults), and its output type. This is what tells you which node can wire into which — a port only accepts an edge whose source produces a type it lists in `accepts`.
+
+### Step 2 — Learn the format by exporting
+
+```bash
+npx @aicopycoders/exodus workflow export "Launch Flow" --out launch.json
+```
+
+Study `launch.json`: it's the `exodus-workflow` contract — `nodes` (each with `id`, `kind` = `brief`/`bot`/`primer`/`image`/`output`, a `config`, and an optional `position`) and `edges` (`source`/`sourceHandle` → `target`/`targetHandle`, the handles being port ids). An export also carries `workflowId` + `updatedAt` at the top — those are update anchors, not part of the graph.
+
+### Step 3 — Compose the contract
+
+Author the JSON by hand or by adapting an export. **Node positions are optional** — leave them out and the server auto-layouts the graph on import; you don't need to compute coordinates.
+
+### Step 4 — Dry-run like a compiler loop
+
+```bash
+npx @aicopycoders/exodus workflow import launch.json --dry-run
+```
+
+`--dry-run` validates and resolves refs without writing. It returns compiler-style issues — each names the **node id**, the **port id** where relevant, and a concrete **remedy** (the exact edit that fixes it). Codes you'll see include `dangling-edge`, `unknown-port`, `type-mismatch`, `missing-required-input`, `duplicate-input`, `cycle`, `unknown-kind`, and `bad-config`. Fix, re-run `--dry-run`, repeat until it's clean — same loop as fixing type errors.
+
+### Step 5 — Import (create or update)
+
+```bash
+# Create a new workflow
+npx @aicopycoders/exodus workflow import launch.json
+
+# Update an existing workflow in place
+npx @aicopycoders/exodus workflow import launch.json --update wf_123
+```
+
+Then **tell the user to review it on the canvas at `/workflows`** — the CLI writes the graph; the human eye confirms it reads right.
+
+**Two rules for edits (`--update`):**
+
+- **Always export a backup first.** v1 has no version history — a destructive `--update` overwrites the live workflow with no undo. `export --out backup.json` before you import over it.
+- **A 409 means the canvas moved.** `--update` sends the export's `updatedAt` as an optimistic-concurrency guard. If someone edited the workflow on the dashboard since your export, the import 409s. Re-export the current workflow, reapply your edits onto the fresh contract, and import again — never force past a 409, or you'll clobber their change.
+
+## Failure handling
+
+- **`describe` shows a ✗ prerequisite** — don't run yet. Fill the primer via `exodus-primer` / `exodus-foundation`, then re-check `describe`.
+- **Run comes back `partial` or `failed`** — read `status --id <runId>` (drop `--json` for a readable view) to see which node failed and why before re-running.
+- **`import --dry-run` issues** — fix the exact node/port each issue names using its remedy; don't guess.
+- **`import --update` 409** — re-export, reapply, re-import (see Step 5). This is a conflict, not a bug.
+- **Auth / whoami failure** — run `npx @aicopycoders/exodus doctor` and confirm `EXODUS_API_KEY`.
+- **Wrong brand** — workflows are per-brand. `npx @aicopycoders/exodus brand current` to confirm you're on the brand you think you are; switch with the `exodus-brand` skill.
+
+## Not the right skill for
+
+- **Running a single Genesis writing pass** (brief → copy in two voices) — that's `exodus-genesis`. Reach here when the member has a *saved multi-node workflow* to run or build.
+- **One-off image renders** — `exodus-image` / `exodus-creative` / `exodus-template`.
+- **Building the primer a workflow depends on** — `exodus-primer` (winning ads) or `exodus-foundation` (no ads).
+- **Finding a past run's output doc** — `exodus-browse`.

package/dist/bin/exodus.js

@@ -18,6 +18,7 @@ const OTHER_COMMANDS = new Set([
     "init",
     "migrate",
     "segment",
+    "workflow",
 ]);
 const HIDDEN_COMMANDS = new Set([
     "creative",

package/dist/commands/workflow.d.ts

@@ -0,0 +1,271 @@
+import { type ApiResponse } from "../lib/client.js";
+import { type PollOptions, type PollResult } from "../lib/poll.js";
+export declare const helpText: string;
+export type WorkflowNodeKind = "brief" | "bot" | "primer" | "image" | "output";
+export interface WorkflowNode {
+    id: string;
+    kind: WorkflowNodeKind;
+    position: {
+        x: number;
+        y: number;
+    };
+    config: Record<string, unknown>;
+}
+export interface WorkflowEdge {
+    id: string;
+    source: string;
+    sourceHandle: string;
+    target: string;
+    targetHandle: string;
+}
+export interface WorkflowContractJson {
+    contract: "exodus-workflow";
+    version: number;
+    workflowId?: string;
+    updatedAt?: string;
+    name: string;
+    description?: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+}
+export interface UnresolvedWorkflowRef {
+    nodeId: string;
+    ref: "persona" | "primer";
+    value: string;
+    message: string;
+}
+export interface WorkflowImportResult {
+    name: string;
+    created: boolean;
+    workflowId?: string;
+    nodeCount: number;
+    edgeCount: number;
+    unresolved: UnresolvedWorkflowRef[];
+    warnings: string[];
+}
+export type GraphIssueCode = "bad-shape" | "unknown-kind" | "duplicate-node-id" | "dangling-edge" | "unknown-port" | "type-mismatch" | "duplicate-input" | "cycle" | "missing-required-input" | "bad-config";
+export interface GraphIssue {
+    code: GraphIssueCode;
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+    portId?: string;
+    remedy?: string;
+}
+export type WorkflowImportErrorCode = "invalid-graph" | "conflict" | "forbidden" | "not-found";
+export interface WorkflowImportError {
+    code: WorkflowImportErrorCode;
+    message: string;
+    issues?: GraphIssue[];
+    currentUpdatedAt?: string;
+}
+export type WorkflowPortType = "text" | "primer" | "image";
+export type WorkflowPrimerKind = "body" | "hook" | "headline" | "summary";
+export type WorkflowParamKind = "select" | "text" | "textarea" | "toggle" | "number" | "multiselect";
+export interface CatalogInput {
+    id: string;
+    label: string;
+    accepts: WorkflowPortType[];
+    required: boolean;
+    multi?: boolean;
+    primerKinds?: WorkflowPrimerKind[];
+}
+export interface CatalogParam {
+    key: string;
+    label: string;
+    kind: WorkflowParamKind;
+    options?: string[];
+    min?: number;
+    max?: number;
+    required?: boolean;
+    help?: string;
+    default?: string;
+}
+export interface CatalogBot {
+    slug: string;
+    name: string;
+    blurb: string;
+    category: string;
+    categoryLabel: string;
+    inputs: CatalogInput[];
+    params: CatalogParam[];
+    outputType: string;
+    splitsOutput: boolean;
+}
+export interface WorkflowCatalog {
+    catalog: "exodus-workflow-catalog";
+    version: 1;
+    bots: CatalogBot[];
+    vocabulary: {
+        nodeKinds: string[];
+        briefSources: string[];
+        primerKinds: string[];
+        imageModels: string[];
+        aspectRatios: string[];
+        imageQuantityModes: string[];
+        categories: Array<{
+            id: string;
+            label: string;
+        }>;
+    };
+    customBot: {
+        slug: "custom";
+        configKey: "customSlug";
+        inputs: CatalogInput[];
+        summaryOnlySlugs: string[];
+        notes: string;
+    };
+}
+export type WorkflowBriefSource = "text" | "swipe-ad" | "swipe-bundle" | "organic-url" | "ad-url";
+export interface WorkflowInputDescriptor {
+    fieldName: string;
+    nodeId: string;
+    source: WorkflowBriefSource;
+    required: boolean;
+    description?: string;
+    bundleSize?: number;
+}
+export interface WorkflowPrerequisiteDescriptor {
+    primerKind: WorkflowPrimerKind;
+    nodeIds: string[];
+}
+export interface WorkflowOutputDescriptor {
+    type: "text" | "image";
+    label: string;
+    nodeId: string;
+    botSlug?: string;
+}
+export interface WorkflowDescribeResponse {
+    workflowId: string;
+    name: string;
+    description?: string;
+    updatedAt: string;
+    inputs: WorkflowInputDescriptor[];
+    prerequisites: Array<WorkflowPrerequisiteDescriptor & {
+        stored: boolean;
+    }>;
+    outputs: WorkflowOutputDescriptor[];
+}
+export interface WorkflowListItem {
+    _id: string;
+    name: string;
+    description?: string;
+    nodeCount: number;
+    edgeCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WorkflowListResponse {
+    workflows: WorkflowListItem[];
+}
+export type WorkflowRunStatus = "queued" | "running" | "completed" | "partial" | "failed";
+export type WorkflowNodeRunStatus = "idle" | "running" | "done" | "failed" | "skipped";
+export type WorkflowArtifact = {
+    type: "text";
+    text: string;
+    label?: string;
+} | {
+    type: "primer";
+    text: string;
+    primerKind: string;
+} | {
+    type: "image";
+    storageId: string;
+    imageUrl?: string;
+};
+export interface WorkflowRunOutput {
+    nodeId: string;
+    botSlug?: string;
+    type: "text" | "image";
+    label: string;
+    text?: string;
+    imageUrl?: string;
+    imageId?: string;
+}
+export interface WorkflowRunNode {
+    nodeId: string;
+    kind: string;
+    status: WorkflowNodeRunStatus;
+    error?: string;
+    startedAt?: number;
+    completedAt?: number;
+    outputs: WorkflowArtifact[];
+}
+export interface WorkflowCounts {
+    done: number;
+    failed: number;
+    skipped: number;
+    total: number;
+}
+export interface WorkflowRun {
+    _id: string;
+    workflowId: string;
+    workflowName: string;
+    status: WorkflowRunStatus;
+    error?: string;
+    counts?: WorkflowCounts;
+    inputs: Record<string, string>;
+    triggerRunId?: string;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    isTerminal: boolean;
+    nodes: WorkflowRunNode[];
+    outputs?: WorkflowRunOutput[];
+}
+export type WorkflowRunProjection = Omit<WorkflowRun, "nodes"> & {
+    nodes?: never;
+};
+export interface WorkflowRunDeps {
+    get: (path: string) => Promise<ApiResponse<unknown>>;
+    post: (path: string, body: unknown) => Promise<ApiResponse<unknown>>;
+    readFile: (path: string) => string;
+    writeFile: (path: string, text: string) => void;
+    poll: (opts: PollOptions) => Promise<PollResult>;
+}
+export interface FlowResult {
+    code: number;
+    lines: string[];
+}
+interface RunFlowOptions {
+    inputs: Record<string, string>;
+    wait: boolean;
+    json: boolean;
+    onProgressLine?: (line: string) => void;
+}
+export declare function parseInputFlags(args: string[], readFile?: (path: string) => string): Record<string, string>;
+export declare function formatWorkflowList(workflows: WorkflowListItem[]): string;
+export declare function formatRecentRuns(runs: WorkflowRunProjection[]): string;
+export declare function formatImportSummary(result: WorkflowImportResult, mode?: {
+    dryRun?: boolean;
+    update?: boolean;
+}): string;
+export declare function formatWorkflowRun(run: WorkflowRun): string;
+export declare function formatDescribe(res: WorkflowDescribeResponse): string;
+export declare function formatBotsList(catalog: WorkflowCatalog, category?: string): string;
+export declare function formatBotDetail(bot: CatalogBot): string;
+export declare function resolveWorkflowId(ref: string, deps: WorkflowRunDeps): Promise<string>;
+export declare function listFlow(json: boolean, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function describeFlow(workflowRef: string, opts: {
+    json: boolean;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function botsFlow(opts: {
+    category?: string;
+    slug?: string;
+    json: boolean;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function runFlow(workflowRef: string, opts: RunFlowOptions, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function statusFlow(opts: {
+    id?: string;
+    json: boolean;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function exportFlow(workflowRef: string, opts: {
+    out?: string;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function importFlow(file: string, opts: {
+    dryRun: boolean;
+    json: boolean;
+    update?: string;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export {};

package/dist/commands/workflow.js

@@ -0,0 +1,744 @@
+import fs from "node:fs";
+import { apiGet, apiPost } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+import { pollUntilDone } from "../lib/poll.js";
+export const helpText = `
+exodus workflow — List, describe, run, inspect, import, and export saved workflows
+
+Usage:
+  exodus workflow list [--json]
+  exodus workflow describe <workflowId|name> [--json]
+  exodus workflow bots [--category <cat>] [--slug <slug>] [--json]
+  exodus workflow run <workflowId|name> [--input key=value ...] [--wait] [--json]
+  exodus workflow status [--id <runId>] [--json]
+  exodus workflow export <workflowId|name> [--out <file>]
+  exodus workflow import <file> [--update <workflowId>] [--dry-run] [--json]
+
+Flags:
+  --json                 Machine-readable JSON output
+  --category <cat>       (bots) Filter the catalog to one category id
+  --slug <slug>          (bots) Show a single bot's full port + param spec
+  --input key=value      Repeatable workflow run input; values may contain "="
+                         --input key=@path loads the value from a file (path is
+                         resolved from the current directory); --input key=@@text
+                         keeps a leading "@" as a literal character.
+  --wait                 Poll until the workflow run reaches a terminal status
+  --id <runId>           Workflow run id for status detail
+  --out <file>           Write export JSON to a file instead of stdout
+  --update <workflowId>  (import) Update this existing workflow in place instead
+                         of creating a new one. Sends the contract's updatedAt as
+                         an optimistic-concurrency guard — if it 409s, re-export
+                         the workflow, reapply edits, and import again.
+  --dry-run              Preview import (validate + resolve refs) without writing
+
+Examples:
+  exodus workflow describe "Launch Flow"
+  exodus workflow bots
+  exodus workflow bots --category writing
+  exodus workflow bots --slug new-hook-bot
+  exodus workflow run "Launch Flow" --input brief="new offer" --wait
+  exodus workflow run "Launch Flow" --input brief=@brief.txt
+  exodus workflow status --id wr_123
+  exodus workflow export "Launch Flow" --out workflow.json
+  exodus workflow import workflow.json --dry-run
+  exodus workflow import workflow.json --update wf_123
+
+Notes:
+  workflow bots --json emits the FULL catalog response verbatim (--category /
+  --slug filters are ignored in that mode). workflow bots --slug <slug> --json
+  emits just that one bot's catalog JSON.
+`.trim();
+const LIST_PATH = "/api/v2/workflows";
+const RUN_PATH = "/api/v2/workflows/run";
+const STATUS_PATH = "/api/v2/workflow";
+const EXPORT_PATH = "/api/v2/workflows/export";
+const IMPORT_PATH = "/api/v2/workflows/import";
+const DESCRIBE_PATH = "/api/v2/workflows/describe";
+const CATALOG_PATH = "/api/v2/workflows/catalog";
+const VALUE_FLAGS = new Set(["id", "input", "out", "category", "slug", "update"]);
+const defaultDeps = {
+    get: (path) => apiGet(path),
+    post: (path, body) => apiPost(path, body),
+    readFile: (path) => fs.readFileSync(path, "utf-8"),
+    writeFile: (path, text) => fs.writeFileSync(path, text, "utf-8"),
+    poll: (opts) => pollUntilDone(opts),
+};
+function asErrorResult(res, json) {
+    return {
+        code: 1,
+        lines: json
+            ? [JSON.stringify({ ok: false, status: res.status, data: res.data })]
+            : [formatError(res)],
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function dateOnly(value) {
+    if (!value)
+        return "-";
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return String(value);
+    return parsed.toISOString().slice(0, 10);
+}
+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");
+}
+function statusIcon(status) {
+    if (status === "completed" || status === "done")
+        return "✓";
+    if (status === "failed")
+        return "✗";
+    if (status === "skipped")
+        return "-";
+    return "…";
+}
+function truncateText(text, max = 200) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, max - 3).trimEnd()}...`;
+}
+function formatCounts(counts) {
+    if (!counts)
+        return "";
+    return `done=${counts.done}/${counts.total}, failed=${counts.failed}, skipped=${counts.skipped}`;
+}
+function outputLines(output) {
+    if (output.type === "text")
+        return [`    text: ${truncateText(output.text)}`];
+    if (output.type === "primer") {
+        return [`    primer:${output.primerKind}: ${truncateText(output.text)}`];
+    }
+    return [`    image: ${output.imageUrl ?? output.storageId}`];
+}
+function progressLine(node) {
+    const err = node.error ? ` — error: ${node.error}` : "";
+    return `  ${statusIcon(node.status)} ${node.nodeId} (${node.kind}) ${node.status}${err}`;
+}
+function expandInputValue(key, value, readFile) {
+    if (value.startsWith("@@"))
+        return value.slice(1);
+    if (value.startsWith("@")) {
+        const filePath = value.slice(1);
+        if (!filePath) {
+            throw new Error(`--input ${key}=@<file> needs a file path after "@"`);
+        }
+        if (!readFile) {
+            throw new Error(`--input ${key}: cannot load @${filePath} here (no file access)`);
+        }
+        try {
+            return readFile(filePath);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`--input ${key}: could not read file "${filePath}": ${msg}`);
+        }
+    }
+    return value;
+}
+export function parseInputFlags(args, readFile) {
+    const inputs = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        let raw;
+        if (arg === "--input") {
+            raw = args[i + 1];
+            i++;
+        }
+        else if (arg.startsWith("--input=")) {
+            raw = arg.slice("--input=".length);
+        }
+        else {
+            continue;
+        }
+        if (!raw)
+            throw new Error("--input requires key=value");
+        const eq = raw.indexOf("=");
+        if (eq <= 0)
+            throw new Error(`--input must be key=value (got "${raw}")`);
+        const key = raw.slice(0, eq).trim();
+        if (!key)
+            throw new Error(`--input must include a key (got "${raw}")`);
+        inputs[key] = expandInputValue(key, raw.slice(eq + 1), readFile);
+    }
+    return inputs;
+}
+export function formatWorkflowList(workflows) {
+    if (workflows.length === 0)
+        return "No workflows found for the active brand.";
+    return table(["name", "nodes", "edges", "updated", "id"], workflows.map((w) => [
+        w.name,
+        String(w.nodeCount),
+        String(w.edgeCount),
+        dateOnly(w.updatedAt),
+        w._id,
+    ]));
+}
+export function formatRecentRuns(runs) {
+    if (runs.length === 0)
+        return "No workflow runs found for the active brand.";
+    return table(["workflow", "status", "created", "id"], runs.map((r) => [r.workflowName, r.status, dateOnly(r.createdAt), r._id]));
+}
+export function formatImportSummary(result, mode = {}) {
+    const lines = [];
+    const heading = mode.dryRun
+        ? "Workflow import preview:"
+        : result.created
+            ? "Workflow imported."
+            : mode.update
+                ? "Workflow updated."
+                : "Workflow import preview:";
+    lines.push(heading);
+    lines.push(`name:        ${result.name}`);
+    if (result.workflowId)
+        lines.push(`workflowId:  ${result.workflowId}`);
+    lines.push(`nodes:       ${result.nodeCount}`);
+    lines.push(`edges:       ${result.edgeCount}`);
+    if (result.unresolved.length > 0) {
+        lines.push("");
+        lines.push(`Unresolved references (${result.unresolved.length}):`);
+        for (const ref of result.unresolved) {
+            lines.push(`  ${ref.nodeId.padEnd(20)} ${ref.ref.padEnd(7)} ${ref.value} — ${ref.message}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("");
+        lines.push(`Warnings (${result.warnings.length}):`);
+        for (const warning of result.warnings)
+            lines.push(`  ${warning}`);
+    }
+    return lines.join("\n");
+}
+export function formatWorkflowRun(run) {
+    const lines = [];
+    const counts = formatCounts(run.counts);
+    lines.push(`Workflow run — ${run.workflowName}`);
+    lines.push(`runId:        ${run._id}`);
+    lines.push(`workflowId:   ${run.workflowId}`);
+    if (run.triggerRunId)
+        lines.push(`triggerRunId: ${run.triggerRunId}`);
+    lines.push(`verdict:      ${run.status}${counts ? ` (${counts})` : ""}`);
+    if (run.isTerminal)
+        lines.push("terminal:     yes");
+    if (run.error)
+        lines.push(`error:        ${run.error}`);
+    if (Object.keys(run.inputs ?? {}).length > 0) {
+        const inputs = Object.entries(run.inputs).map(([k, v]) => `${k}=${v}`).join(", ");
+        lines.push(`inputs:       ${inputs}`);
+    }
+    if (run.nodes.length > 0) {
+        lines.push("");
+        lines.push(`Nodes (${run.nodes.length}):`);
+        for (const node of run.nodes) {
+            lines.push(progressLine(node));
+            for (const output of node.outputs)
+                lines.push(...outputLines(output));
+        }
+    }
+    if (run.outputs && run.outputs.length > 0) {
+        lines.push("");
+        lines.push(`Outputs (${run.outputs.length}):`);
+        for (const output of run.outputs)
+            lines.push(...runOutputLines(output));
+    }
+    return lines.join("\n");
+}
+function runOutputLines(output) {
+    const slug = output.botSlug ? ` (${output.botSlug})` : "";
+    if (output.type === "image") {
+        return [`  ${output.label} [image]${slug}: ${output.imageUrl ?? output.imageId ?? "(no url)"}`];
+    }
+    const raw = output.text ?? "";
+    const normalized = raw.replace(/\s+/g, " ").trim();
+    const body = truncateText(raw, 400);
+    const note = normalized.length > 400 ? "\n    (truncated — use --json for the full text)" : "";
+    return [`  ${output.label} [text]${slug}:`, `    ${body}${note}`];
+}
+export function formatDescribe(res) {
+    const lines = [];
+    lines.push(`Workflow — ${res.name}`);
+    lines.push(`workflowId:  ${res.workflowId}`);
+    if (res.description)
+        lines.push(`description:  ${res.description}`);
+    lines.push(`updated:     ${dateOnly(res.updatedAt)}`);
+    lines.push("");
+    lines.push(`Inputs (${res.inputs.length}):`);
+    if (res.inputs.length === 0) {
+        lines.push("  (none — this workflow takes no run inputs)");
+    }
+    else {
+        for (const input of res.inputs) {
+            const req = input.required ? "required" : "optional";
+            const bundle = input.bundleSize !== undefined ? `, bundle=${input.bundleSize}` : "";
+            lines.push(`  ${input.fieldName} — ${input.source}, ${req}${bundle}`);
+            if (input.description)
+                lines.push(`      ${input.description}`);
+        }
+    }
+    lines.push("");
+    lines.push(`Prerequisites (${res.prerequisites.length}):`);
+    if (res.prerequisites.length === 0) {
+        lines.push("  (none — no stored primers required)");
+    }
+    else {
+        for (const prereq of res.prerequisites) {
+            const mark = prereq.stored ? "✓ stored" : "✗ MISSING";
+            lines.push(`  ${mark}  ${prereq.primerKind} primer  (nodes: ${prereq.nodeIds.join(", ")})`);
+        }
+        const missing = res.prerequisites.filter((p) => !p.stored);
+        if (missing.length > 0) {
+            lines.push("");
+            lines.push(`  ✗ ${missing.length} primer(s) not stored for this brand — add ${missing
+                .map((p) => `"${p.primerKind}"`)
+                .join(", ")} before running, or those nodes fail.`);
+        }
+    }
+    lines.push("");
+    lines.push(`Outputs (${res.outputs.length}):`);
+    if (res.outputs.length === 0) {
+        lines.push("  (none wired into an Output node)");
+    }
+    else {
+        for (const output of res.outputs) {
+            const slug = output.botSlug ? ` (${output.botSlug})` : "";
+            lines.push(`  ${output.label} [${output.type}]${slug}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatBotVocabulary(catalog) {
+    const v = catalog.vocabulary;
+    const lines = [];
+    lines.push("Vocabulary:");
+    lines.push(`  node kinds:    ${v.nodeKinds.join(", ")}`);
+    lines.push(`  brief sources: ${v.briefSources.join(", ")}`);
+    lines.push(`  primer kinds:  ${v.primerKinds.join(", ")}`);
+    lines.push(`  image models:  ${v.imageModels.join(", ")}`);
+    lines.push(`  aspect ratios: ${v.aspectRatios.join(", ")}`);
+    lines.push(`  custom bot:    set a bot node's slug to "${catalog.customBot.slug}" and ` +
+        `config.${catalog.customBot.configKey}=<genesis-slug> to reach any bot not listed here.`);
+    return lines.join("\n");
+}
+export function formatBotsList(catalog, category) {
+    const bots = category
+        ? catalog.bots.filter((b) => b.category === category)
+        : catalog.bots;
+    if (bots.length === 0) {
+        const known = catalog.vocabulary.categories.map((c) => c.id).join(", ");
+        return category
+            ? `No bots in category "${category}". Known categories: ${known}`
+            : "No bots in the catalog.";
+    }
+    const lines = [];
+    let currentCategory = null;
+    for (const bot of bots) {
+        if (bot.category !== currentCategory) {
+            if (currentCategory !== null)
+                lines.push("");
+            lines.push(`${bot.categoryLabel} (${bot.category})`);
+            currentCategory = bot.category;
+        }
+        lines.push(`  ${bot.slug} — ${bot.blurb}`);
+    }
+    if (!category) {
+        lines.push("");
+        lines.push(formatBotVocabulary(catalog));
+    }
+    return lines.join("\n");
+}
+export function formatBotDetail(bot) {
+    const lines = [];
+    lines.push(`${bot.name}  (slug: ${bot.slug})`);
+    lines.push(`category:    ${bot.categoryLabel} (${bot.category})`);
+    lines.push(`blurb:       ${bot.blurb}`);
+    lines.push(`outputType:  ${bot.outputType}`);
+    lines.push(`splits:      ${bot.splitsOutput ? "yes (can split into per-item deliverables)" : "no"}`);
+    lines.push("");
+    lines.push(`Input ports (${bot.inputs.length}):`);
+    if (bot.inputs.length === 0) {
+        lines.push("  (none)");
+    }
+    else {
+        for (const input of bot.inputs) {
+            const bits = [`accepts ${input.accepts.join("/")}`, input.required ? "required" : "optional"];
+            if (input.multi)
+                bits.push("multi");
+            if (input.primerKinds && input.primerKinds.length > 0) {
+                bits.push(`primer-gate: ${input.primerKinds.join("/")}`);
+            }
+            lines.push(`  ${input.id} — ${bits.join(", ")}`);
+        }
+    }
+    lines.push("");
+    lines.push(`Params (${bot.params.length}):`);
+    if (bot.params.length === 0) {
+        lines.push("  (none)");
+    }
+    else {
+        for (const param of bot.params) {
+            const bits = [param.kind];
+            if (param.options && param.options.length > 0)
+                bits.push(`options: ${param.options.join("|")}`);
+            if (param.min !== undefined)
+                bits.push(`min ${param.min}`);
+            if (param.max !== undefined)
+                bits.push(`max ${param.max}`);
+            if (param.required)
+                bits.push("required");
+            if (param.default !== undefined)
+                bits.push(`default "${param.default}"`);
+            lines.push(`  config.${param.key} — ${param.label} (${bits.join(", ")})`);
+            if (param.help)
+                lines.push(`      ${param.help}`);
+        }
+    }
+    return lines.join("\n");
+}
+function graphIssueLines(issue) {
+    const node = issue.nodeId ? ` [node ${issue.nodeId}]` : "";
+    const port = issue.portId ? ` [port ${issue.portId}]` : "";
+    const edge = !issue.nodeId && issue.edgeId ? ` [edge ${issue.edgeId}]` : "";
+    const out = [`${issue.code}${node}${edge}${port}: ${issue.message}`];
+    if (issue.remedy)
+        out.push(`  fix: ${issue.remedy}`);
+    return out;
+}
+function formatImportError(res) {
+    const data = isRecord(res.data) ? res.data : {};
+    const err = isRecord(data.error) ? data.error : {};
+    const code = typeof err.code === "string" ? err.code : undefined;
+    const message = typeof err.message === "string" ? err.message : "Import failed";
+    if (code === "INVALID_GRAPH") {
+        const issues = Array.isArray(data.issues) ? data.issues : [];
+        const lines = [`Import rejected — invalid graph: ${message}`];
+        if (issues.length > 0) {
+            lines.push("");
+            lines.push(`Issues (${issues.length}):`);
+            for (const issue of issues)
+                lines.push(...graphIssueLines(issue));
+        }
+        return lines.join("\n");
+    }
+    if (code === "CONFLICT") {
+        const lines = [`Import conflict — ${message}`];
+        if (typeof data.currentUpdatedAt === "string") {
+            lines.push(`current updatedAt: ${data.currentUpdatedAt}`);
+        }
+        const remedy = typeof data.remedy === "string"
+            ? data.remedy
+            : "Re-export the workflow, reapply your edits, and import again with the fresh updatedAt.";
+        lines.push(`fix: ${remedy}`);
+        return lines.join("\n");
+    }
+    return formatError(res);
+}
+export async function resolveWorkflowId(ref, deps) {
+    const res = await deps.get(LIST_PATH);
+    if (!res.ok)
+        throw new Error(formatError(res));
+    const workflows = res.data.workflows ?? [];
+    const match = workflows.find((w) => w.name.toLowerCase() === ref.toLowerCase());
+    return match?._id ?? ref;
+}
+export async function listFlow(json, deps) {
+    const res = await deps.get(LIST_PATH);
+    if (!res.ok)
+        return asErrorResult(res, json);
+    const data = res.data;
+    return {
+        code: 0,
+        lines: json ? [JSON.stringify(data)] : [formatWorkflowList(data.workflows ?? [])],
+    };
+}
+export async function describeFlow(workflowRef, opts, deps) {
+    let workflowId;
+    try {
+        workflowId = await resolveWorkflowId(workflowRef, deps);
+    }
+    catch (e) {
+        return { code: 1, lines: [e instanceof Error ? e.message : String(e)] };
+    }
+    const res = await deps.get(`${DESCRIBE_PATH}?id=${encodeURIComponent(workflowId)}`);
+    if (!res.ok)
+        return asErrorResult(res, opts.json);
+    if (opts.json)
+        return { code: 0, lines: [JSON.stringify(res.data)] };
+    return { code: 0, lines: [formatDescribe(res.data)] };
+}
+export async function botsFlow(opts, deps) {
+    const res = await deps.get(CATALOG_PATH);
+    if (!res.ok)
+        return asErrorResult(res, opts.json);
+    const catalog = res.data;
+    if (opts.slug) {
+        const bot = catalog.bots.find((b) => b.slug === opts.slug);
+        if (!bot) {
+            const line = opts.json
+                ? JSON.stringify({ ok: false, error: `unknown bot slug "${opts.slug}"` })
+                : `No bot with slug "${opts.slug}" in the catalog. Run "exodus workflow bots" to list them.`;
+            return { code: 1, lines: [line] };
+        }
+        return { code: 0, lines: [opts.json ? JSON.stringify(bot) : formatBotDetail(bot)] };
+    }
+    if (opts.json)
+        return { code: 0, lines: [JSON.stringify(catalog)] };
+    return { code: 0, lines: [formatBotsList(catalog, opts.category)] };
+}
+export async function runFlow(workflowRef, opts, deps) {
+    let workflowId;
+    try {
+        workflowId = await resolveWorkflowId(workflowRef, deps);
+    }
+    catch (e) {
+        return { code: 1, lines: [e instanceof Error ? e.message : String(e)] };
+    }
+    const body = {
+        workflowId,
+        ...(Object.keys(opts.inputs).length > 0 ? { inputs: opts.inputs } : {}),
+    };
+    const start = await deps.post(RUN_PATH, body);
+    if (!start.ok)
+        return asErrorResult(start, opts.json);
+    const data = start.data;
+    const base = { ...data, workflowId };
+    if (opts.json && !opts.wait)
+        return { code: 0, lines: [JSON.stringify(base)] };
+    const lines = opts.json
+        ? []
+        : [
+            "Workflow run started.",
+            `runId:        ${data.runId}`,
+            `triggerRunId: ${data.triggerRunId}`,
+            `Poll: exodus workflow status --id ${data.runId}`,
+        ];
+    if (!opts.wait)
+        return { code: 0, lines };
+    if (!opts.json && opts.onProgressLine) {
+        for (const line of lines)
+            opts.onProgressLine(line);
+        lines.length = 0;
+    }
+    const seen = new Map();
+    const pollResult = await deps.poll({
+        path: `${STATUS_PATH}?runId=${encodeURIComponent(data.runId)}`,
+        intervalMs: 3_000,
+        timeoutMs: 60 * 60 * 1000,
+        terminalStatuses: ["completed", "partial", "failed"],
+        onProgress: (raw) => {
+            if (opts.json || !opts.onProgressLine)
+                return;
+            const nodes = Array.isArray(raw["nodes"]) ? raw["nodes"] : [];
+            for (const node of nodes) {
+                if (seen.get(node.nodeId) === node.status)
+                    continue;
+                seen.set(node.nodeId, node.status);
+                opts.onProgressLine(progressLine(node));
+            }
+        },
+    });
+    if (opts.json) {
+        return {
+            code: pollResult.ok ? 0 : 1,
+            lines: [JSON.stringify({ ...base, result: pollResult.data, timedOut: pollResult.timedOut })],
+        };
+    }
+    if (pollResult.timedOut) {
+        lines.push(`Timed out waiting. Check later: exodus workflow status --id ${data.runId}`);
+        return { code: 1, lines };
+    }
+    lines.push("");
+    if (isRecord(pollResult.data) && typeof pollResult.data["_id"] === "string") {
+        lines.push(formatWorkflowRun(pollResult.data));
+    }
+    else {
+        lines.push(`Polling failed: ${JSON.stringify(pollResult.data)}`);
+    }
+    return { code: pollResult.ok ? 0 : 1, lines };
+}
+export async function statusFlow(opts, deps) {
+    const path = opts.id ? `${STATUS_PATH}?runId=${encodeURIComponent(opts.id)}` : STATUS_PATH;
+    const res = await deps.get(path);
+    if (!res.ok)
+        return asErrorResult(res, opts.json);
+    if (opts.json)
+        return { code: 0, lines: [JSON.stringify(res.data)] };
+    if (opts.id)
+        return { code: 0, lines: [formatWorkflowRun(res.data)] };
+    const runs = (res.data.runs ?? []);
+    return { code: 0, lines: [formatRecentRuns(runs)] };
+}
+export async function exportFlow(workflowRef, opts, deps) {
+    let workflowId;
+    try {
+        workflowId = await resolveWorkflowId(workflowRef, deps);
+    }
+    catch (e) {
+        return { code: 1, lines: [e instanceof Error ? e.message : String(e)] };
+    }
+    const res = await deps.get(`${EXPORT_PATH}?id=${encodeURIComponent(workflowId)}`);
+    if (!res.ok)
+        return asErrorResult(res, false);
+    const doc = JSON.stringify(res.data, null, 2);
+    if (opts.out) {
+        deps.writeFile(opts.out, `${doc}\n`);
+        return { code: 0, lines: [`Wrote workflow contract to ${opts.out}.`] };
+    }
+    return { code: 0, lines: [doc] };
+}
+export async function importFlow(file, opts, deps) {
+    let text;
+    try {
+        text = deps.readFile(file);
+    }
+    catch {
+        return { code: 1, lines: [`Error: file not found: ${file}`] };
+    }
+    let parsed;
+    try {
+        parsed = 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}`] };
+    }
+    if (!isRecord(parsed)) {
+        return { code: 1, lines: [`Error: ${file} is not a workflow contract (expected a JSON object).`] };
+    }
+    const body = { ...parsed };
+    delete body.dryRun;
+    delete body.targetWorkflowId;
+    delete body.expectedUpdatedAt;
+    if (opts.dryRun)
+        body.dryRun = true;
+    if (opts.update) {
+        const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : undefined;
+        if (!updatedAt) {
+            return {
+                code: 1,
+                lines: [
+                    `Error: ${file} has no "updatedAt" anchor, so drift can't be detected. ` +
+                        `Re-export the workflow first (exodus workflow export <id> --out ${file}) and retry --update.`,
+                ],
+            };
+        }
+        body.targetWorkflowId = opts.update;
+        body.expectedUpdatedAt = updatedAt;
+    }
+    const res = await deps.post(IMPORT_PATH, body);
+    if (!res.ok) {
+        return {
+            code: 1,
+            lines: opts.json
+                ? [JSON.stringify({ ok: false, status: res.status, data: res.data })]
+                : [formatImportError(res)],
+        };
+    }
+    const data = res.data;
+    return {
+        code: 0,
+        lines: opts.json
+            ? [JSON.stringify(data)]
+            : [formatImportSummary(data, { dryRun: opts.dryRun, update: !!opts.update })],
+    };
+}
+function flagString(flags, name) {
+    const v = flags[name];
+    return typeof v === "string" ? v : undefined;
+}
+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 === "describe") {
+        const workflowRef = rest[0];
+        if (!workflowRef) {
+            console.error("Error: workflow describe requires <workflowId|name>.");
+            console.log("Usage: exodus workflow describe <workflowId|name> [--json]");
+            process.exit(1);
+        }
+        return printResult(await describeFlow(workflowRef, { json }, defaultDeps));
+    }
+    if (sub === "bots") {
+        return printResult(await botsFlow({ category: flagString(flags, "category"), slug: flagString(flags, "slug"), json }, defaultDeps));
+    }
+    if (sub === "run") {
+        const workflowRef = rest[0];
+        if (!workflowRef) {
+            console.error("Error: workflow run requires <workflowId|name>.");
+            console.log("Usage: exodus workflow run <workflowId|name> [--input key=value ...] [--wait] [--json]");
+            process.exit(1);
+        }
+        let inputs;
+        try {
+            inputs = parseInputFlags(process.argv.slice(3), defaultDeps.readFile);
+        }
+        catch (e) {
+            console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+            process.exit(1);
+        }
+        return printResult(await runFlow(workflowRef, {
+            inputs,
+            wait: flags["wait"] === true,
+            json,
+            onProgressLine: (line) => console.log(line),
+        }, defaultDeps));
+    }
+    if (sub === "status") {
+        return printResult(await statusFlow({ id: flagString(flags, "id"), json }, defaultDeps));
+    }
+    if (sub === "export") {
+        const workflowRef = rest[0];
+        if (!workflowRef) {
+            console.error("Error: workflow export requires <workflowId|name>.");
+            console.log("Usage: exodus workflow export <workflowId|name> [--out <file>]");
+            process.exit(1);
+        }
+        return printResult(await exportFlow(workflowRef, { out: flagString(flags, "out") }, defaultDeps));
+    }
+    if (sub === "import") {
+        const file = rest[0];
+        if (!file) {
+            console.error("Error: workflow import requires <file>.");
+            console.log("Usage: exodus workflow import <file> [--update <workflowId>] [--dry-run] [--json]");
+            process.exit(1);
+        }
+        return printResult(await importFlow(file, { dryRun: flags["dry-run"] === true, json, update: flagString(flags, "update") }, defaultDeps));
+    }
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}

package/package.json

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