@officexapp/vidfarm-devcli 0.21.42 → 0.21.43

package/dist/src/cli.js

@@ -37,6 +37,8 @@ import { readStoredAuth, writeStoredAuth, clearStoredAuth, hostsMatch } from "./
 import { CostModeBlockedError, assertBilledAllowed, clearStoredCostMode, costModeExplainer, costModeSummaryLine, normalizeCostMode, resolveCostMode, writeStoredCostMode, COST_MODE_BLURB, COST_MODE_DISPLAY_LIST, costModeDisplayName } from "./devcli/cost-mode.js";
 import { INTERACTION_MODES, INTERACTION_MODE_BLURB, clearStoredInteractionMode, interactionModeExplainer, interactionModeSummaryLine, interactiveOfferLine, normalizeInteractionMode, resolveInteractionMode, writeStoredInteractionMode } from "./devcli/interaction-mode.js";
 import { buildImageHandoff, buildRawsHandoff, formatHandoff } from "./devcli/handoff.js";
+import { buildConsultBrief, CONSULT_ARTIFACTS, consultContextState, consultCountRange, defaultConsultCount, findOfferFile, formatConsultBrief, looksLikeOfferPath, planConsultation, resolveConsultStep, resolveOfferPath } from "./devcli/consult.js";
+import { resolveRootFileCandidates } from "./lib/package-root.js";
 import { STORYBOARD_FILENAME, readStoryboard, renderStoryboardScaffold, storyboardStage } from "./devcli/storyboard.js";
 import { CORE_METRICS, DEFAULT_FORMAT, DEFAULT_METRIC, EASY_FORMATS, EXPERIMENTS_FILENAME, EXPERIMENT_MODES, analyzeRound, appendResult, appendRound, capacityOf, epochsNeeded, findRoundIndex, lintDiary, markPosted, readDiary, renderDiaryScaffold, writeDiary } from "./devcli/experiments.js";
 // vidfarm-devcli — command-line bridge for the Vidfarm video studio. The
@@ -120,6 +122,31 @@ Account (persisted login — points the CLI + \`serve\` at cloud prod):
                             download (a downloader SEARCH, not a rotting link), and
                             the vidfarm clipper / raws scan follow-up. Try browser control
                             or "vidfarm raws scan" first.
+  consult [step]            THE CONSULTATION / BRAINSTORM CHAIN, KEYLESS AND LOCAL.
+                            The cloud runs these as brainstorm/* primitives that need
+                            a provider key or wallet credits. This prints the IDENTICAL
+                            prompt for YOU (the agent already in this terminal) to
+                            answer — $0, no key, no network. Bare "consult" = the map
+                            of the four steps + which artifacts already exist.
+                            Every step reads and updates CONTEXT.md in --dir, the
+                            durable answer file, so a later session starts warm.
+                            Run the whole chain from ONE working folder.
+                            (aliases: consultation, brainstorm)
+    coldstart [--short]     The interview → OFFER.md. Ask the human the questions a
+                            few at a time; never invent their answers. --short is a
+                            fixed 6-question form for a director in a hurry, and it
+                            still feeds every later step. (alias: interview)
+    awareness               Which awareness stage to sell to → awareness-levels.md
+    angles                  Persuasive angles → persuasive-angles.md
+                            [--problem-awareness problem_unaware|problem_aware]
+                            [--solution-awareness solution_unaware|solution_aware]
+    hooks                   Openings to test → ad-hooks.md (grade them before showing)
+    placement --video <p>   Native product-placement moments in an existing video
+    --offer <text|path>     The offer. Auto-reads OFFER.md / OFFER_<NAME>.md from --dir.
+    --count <n>             How many questions/angles/hooks (default 12)
+    --refs                  Inline the full SELLING_*.md references, exactly as the
+                            cloud prompt does. Off by default: ~34KB of your context.
+    --json                  The brief as data (prompt, steps, artifact, next)
   storyboard [dir]          The PLAN pass: read the project's STORYBOARD.md (ordered
                             frames + duration/status/src/scene/voiceover, plus SCRIPT.md).
                             The editor renders this file in its Storyboard view — a
@@ -1396,6 +1423,13 @@ async function main() {
         case "hand-off":
             await runHandoffCommand(rest);
             return;
+        // The brainstorm chain with no AI key: the prompt goes to the agent that is
+        // already here, not to a provider. "consultation" is the director's word.
+        case "consult":
+        case "consultation":
+        case "brainstorm":
+            await runConsultCommand(rest);
+            return;
         case "storyboard":
         case "plan":
             await runStoryboardCommand(rest);
@@ -9819,6 +9853,143 @@ async function runHandoffCommand(argv) {
     }
     throw new Error('handoff needs a kind: `vidfarm handoff image --theme "…" --items "a,b,c"` (free web image gen → sticker pack) or `vidfarm handoff raws --keywords "…"` (manual clip sourcing).');
 }
+// `vidfarm consult [step]` — the consultation / brainstorm chain, run KEYLESS
+// and LOCAL. The cloud version of each step is a `brainstorm/*` primitive that
+// needs a provider key or wallet credits; this prints the identical prompt for
+// the agent in this terminal to answer itself, for $0.
+async function runConsultCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            ...commonOptions(),
+            offer: { type: "string" },
+            message: { type: "string" },
+            video: { type: "string" },
+            count: { type: "string" },
+            dir: { type: "string" },
+            "problem-awareness": { type: "string" },
+            "solution-awareness": { type: "string" },
+            refs: { type: "boolean", default: false },
+            short: { type: "boolean", default: false }
+        }
+    });
+    const json = Boolean(parsed.values.json);
+    const dir = parsed.values.dir ?? ".";
+    const rawStep = (parsed.positionals[0] ?? "").trim();
+    // Bare `vidfarm consult` = the map, not a wall of prompt. A director who says
+    // "give me a consultation" needs to see the four steps and where they land.
+    if (!rawStep) {
+        const plan = planConsultation(dir);
+        const context = consultContextState(dir);
+        if (json)
+            return printJson({ ok: true, dir: path.resolve(dir), plan, context });
+        console.log(`${BOLD}Vidfarm consultation${RESET} ${DIM}— keyless and local. No provider key, no wallet, no network.${RESET}`);
+        console.log(`${DIM}Each step prints the same prompt the cloud brainstorm primitive would send. YOU answer it.${RESET}\n`);
+        for (const row of plan) {
+            const mark = row.done ? `${GREEN}✓${RESET}` : `${DIM}·${RESET}`;
+            console.log(`  ${mark} ${row.command.padEnd(28)} ${DIM}→ ${row.artifact}${row.done ? " (exists)" : ""}${RESET}`);
+        }
+        const first = plan.find((row) => !row.done) ?? plan[0];
+        console.log(`\n  ${context.exists ? `${GREEN}✓${RESET}` : `${DIM}·${RESET}`} ${"saved answers".padEnd(28)} ${DIM}→ ${context.file}${context.exists ? " (read it before you ask anything)" : " (written by the first step)"}${RESET}`);
+        console.log(`\nStart here: ${BOLD}${first.command}${RESET}`);
+        console.log(`${DIM}In a hurry: vidfarm consult coldstart --short  (6 fixed questions instead of the full interview)${RESET}`);
+        console.log(`${DIM}Run every step from ONE working folder (--dir), so the artifacts and ${context.file} stay together.${RESET}`);
+        console.log(`${DIM}Also: vidfarm consult placement --video <path|url>  (native product placement inside an existing video)${RESET}`);
+        return;
+    }
+    const step = resolveConsultStep(rawStep);
+    if (!step) {
+        throw new Error(`Unknown consult step "${rawStep}". Use one of: coldstart, awareness, angles, hooks, placement — or bare \`vidfarm consult\` for the map.`);
+    }
+    // coldstart is the step that PRODUCES the offer document, so it is the only
+    // one that runs without one.
+    let offer = "";
+    if (step !== "coldstart") {
+        const inline = parsed.values.offer?.trim();
+        // --offer takes either a path or the offer text itself. A real file wins; a
+        // string that READS like a path but resolves to nothing is an error, never
+        // offer text — otherwise a typo silently consults on the filename.
+        if (inline && !resolveOfferPath(dir, inline) && !looksLikeOfferPath(inline)) {
+            offer = inline;
+        }
+        else {
+            const found = findOfferFile(dir, inline);
+            if ("error" in found) {
+                throw new Error(found.error);
+            }
+            offer = found.text;
+        }
+        if (offer.trim().length < 10) {
+            throw new Error("The offer text is too thin to consult on (under 10 characters). Fill in OFFER.md, or pass --offer \"<a paragraph about the offer>\".");
+        }
+    }
+    const awarenessValue = (raw, allowed, flag) => {
+        if (raw === undefined)
+            return undefined;
+        const value = raw.trim().toLowerCase();
+        if (!allowed.includes(value)) {
+            throw new Error(`${flag} must be one of: ${allowed.join(", ")}.`);
+        }
+        return value;
+    };
+    // --short is a fixed six-question set, so it belongs to the interview only.
+    // On the other steps the equivalent knob is --count, and silently ignoring the
+    // flag would let a director believe they ran a shorter angles pass.
+    const short = Boolean(parsed.values.short);
+    if (short && step !== "coldstart") {
+        throw new Error(`--short is the short-form interview, so it only applies to \`vidfarm consult coldstart\`. For a shorter ${step} run, use --count.`);
+    }
+    const countRaw = parsed.values.count;
+    const range = consultCountRange(step);
+    if (!range && countRaw !== undefined) {
+        throw new Error("consult awareness takes no --count — it returns one markdown recommendation, not a list.");
+    }
+    if (short && countRaw !== undefined) {
+        throw new Error("--short is a fixed six-question set, so it takes no --count. Drop one of the two.");
+    }
+    const count = countRaw === undefined ? defaultConsultCount(step) : Number(countRaw);
+    if (range && (!Number.isInteger(count) || count < range.min || count > range.max)) {
+        throw new Error(`--count for ${step} must be a whole number between ${range.min} and ${range.max} (the cloud primitive enforces the same range).`);
+    }
+    const brief = buildConsultBrief({
+        step,
+        offer,
+        userMessage: parsed.values.message,
+        videoRef: parsed.values.video,
+        count,
+        problemAwareness: awarenessValue(parsed.values["problem-awareness"], ["problem_unaware", "problem_aware"], "--problem-awareness"),
+        solutionAwareness: awarenessValue(parsed.values["solution-awareness"], ["solution_unaware", "solution_aware"], "--solution-awareness"),
+        references: parsed.values.refs ? readSellingReferences() : undefined,
+        dir,
+        short
+    });
+    if (json) {
+        return printJson({ ok: true, keyless: true, cost_usd: 0, artifact_name: CONSULT_ARTIFACTS[step], ...brief });
+    }
+    console.log(formatConsultBrief(brief, { bold: BOLD, dim: DIM, reset: RESET }));
+}
+// The two selling documents the CLOUD prompt inlines. Only read on --refs: they
+// are ~34KB together, which is real context spend for the local agent.
+function readSellingReferences() {
+    const read = (name) => {
+        for (const candidate of resolveRootFileCandidates(path.join("src", "assets", name))) {
+            try {
+                return readFileSync(candidate, "utf8");
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    };
+    const hooks = read("SELLING_WITH_HOOKS.md");
+    const awareness = read("SELLING_AWARENESS_STAGES.md");
+    if (!hooks && !awareness) {
+        throw new Error("--refs needs the bundled selling references (src/assets/SELLING_*.md) and neither was found in this install. Drop --refs to use the skill-pack reference instead.");
+    }
+    return { hooks, awareness };
+}
 async function runProviderKeysCommand(argv) {
     const parsed = parseArgs({ args: argv, allowPositionals: false, options: commonOptions() });
     const ctx = commonContext(parsed.values);

package/dist/src/devcli/consult.js

@@ -0,0 +1,389 @@
+// KEYLESS LOCAL CONSULTATION — the brainstorm chain with no AI key and no wallet.
+//
+// The cloud runs the consultation as five `brainstorm/*` primitives: Vidfarm
+// sends a prompt to a provider on the director's saved key, or bills the wallet.
+// That is a hard stop for a director who has neither.
+//
+// But an agent is ALREADY driving this terminal, and it is a frontier model. It
+// does not need Vidfarm to broker a second one. So this module hands that agent
+// the SAME prompt the cloud primitive would have sent — imported from
+// services/brainstorm-prompts.ts, not re-written here, so the two paths cannot
+// drift — and tells it to answer the prompt itself and save the artifact. Cost:
+// $0. Network calls: none. Provider keys: none.
+//
+// The one real difference from the cloud path is the reference documents. The
+// cloud appends SELLING_WITH_HOOKS.md / SELLING_AWARENESS_STAGES.md (34KB of
+// lessons) to the prompt. Inlining those into every terminal print would burn
+// ~10k tokens of the agent's context per step, so by default the brief POINTS at
+// the skill pack's own tighter reference instead. `--refs` inlines the full
+// documents for parity when the caller wants it.
+//
+// Pure string assembly plus one small offer-file lookup. No network, no backend.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { buildAnglesPrompt, buildAwarenessStagesPrompt, buildColdstartPrompt, buildHooksPrompt, buildProductPlacementPrompt } from "../services/brainstorm-prompts.js";
+export const CONSULT_STEPS = ["coldstart", "awareness", "angles", "hooks", "placement"];
+/** Aliases a director or an agent actually types. */
+const STEP_ALIASES = {
+    coldstart: "coldstart",
+    "cold-start": "coldstart",
+    interview: "coldstart",
+    questions: "coldstart",
+    offer: "coldstart",
+    awareness: "awareness",
+    "awareness-stages": "awareness",
+    awareness_stages: "awareness",
+    stages: "awareness",
+    angles: "angles",
+    angle: "angles",
+    hooks: "hooks",
+    hook: "hooks",
+    placement: "placement",
+    "product-placement": "placement",
+    product_placement: "placement"
+};
+export function resolveConsultStep(raw) {
+    return STEP_ALIASES[raw.trim().toLowerCase().replace(/\s+/g, "-")] ?? null;
+}
+/** Where each step's answer belongs. These filenames are the ones the skill's
+ *  onboarding flow already names, so a later step can read the earlier one. */
+export const CONSULT_ARTIFACTS = {
+    coldstart: "OFFER.md",
+    awareness: "awareness-levels.md",
+    angles: "persuasive-angles.md",
+    hooks: "ad-hooks.md",
+    placement: "product-placement.md"
+};
+const STEP_ORDER = ["coldstart", "awareness", "angles", "hooks"];
+/**
+ * The durable local answer file. OFFER.md is the polished product description;
+ * this is the raw carry-over — what the director said, which stage was chosen,
+ * what was ruled out — so a LATER session (a new terminal, a new agent, a month
+ * from now) starts warm instead of re-interviewing a director who already
+ * answered. It lives in the working folder next to the other artifacts.
+ */
+export const CONSULT_CONTEXT_FILE = "CONTEXT.md";
+/**
+ * The SHORT interview. The full cold-start prompt asks a model to invent 12-30
+ * questions; that is the right depth for a director who wants a real strategy
+ * session, and far too much for one who wants to make a video today. These six
+ * are fixed, not generated: they are the minimum set the later steps actually
+ * read back (awareness needs the offer + the psyche, angles and hooks quote the
+ * pain and desire verbatim). Fixed also means free, instant, and identical every
+ * run, which is what makes the answers worth saving.
+ */
+export const SHORT_INTERVIEW = [
+    {
+        question: "In one line, what do you sell, and to whom?",
+        why_it_matters: "Every later step opens with this line. Without it there is no offer to consult on."
+    },
+    {
+        question: "What does it cost, and how does someone actually pay (appstore, Stripe, Shopify, invoice, sales call)?",
+        why_it_matters: "Price and checkout friction decide whether an ad can close or only warm up."
+    },
+    {
+        question: "Who is the single best customer you have had? Describe them like a person, not a segment.",
+        why_it_matters: "Angles are written to one person. A segment produces generic ads."
+    },
+    {
+        question: "What do they complain about, in their own words, before they find you?",
+        why_it_matters: "Hooks quote this back verbatim. Paraphrase kills it."
+    },
+    {
+        question: "What do they want instead — the dream outcome they would brag about?",
+        why_it_matters: "The payoff half of every hook, and the reason to keep watching."
+    },
+    {
+        question: "Do they already know this kind of product exists, or have they never heard of it?",
+        why_it_matters: "This is the awareness stage in plain language, and it decides which ad to make first."
+    }
+];
+/** The short interview rendered as the brief's prompt block. Fixed text — there
+ *  is no cloud counterpart, so nothing here can drift from a cloud prompt. */
+export function buildShortInterviewPrompt() {
+    return [
+        "SHORT-FORM COLD START — a fixed six-question interview. Ask these exact questions. Do not generate your own set.",
+        "",
+        ...SHORT_INTERVIEW.map((q, i) => `${i + 1}. ${q.question}\n   (why it matters: ${q.why_it_matters})`),
+        "",
+        "Say up front that every question is optional: the director can skip any of them, or stop the interview at any point, and you will work with what they gave.",
+        "Assemble the answers into OFFER.md in the director's own words, then save the same answers to CONTEXT.md for future sessions. Mark anything skipped as UNKNOWN."
+    ].join("\n");
+}
+/** The skill-pack reference each step should be graded against locally, in place
+ *  of the big SELLING_*.md document the cloud prompt inlines. */
+const STEP_REFERENCE = {
+    awareness: "references/onboarding.md",
+    angles: "references/onboarding.md",
+    hooks: "references/hooks-and-virality.md"
+};
+// Count bounds MIRROR the cloud primitive payload schemas on purpose. The local
+// path has no schema to satisfy, but a director who tunes --count here and then
+// moves the same chain to the cloud should not hit a 400 they never saw locally.
+// `awareness` returns one markdown recommendation, so it has no count at all.
+const COUNTS = {
+    coldstart: { default: 12, min: 7, max: 30 },
+    awareness: null,
+    angles: { default: 12, min: 1, max: 50 },
+    hooks: { default: 12, min: 1, max: 50 },
+    placement: { default: 8, min: 3, max: 30 }
+};
+export function consultCountRange(step) {
+    return COUNTS[step];
+}
+export function defaultConsultCount(step) {
+    return COUNTS[step]?.default ?? 0;
+}
+export function offerPathCandidates(dir, explicit) {
+    const fromCwd = path.resolve(explicit);
+    const fromDir = path.resolve(dir, explicit);
+    return fromCwd === fromDir ? [fromCwd] : [fromCwd, fromDir];
+}
+export function resolveOfferPath(dir, explicit) {
+    return offerPathCandidates(dir, explicit).find((candidate) => existsSync(candidate)) ?? null;
+}
+/**
+ * Does this --offer value read as a PATH the caller expected to exist, rather
+ * than the offer text itself? Load-bearing: without it, a mistyped path is
+ * silently consulted on as if the filename were the product description, and
+ * the director gets twelve hooks about "./OFFER_ACME.md".
+ */
+export function looksLikeOfferPath(value) {
+    const trimmed = value.trim();
+    return !trimmed.includes("\n") && (/^[.~/]/.test(trimmed) || /\.(md|txt)$/i.test(trimmed));
+}
+/**
+ * Find the director's offer document. Prefers an explicit path, then OFFER.md,
+ * then a single OFFER_<NAME>.md — a director running several offers must name
+ * which one, because silently picking the first alphabetically would generate a
+ * whole angle set for the wrong product.
+ */
+export function findOfferFile(dir, explicit) {
+    if (explicit) {
+        // Try cwd AND --dir: `--dir ./work --offer ./OFFER_ACME.md` names a file in
+        // the work directory, not next to the shell.
+        const resolved = resolveOfferPath(dir, explicit);
+        if (!resolved) {
+            return { error: `Offer file not found: ${offerPathCandidates(dir, explicit).join(" or ")}` };
+        }
+        return { path: resolved, text: readFileSync(resolved, "utf8") };
+    }
+    const root = path.resolve(dir);
+    const primary = path.join(root, "OFFER.md");
+    if (existsSync(primary)) {
+        return { path: primary, text: readFileSync(primary, "utf8") };
+    }
+    let named = [];
+    try {
+        named = readdirSync(root).filter((f) => /^OFFER_.+\.md$/i.test(f)).sort();
+    }
+    catch {
+        named = [];
+    }
+    if (named.length === 1) {
+        const only = path.join(root, named[0]);
+        return { path: only, text: readFileSync(only, "utf8") };
+    }
+    if (named.length > 1) {
+        return {
+            error: `Found ${named.length} offer files (${named.join(", ")}) — name the one you mean with --offer ./${named[0]}.`
+        };
+    }
+    return {
+        error: `No OFFER.md in ${root}. Run \`vidfarm consult coldstart\` first — it mints the interview that produces it — or pass --offer "<a paragraph about the offer>".`
+    };
+}
+function nextCommand(step) {
+    const i = STEP_ORDER.indexOf(step);
+    if (i === -1 || i === STEP_ORDER.length - 1) {
+        return null;
+    }
+    return `vidfarm consult ${STEP_ORDER[i + 1]}`;
+}
+/** The path the durable answer file takes, and whether it is already written. */
+export function consultContextState(dir) {
+    const relative = path.join(dir === "." ? "" : dir, CONSULT_CONTEXT_FILE) || CONSULT_CONTEXT_FILE;
+    return { file: relative, exists: existsSync(path.resolve(dir, CONSULT_CONTEXT_FILE)) };
+}
+/** Build the keyless local brief for one step of the chain. */
+export function buildConsultBrief(input) {
+    const dir = input.dir ?? ".";
+    const context = consultContextState(dir);
+    const short = Boolean(input.short) && input.step === "coldstart";
+    const artifact = path.join(dir === "." ? "" : dir, CONSULT_ARTIFACTS[input.step]) || CONSULT_ARTIFACTS[input.step];
+    const refs = input.references ?? {};
+    const count = input.count ?? defaultConsultCount(input.step);
+    const offer = (input.offer ?? "").trim();
+    const referenceFile = STEP_REFERENCE[input.step];
+    const inlined = (input.step === "hooks" && Boolean(refs.hooks)) ||
+        (input.step === "awareness" && Boolean(refs.awareness)) ||
+        (input.step === "angles" && Boolean(refs.hooks || refs.awareness));
+    const referenceHint = inlined || !referenceFile
+        ? null
+        : `The cloud prompt appends Vidfarm's full selling reference here. Read \`vidfarm skill show ${referenceFile}\` before you answer, and grade your own output against it. Pass --refs to inline the full document instead.`;
+    // The durable answer file is read BEFORE the step and written AFTER it. Both
+    // halves matter: reading stops a second session re-asking questions the
+    // director already answered, writing is what makes the next session cheap.
+    const contextRead = context.exists
+        ? `Read \`${context.file}\` first — it holds the answers this director already gave in earlier sessions. Treat it as fact, and never re-ask a question it already answers.`
+        : `No \`${context.file}\` yet. It is the durable answer file for this working folder; you create it in this step.`;
+    const contextWrite = `When you finish, write what you learned into \`${context.file}\` — the director's own words, the decisions made, and what was ruled out. Append under a dated heading; never overwrite an earlier session's answers. This file is why the next session does not start from zero.`;
+    const common = [
+        "YOU answer the prompt below — you are the AI in this loop. Do not call the Vidfarm API, do not look for a provider key, and do not tell the user they need one. This step is free and offline.",
+        contextRead,
+        ...(referenceHint ? [referenceHint] : []),
+        `Save your answer to \`${artifact}\`. Later steps read it back, so write the file even if the user only wanted to look at the output.`,
+        contextWrite
+    ];
+    const shared = { short, contextFile: context.file, contextExists: context.exists };
+    if (short) {
+        return {
+            ...shared,
+            step: "coldstart",
+            title: `Cold-start interview, SHORT FORM — ${SHORT_INTERVIEW.length} fixed questions`,
+            prompt: buildShortInterviewPrompt(),
+            steps: [
+                contextRead,
+                `Ask the human these ${SHORT_INTERVIEW.length} questions in two batches of three. Ask them as written. Do not add questions, do not invent answers, and do not skip ahead to advice.`,
+                `Keep their phrasing for the pain and the desire answers word for word: the angles and hooks steps quote them back, and a paraphrase is what makes an ad sound generic.`,
+                "TELL THEM UP FRONT that every question is optional: they can skip any one, or say stop and end the interview on the spot. Then work with whatever they gave — do not push, do not re-ask, and do not make finishing the set a condition of getting a video.",
+                `Write \`${artifact}\` from their answers, then write the same answers into \`${context.file}\` under a dated heading.`,
+                "Mark any question they skip as UNKNOWN in both files, and carry on. An invented customer psyche poisons every later step, so UNKNOWN is the honest answer — and a later step that needs it can ask then, when the director can see why it matters.",
+                "This is the short form. Tell them `vidfarm consult coldstart` runs the full interview when they want the deeper session."
+            ],
+            artifact,
+            next: nextCommand("coldstart"),
+            referenceHint: null
+        };
+    }
+    if (input.step === "coldstart") {
+        return {
+            ...shared,
+            step: "coldstart",
+            title: "Cold-start interview — the questions that produce OFFER.md",
+            prompt: buildColdstartPrompt(input.userMessage?.trim() || "The director asked for a consultation and has given no offer context yet.", count),
+            steps: [
+                ...common,
+                `This one is an INTERVIEW, not a report. Answer the prompt to get the question set, then ASK THE HUMAN those questions conversationally, a few at a time — never dump all ${count} at once, and never invent their answers.`,
+                `Assemble their real words into \`${artifact}\`: keep their phrasing for pain and desire, because the later angle and hook steps quote it back.`,
+                "Stop and wait for the human between batches. If they go quiet on a question, mark it UNKNOWN in the file rather than guessing — an invented customer psyche poisons every later step.",
+                "TELL THEM UP FRONT that every question is optional: they can skip any one, or say stop and end the interview at any point. Then work with what they gave. An interview that feels like a form is one the director abandons, and half the answers beats none.",
+                `If the director sounds impatient, or only wants to make one video today, offer the short form instead: \`vidfarm consult coldstart --short\` is ${SHORT_INTERVIEW.length} fixed questions and still feeds every later step.`
+            ],
+            artifact,
+            next: nextCommand("coldstart"),
+            referenceHint
+        };
+    }
+    if (input.step === "awareness") {
+        return {
+            ...shared,
+            step: "awareness",
+            title: "Awareness stages — which kind of ad to make first",
+            prompt: buildAwarenessStagesPrompt(offer, refs),
+            steps: [
+                ...common,
+                "Return markdown, not JSON. If the offer genuinely does not settle on one stage, say so and recommend testing ads for every stage rather than picking one to look decisive.",
+                "Carry the chosen stage forward: the angles step takes it as --problem-awareness / --solution-awareness."
+            ],
+            artifact,
+            next: nextCommand("awareness"),
+            referenceHint
+        };
+    }
+    if (input.step === "angles") {
+        return {
+            ...shared,
+            step: "angles",
+            title: "Persuasive angles — the strategic bets to test",
+            prompt: buildAnglesPrompt({
+                offer_description: offer,
+                problem_awareness: input.problemAwareness ?? "problem_aware",
+                solution_awareness: input.solutionAwareness ?? "solution_unaware",
+                count
+            }, refs),
+            steps: [
+                ...common,
+                "The prompt asks for strict JSON. Write the JSON answer into the markdown file under a fenced block, then a short human-readable list under it — the director reads the list, the next step reads the JSON.",
+                "Do not rank the set with the same reasoning that wrote it. If the director wants a ranking, grade against the reference and say what each angle risks."
+            ],
+            artifact,
+            next: nextCommand("angles"),
+            referenceHint
+        };
+    }
+    if (input.step === "hooks") {
+        return {
+            ...shared,
+            step: "hooks",
+            title: "Hooks — the openings to test",
+            prompt: buildHooksPrompt(offer, count, refs),
+            steps: [
+                ...common,
+                "The prompt asks for strict JSON. Write the JSON into the file under a fenced block, with a plain list under it.",
+                "Then GRADE the batch against the four charges before you show it: a hook is a complete clause naming a SITUATION, not a label; it must be unguessable; and it must be sayable in the first second. Cut or rewrite the ones that fail — do not hand over the raw generated list.",
+                "Never rank a generated batch with the reasoning that wrote it. The rubric catches defects; it does not pick winners."
+            ],
+            artifact,
+            next: nextCommand("hooks"),
+            referenceHint
+        };
+    }
+    const videoRef = input.videoRef?.trim();
+    return {
+        ...shared,
+        step: "placement",
+        title: "Product placement — native moments inside an existing video",
+        prompt: buildProductPlacementPrompt(offer, count),
+        steps: [
+            ...common,
+            videoRef
+                ? `The prompt says "the attached video" — that is \`${videoRef}\`. Watch it yourself before answering: read real frames (\`vidfarm stills ${videoRef} --sheet\` for a contact sheet) and the transcript. This step is worthless if you answer from the filename.`
+                : "The prompt says \"the attached video\" — you were given none. Ask the director for the video path or URL, then re-run with --video <path|url>. Do not answer from imagination.",
+            "Every opportunity must cite a moment you actually saw, with a timestamp. Drop any you cannot point at."
+        ],
+        artifact,
+        next: null,
+        referenceHint
+    };
+}
+/** Render a brief for a terminal. The prompt is delimited so an agent can lift
+ *  it exactly, and so a human can copy it into a chat window instead. */
+export function formatConsultBrief(brief, style = { bold: "", dim: "", reset: "" }) {
+    const { bold, dim, reset } = style;
+    const lines = [];
+    lines.push(`${bold}${brief.title}${reset}`);
+    lines.push(`${dim}Keyless + local: no provider key, no wallet, no network. You answer this.${reset}`);
+    lines.push("");
+    brief.steps.forEach((s, i) => lines.push(`${i + 1}. ${s}`));
+    lines.push("");
+    lines.push(brief.short
+        ? `${dim}─── the short-form question set (fixed and local — ask these as written) ───${reset}`
+        : `${dim}─── the prompt (identical to the cloud brainstorm primitive) ───${reset}`);
+    lines.push(brief.prompt);
+    lines.push(`${dim}───────────────────────────────────────────────────────────────${reset}`);
+    lines.push("");
+    lines.push(`Save to: ${brief.artifact}`);
+    lines.push(`Context: ${brief.contextFile}${brief.contextExists ? " (exists — read it first)" : " (create it)"}`);
+    if (brief.next) {
+        lines.push(`Next:    ${brief.next}`);
+    }
+    return lines.join("\n");
+}
+/** The whole chain plus which artifacts already exist, for a bare
+ *  `vidfarm consult`. A director who says "give me a consultation" gets the map
+ *  and the first command, not a wall of prompt. */
+export function planConsultation(dir) {
+    const root = path.resolve(dir);
+    return STEP_ORDER.map((step) => {
+        const file = CONSULT_ARTIFACTS[step];
+        const offerDone = step === "coldstart" && !("error" in findOfferFile(root));
+        return {
+            step,
+            artifact: file,
+            done: step === "coldstart" ? offerDone : existsSync(path.join(root, file)),
+            command: `vidfarm consult ${step}`
+        };
+    });
+}
+//# sourceMappingURL=consult.js.map