@officexapp/vidfarm-devcli 0.21.55 → 0.21.56

package/dist/src/devcli/clipper-run.js

@@ -0,0 +1,941 @@
+// `vidfarm clipper-run` — the RUN MODE of an agentic clipper loop, and the
+// per-task state that survives a context reset.
+//
+// A clipper task is a long-horizon job: read the brief, shortlist templates,
+// pick one, plan it, procure raws, build, render, QA, get the cut reviewed, then
+// submit. That is far more than a weak model (Antigravity, Gemini Flash, GLM,
+// DeepSeek) holds in one context, and the failure is always the same shape: it
+// forgets which stage it was at, re-does a step, or — worst — submits a cut the
+// gigworker never watched. So the stage lives in a file, not in the context.
+//
+// FOUR RUN MODES, one axis: how much of the gigworker's attention each task
+// costs. They differ ONLY in which stages stop for a human.
+//
+//   full-interactive   shortlist · plan · raws · cut   — max quality on a weak
+//                      model. The human picks the template, reads the plan, can
+//                      help collect raws, and watches the cut.
+//   quick-interactive  shortlist · cut                 — the human approves ONE
+//                      template_id off a shortlist, the agent then runs the task
+//                      alone, and the human watches the cut before it is sent.
+//   auto-batch         cut                             — the agent picks the
+//                      template and builds every task unattended; nothing is
+//                      submitted until the human reviews the batch.
+//   auto-submit        (nothing)                       — fully unattended,
+//                      submits its own proofs. Opt-in, in the gigworker's own
+//                      words, and reverted after any rejection.
+//
+// `quick-interactive` and `auto-batch` are the two common ones.
+//
+// STATE ON DISK, under the mission folder (default ./CLIPPER):
+//   run.json                     the chosen run mode
+//   tasks/<task-id>/state.json   one task's stage, gate, shortlist, artifacts
+//   tasks/<task-id>/raws/        where this task's footage is collected
+//   REVIEW_QUEUE.md              regenerated from every open gate — the human's list
+//   LEDGER.jsonl                 appended on submit / drop
+//
+// Backend-free (Node built-ins only) so it ships in the public cloud-only CLI.
+import { parseArgs } from "node:util";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+export const RUN_MODES = ["full-interactive", "quick-interactive", "auto-batch", "auto-submit"];
+/** Nobody has chosen yet. Safe, and one of the two common modes. */
+export const DEFAULT_RUN_MODE = "quick-interactive";
+/** The pipeline, in order. `done`/`discarded` are terminal. */
+export const STAGES = ["claimed", "shortlist", "plan", "raws", "build", "cut", "submit", "done"];
+/**
+ * The whole difference between the four modes: which stages STOP for a human.
+ * Everything else in this file is the same code on every mode.
+ */
+export const MODE_GATES = {
+    "full-interactive": ["shortlist", "plan", "raws", "cut"],
+    "quick-interactive": ["shortlist", "cut"],
+    "auto-batch": ["cut"],
+    "auto-submit": []
+};
+export const MODE_BLURB = {
+    "full-interactive": "Full interactive — four stops. The agent shortlists template_ids and the gigworker picks one; the agent " +
+        "writes the plan and the gigworker reviews it; the agent opens a local raws folder the gigworker may drop " +
+        "footage into; the agent builds and renders and the gigworker watches the cut before it is submitted. " +
+        "This is how a WEAK model produces work a buyer keeps: the human supplies the taste at four cheap moments.",
+    "quick-interactive": "Quick interactive — one stop before the work, one after. The agent suggests a few template_ids, the " +
+        "gigworker approves ONE, and the agent then plans and builds the whole task alone from that starting " +
+        "point. The gigworker watches the finished cut before it is submitted. One of the two most-used modes.",
+    "auto-batch": "Full auto with batch review — the agent picks the template and completes every task unattended, and " +
+        "submits NOTHING. Finished cuts pile up in REVIEW_QUEUE.md; the gigworker watches the batch in one " +
+        "sitting and approves or drops each one. The other most-used mode.",
+    "auto-submit": "Full auto with auto-submit — no human anywhere. The agent picks, builds and submits its own proofs. " +
+        "Only ever set by the gigworker, in their own words, and reverted to auto-batch after any rejection: a " +
+        "low_quality rejection is scored on the wallet and buyers read it as a trust score on the public profile."
+};
+/** What the human is asked at each gate, when the caller gives no `--ask`. */
+const DEFAULT_ASK = {
+    shortlist: "Which of these templates should I adapt? Reply with one template_id (or say 'you pick').",
+    plan: "Does this plan match what the buyer asked for? Approve it, or tell me what to change.",
+    raws: "Want to help collect footage? Drop clips into the folder above, then approve. Say 'go' to let me source it all myself.",
+    cut: "Watch the cut: does it satisfy the brief, is the hook alive in the first 3 seconds, are the captions readable and inside the safe zone, is the audio clean, is the buyer's brand right?"
+};
+export function normalizeRunMode(raw) {
+    const v = (raw ?? "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+    if (!v)
+        return null;
+    if (["full-interactive", "full", "interactive", "full-hands-on", "hands-on", "review-every-step", "guided"].includes(v)) {
+        return "full-interactive";
+    }
+    if (["quick-interactive", "quick", "quick-review", "approve-template", "pick-template", "light"].includes(v)) {
+        return "quick-interactive";
+    }
+    if (["auto-batch", "batch", "batch-review", "full-auto-batch", "auto-with-batch-review", "full-auto-with-batch-review", "autonomous"].includes(v)) {
+        return "auto-batch";
+    }
+    if (["auto-submit", "autosubmit", "auto", "full-auto", "unattended", "headless", "full-autonomous"].includes(v)) {
+        return "auto-submit";
+    }
+    return null;
+}
+// ── the mission folder ───────────────────────────────────────────────────────
+function missionRoot(values) {
+    const explicit = values.dir?.trim();
+    if (explicit)
+        return path.resolve(explicit);
+    if (process.env.VIDFARM_CLIPPER_DIR)
+        return path.resolve(process.env.VIDFARM_CLIPPER_DIR);
+    return path.resolve("CLIPPER");
+}
+function readRunMode(root) {
+    // A per-run flag beats the file: `--mode auto-batch` on one command must not
+    // silently rewrite the mission's own choice.
+    try {
+        const parsed = JSON.parse(readFileSync(path.join(root, "run.json"), "utf8"));
+        const mode = normalizeRunMode(parsed?.mode);
+        if (mode)
+            return { mode, isSet: true, note: parsed.note ?? null };
+    }
+    catch {
+        /* not set yet */
+    }
+    return { mode: DEFAULT_RUN_MODE, isSet: false };
+}
+function resolveMode(root, values) {
+    const flag = normalizeRunMode(values.mode);
+    if (flag)
+        return { mode: flag, isSet: true };
+    const env = normalizeRunMode(process.env.VIDFARM_CLIPPER_RUN_MODE);
+    if (env)
+        return { mode: env, isSet: true };
+    return readRunMode(root);
+}
+function tasksDir(root) {
+    return path.join(root, "tasks");
+}
+function taskDir(root, taskId) {
+    // Task ids come off the wire; keep them from escaping the mission folder.
+    const safe = taskId.replace(/[^A-Za-z0-9._-]/g, "_");
+    if (!safe || safe === "." || safe === "..")
+        throw new Error(`"${taskId}" is not a usable task id.`);
+    return path.join(tasksDir(root), safe);
+}
+function statePath(root, taskId) {
+    return path.join(taskDir(root, taskId), "state.json");
+}
+function readState(root, taskId) {
+    const file = statePath(root, taskId);
+    if (!existsSync(file)) {
+        throw new Error(`No state for ${taskId}. Start it first: vidfarm clipper-run start ${taskId} --gig <gig-id>`);
+    }
+    return JSON.parse(readFileSync(file, "utf8"));
+}
+function listStates(root) {
+    const dir = tasksDir(root);
+    if (!existsSync(dir))
+        return [];
+    const rows = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const file = path.join(dir, entry.name, "state.json");
+        if (!existsSync(file))
+            continue;
+        try {
+            rows.push(JSON.parse(readFileSync(file, "utf8")));
+        }
+        catch {
+            /* a half-written state file is not worth crashing the whole loop over */
+        }
+    }
+    return rows.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+function writeState(root, state) {
+    state.updated_at = new Date().toISOString();
+    const dir = taskDir(root, state.task_id);
+    mkdirSync(dir, { recursive: true });
+    const file = statePath(root, state.task_id);
+    writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    // The human's list is a VIEW of the states, so regenerate it every time. A
+    // hand-maintained review queue goes stale the first time an agent forgets.
+    writeReviewQueue(root);
+    return file;
+}
+function note(state, event, text) {
+    state.history.push({ ts: new Date().toISOString(), event, ...(text ? { note: text } : {}) });
+}
+/** Does this stage stop for a human under this mode? */
+export function isGated(mode, stage) {
+    return MODE_GATES[mode].includes(stage);
+}
+/** The stage after `stage`, or `done` at the end. */
+export function nextStage(stage) {
+    const index = STAGES.indexOf(stage);
+    if (index < 0 || index >= STAGES.length - 1)
+        return "done";
+    return STAGES[index + 1];
+}
+/**
+ * Finish a stage: open a gate if this mode stops here, otherwise move straight
+ * on. Every verb below funnels through this, which is why the four modes need no
+ * separate code paths.
+ */
+function completeStage(state, stage, ask) {
+    state.stage = stage;
+    if (isGated(state.mode, stage)) {
+        state.gate = { stage, ask: (ask ?? "").trim() || DEFAULT_ASK[stage] || "Review this and approve it.", since: new Date().toISOString() };
+        note(state, `gate_opened:${stage}`);
+        return { gated: true };
+    }
+    state.gate = null;
+    state.stage = nextStage(stage);
+    note(state, `auto_advance:${stage}`);
+    return { gated: false };
+}
+// ── the human's list ─────────────────────────────────────────────────────────
+function writeReviewQueue(root) {
+    const rows = listStates(root).filter((s) => s.gate);
+    const lines = [
+        "# Review queue",
+        "",
+        "Regenerated by `vidfarm clipper-run`. One row per task that is WAITING FOR YOU.",
+        "Approve: `vidfarm clipper-run approve <task-id>` · changes: `… changes <task-id> --note \"…\"` · drop: `… drop <task-id> --reason \"…\"`",
+        ""
+    ];
+    if (!rows.length) {
+        lines.push("_Nothing waiting for you right now._");
+    }
+    for (const state of rows) {
+        lines.push(`## ${state.task_id} — waiting at \`${state.gate.stage}\``);
+        lines.push("");
+        lines.push(`- buyer machine: ${state.gig_id ?? "?"}${state.machine ? ` (${state.machine})` : ""}`);
+        lines.push(`- price: ${state.price === null ? "TBD" : `$${state.price.toFixed(2)}`} · mode: ${state.mode} · waiting since ${state.gate.since}`);
+        if (state.title)
+            lines.push(`- brief: ${state.title}`);
+        if (state.harness)
+            lines.push(`- harness: ${state.harness}`);
+        if (state.gate.stage === "shortlist" && state.shortlist.length) {
+            lines.push("- templates to choose from:");
+            for (const row of state.shortlist) {
+                lines.push(`    - \`${row.template_id}\`${row.why ? ` — ${row.why}` : ""}`);
+            }
+            lines.push(`    - pick one: \`vidfarm clipper-run pick ${state.task_id} <template_id>\``);
+        }
+        if (state.gate.stage === "plan" && state.plan_path)
+            lines.push(`- plan: ${state.plan_path}`);
+        if (state.gate.stage === "raws" && state.raws_dir)
+            lines.push(`- drop footage here: ${state.raws_dir}`);
+        if (state.gate.stage === "cut" && state.cut_path)
+            lines.push(`- watch the cut: ${state.cut_path}`);
+        lines.push("");
+        lines.push(`**${state.gate.ask}**`);
+        lines.push("");
+    }
+    mkdirSync(root, { recursive: true });
+    writeFileSync(path.join(root, "REVIEW_QUEUE.md"), `${lines.join("\n")}\n`, "utf8");
+}
+function appendLedger(root, row) {
+    mkdirSync(root, { recursive: true });
+    appendFileSync(path.join(root, "LEDGER.jsonl"), `${JSON.stringify(row)}\n`, "utf8");
+}
+// ── what to do next ──────────────────────────────────────────────────────────
+/** The one command an agent should run next for a task, given its stage. */
+export function nextAction(state) {
+    if (state.gate) {
+        return { who: "gigworker", what: `${state.gate.ask}   → vidfarm clipper-run approve ${state.task_id}` };
+    }
+    switch (state.stage) {
+        case "claimed":
+            return {
+                who: "agent",
+                what: `Shortlist templates to adapt: vidfarm discover --query "<the buyer's problem, in their words>" --limit 20 --json` +
+                    `\n     then: vidfarm clipper-run shortlist ${state.task_id} --template <id> --why "<why it fits>"  (repeat per candidate)`
+            };
+        case "shortlist":
+            return { who: "agent", what: `Choose the template to adapt: vidfarm clipper-run pick ${state.task_id} <template_id>` };
+        case "plan":
+            return {
+                who: "agent",
+                what: `Fork it and write the plan, then record it:` +
+                    `\n     vidfarm fork ${state.template_id ?? "<template_id>"} · vidfarm pull <forkId> --dir ./work · vidfarm harness derive <forkId> --out ./work/HARNESS.md` +
+                    `\n     vidfarm clipper-run plan ${state.task_id} --file ./work/STORYBOARD.md`
+            };
+        case "raws":
+            return {
+                who: "agent",
+                what: `Procure every raw for every beat in ONE pass (buyer's shared folder → their site → public raws → free stock → your own subscription → billed last), then:` +
+                    `\n     vidfarm clipper-run raws ${state.task_id}`
+            };
+        case "build":
+            return {
+                who: "agent",
+                what: `Build, lint, render locally, QA, then record the two exports:` +
+                    `\n     vidfarm lint · vidfarm render · vidfarm qa ./work${state.harness ? ` --harness ${state.harness}` : ""}` +
+                    `\n     vidfarm clipper-run cut ${state.task_id} --file ./final-watermarked.mp4 --clean-master ./final-clean.mp4`
+            };
+        case "cut":
+            return { who: "agent", what: `Cut is recorded and no gate is open — go to submit.` };
+        case "submit":
+            return {
+                who: "agent",
+                what: `Submit it, then close the row:` +
+                    `\n     vidfarm gigs submit ${state.gig_id ?? "<gig-id>"} --task ${state.task_id} --proof <public watermarked url>${state.clean_master ? ` --clean-master ${state.clean_master}` : ""}` +
+                    `\n     vidfarm clipper-run submitted ${state.task_id} --proof <proof-id>`
+            };
+        default:
+            return { who: "agent", what: "Nothing left on this task." };
+    }
+}
+// ── output helpers ───────────────────────────────────────────────────────────
+function out(json, value, human) {
+    if (json) {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    human();
+}
+function stageLine(state) {
+    const gate = state.gate ? `${YELLOW}WAITING ON THE GIGWORKER${RESET} at ${BOLD}${state.gate.stage}${RESET}` : `stage ${BOLD}${state.stage}${RESET}`;
+    const price = state.price === null ? "price TBD" : `$${state.price.toFixed(2)}`;
+    return `  ${BOLD}${state.task_id}${RESET}  ${gate}  ${DIM}${state.mode} · ${price}${state.gig_id ? " · " + state.gig_id : ""}${RESET}`;
+}
+// ── commands ─────────────────────────────────────────────────────────────────
+const MISSION_TEMPLATE = (mode) => `# Clipper mission
+
+payout_wallet: 0xYOUR_BASE_L2_ADDRESS      # Base L2, receives USDC
+cash_out: GCash via https://officex.short.gy/solana-usdc-gcash
+cost_mode: minimize                        # profit = price - spend
+run_mode: ${mode}                          # full-interactive | quick-interactive | auto-batch | auto-submit
+auto_submit: ${mode === "auto-submit"}     # only the gigworker may set this true, in words, on purpose
+specialities:                              # sticker explainers, meme recaptions, greenscreen reaction
+max_tasks_in_flight: 1                     # raise only after the gigworker has watched a finished one
+hardware_tier:                             # weak | capable — measured once, agentic-clipper.md § 3½
+agent_cli:                                 # antigravity | codex | claude-code | …
+cycle_every: 30 minutes
+stop_if: 2 rejections in a row · any gig warning about funds · 3 failed renders · human says stop
+`;
+function cmdInit(root, values) {
+    const mode = resolveMode(root, values).mode;
+    mkdirSync(tasksDir(root), { recursive: true });
+    const created = [];
+    const seed = (name, contents) => {
+        const file = path.join(root, name);
+        // Never clobber a mission the gigworker has already written into.
+        if (existsSync(file))
+            return;
+        writeFileSync(file, contents, "utf8");
+        created.push(file);
+    };
+    seed("MISSION.md", MISSION_TEMPLATE(mode));
+    seed("MACHINES.md", "# Machines\n\n| gig_id | buyer | machine type | available_funds | task price | last paid me | verdict |\n|---|---|---|---|---|---|---|\n");
+    seed("NOTES.md", "# Notes\n\nWhat each buyer approved, what they rejected and with which tag, prices that moved.\n");
+    seed("EARNINGS.md", "# Earnings\n\nsubmitted / approved / PAID / owed, with dates. `approved` is not `paid`.\n");
+    seed("LEDGER.jsonl", "");
+    writeReviewQueue(root);
+    out(Boolean(values.json), { ok: true, root, mode, created }, () => {
+        console.log(`${GREEN}✓${RESET} Mission folder ready at ${BOLD}${root}${RESET}`);
+        for (const file of created)
+            console.log(`  ${DIM}${file}${RESET}`);
+        console.log("");
+        console.log(`${DIM}Run mode: ${BOLD}${mode}${RESET}${DIM} — change it with: vidfarm clipper-run mode <${RUN_MODES.join("|")}>${RESET}`);
+    });
+}
+function cmdMode(root, values, positionals) {
+    const requested = positionals[0];
+    const json = Boolean(values.json);
+    if (requested) {
+        const mode = normalizeRunMode(requested);
+        if (!mode)
+            throw new Error(`Unknown run mode "${requested}". Choose one of: ${RUN_MODES.join(", ")}.`);
+        const savedAt = new Date().toISOString();
+        mkdirSync(root, { recursive: true });
+        const payload = { mode, note: values.note ?? null, savedAt };
+        const file = path.join(root, "run.json");
+        writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+        // MISSION.md is the file a human reads, so keep its two mode lines honest —
+        // but only rewrite lines that already exist. This never invents a mission.
+        const missionFile = path.join(root, "MISSION.md");
+        if (existsSync(missionFile)) {
+            const before = readFileSync(missionFile, "utf8");
+            const after = before
+                .replace(/^run_mode:.*$/m, `run_mode: ${mode}`)
+                .replace(/^auto_submit:.*$/m, `auto_submit: ${mode === "auto-submit"}`);
+            if (after !== before)
+                writeFileSync(missionFile, after, "utf8");
+        }
+        out(json, { ok: true, run_mode: mode, saved_at: savedAt, file, gates: MODE_GATES[mode] }, () => {
+            console.log(`${GREEN}${BOLD}Run mode: ${mode}${RESET}`);
+            console.log(`${DIM}${MODE_BLURB[mode]}${RESET}`);
+            const gates = MODE_GATES[mode];
+            console.log(`${DIM}Stops for the gigworker: ${gates.length ? gates.join(" · ") : "NONE — this loop submits unattended"}${RESET}`);
+            if (mode === "auto-submit") {
+                console.log(`${YELLOW}Only the gigworker may choose this${RESET}${DIM} — a rejection is scored on the wallet and shown to buyers as a trust score. Revert to auto-batch after any rejection.${RESET}`);
+            }
+            console.log(`${DIM}Saved to ${file}.${RESET}`);
+        });
+        return;
+    }
+    const resolved = resolveMode(root, values);
+    out(json, { ok: true, run_mode: resolved.mode, is_set: resolved.isSet, gates: MODE_GATES[resolved.mode], modes: RUN_MODES }, () => {
+        console.log(`${BOLD}run mode: ${resolved.mode}${RESET} ${DIM}(${resolved.isSet ? "set" : "NOT set — assuming " + DEFAULT_RUN_MODE}, mission ${root})${RESET}`);
+        console.log("");
+        for (const mode of RUN_MODES) {
+            console.log(`  ${BOLD}${mode}${RESET} ${DIM}— stops at: ${MODE_GATES[mode].join(" · ") || "nothing"}${RESET}`);
+            console.log(`    ${DIM}${MODE_BLURB[mode]}${RESET}`);
+        }
+        console.log("");
+        console.log(`${DIM}Set it: ${BOLD}vidfarm clipper-run mode <${RUN_MODES.join("|")}>${RESET}`);
+        if (!resolved.isSet) {
+            console.log(`${DIM}Nothing saved yet — ASK the gigworker which one they want before the first task.${RESET}`);
+        }
+    });
+}
+function numberOrNull(value) {
+    const parsed = typeof value === "string" ? Number(value) : typeof value === "number" ? value : NaN;
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function cmdStart(root, values, positionals) {
+    const taskId = positionals[0];
+    if (!taskId)
+        throw new Error("clipper-run start needs the task id: vidfarm clipper-run start TASK_01H… --gig GIG_01H…");
+    const mode = resolveMode(root, values).mode;
+    const now = new Date().toISOString();
+    const dir = taskDir(root, taskId);
+    mkdirSync(path.join(dir, "raws"), { recursive: true });
+    const state = {
+        task_id: taskId,
+        gig_id: values.gig ?? null,
+        machine: values.machine ?? null,
+        price: numberOrNull(values.price),
+        title: values.title ?? null,
+        harness: values.harness ?? null,
+        mode,
+        stage: "claimed",
+        gate: null,
+        shortlist: [],
+        template_id: null,
+        template_picked_by: null,
+        plan_path: null,
+        raws_dir: path.join(dir, "raws"),
+        cut_path: null,
+        clean_master: null,
+        proof_id: null,
+        reviewed_by_gigworker: null,
+        history: [{ ts: now, event: "started" }],
+        created_at: now,
+        updated_at: now
+    };
+    // The brief is what the subagent actually reads — write the raw payload down
+    // rather than paraphrasing it into a chat message that dies with the context.
+    const briefFile = values.brief ? String(values.brief) : null;
+    if (briefFile) {
+        writeFileSync(path.join(dir, "brief.md"), readFileSync(briefFile, "utf8"), "utf8");
+    }
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} Task ${BOLD}${taskId}${RESET} opened in ${BOLD}${mode}${RESET} ${DIM}(${dir})${RESET}`);
+        const next = nextAction(state);
+        console.log(`  ${DIM}next (${next.who}):${RESET} ${next.what}`);
+    });
+}
+function cmdShortlist(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "shortlist"));
+    const templates = [].concat(values.template ?? []);
+    const whys = [].concat(values.why ?? []);
+    if (!templates.length) {
+        throw new Error('clipper-run shortlist needs at least one --template <id> (repeat it, with a matching --why "<reason>").');
+    }
+    for (const [index, template] of templates.entries()) {
+        state.shortlist.push({ template_id: template, why: whys[index] ?? "" });
+    }
+    note(state, "shortlisted", templates.join(", "));
+    // Shortlist is the one stage that never auto-advances: SOMEBODY still has to
+    // choose, and in the two auto modes that somebody is the agent itself. So the
+    // task waits at `shortlist` for a `pick` either way — only the gate differs.
+    state.stage = "shortlist";
+    const gated = isGated(state.mode, "shortlist");
+    state.gate = gated
+        ? { stage: "shortlist", ask: (values.ask ?? "").trim() || DEFAULT_ASK.shortlist, since: new Date().toISOString() }
+        : null;
+    if (gated)
+        note(state, "gate_opened:shortlist");
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, gated, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} ${state.shortlist.length} template(s) shortlisted for ${BOLD}${state.task_id}${RESET}`);
+        for (const row of state.shortlist)
+            console.log(`  ${BOLD}${row.template_id}${RESET}${row.why ? ` ${DIM}— ${row.why}${RESET}` : ""}`);
+        console.log("");
+        if (gated) {
+            console.log(`${YELLOW}STOP — show these to the gigworker and wait.${RESET} ${DIM}${state.gate.ask}${RESET}`);
+            console.log(`${DIM}They answer with: vidfarm clipper-run pick ${state.task_id} <template_id>${RESET}`);
+            console.log(`${DIM}Show them the videos first: https://vidfarm.cc/template/<template_id>${RESET}`);
+        }
+        else {
+            console.log(`${DIM}This mode does not stop here — pick one yourself: vidfarm clipper-run pick ${state.task_id} <template_id>${RESET}`);
+        }
+    });
+}
+function cmdPick(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "pick"));
+    const flagged = [].concat(values.template ?? [])[0];
+    // With no id at all, take the top of the shortlist. That is the auto-mode
+    // shape — the agent shortlisted best-first, so "pick" means "take your own
+    // first choice" — and it saves a weak model from re-typing an id it just wrote.
+    const templateId = positionals[1] ?? flagged ?? state.shortlist[0]?.template_id;
+    if (!templateId) {
+        throw new Error("clipper-run pick needs a template id (or a shortlist to take the top of): vidfarm clipper-run pick <task-id> template_019…");
+    }
+    // A pick IS the answer to the shortlist gate, so it closes it. That saves the
+    // gigworker from having to both pick and approve.
+    const wasGated = state.gate?.stage === "shortlist";
+    state.template_id = String(templateId);
+    state.template_picked_by = (normalizeWho(values.by) ?? (wasGated ? "human" : "agent"));
+    note(state, "template_picked", `${state.template_id} by ${state.template_picked_by}`);
+    state.gate = null;
+    state.stage = "plan";
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} ${BOLD}${state.task_id}${RESET} will adapt ${BOLD}${state.template_id}${RESET} ${DIM}(chosen by the ${state.template_picked_by})${RESET}`);
+        const next = nextAction(state);
+        console.log(`  ${DIM}next (${next.who}):${RESET} ${next.what}`);
+    });
+}
+function normalizeWho(raw) {
+    const v = String(raw ?? "").trim().toLowerCase();
+    if (["human", "gigworker", "me", "user"].includes(v))
+        return "human";
+    if (["agent", "ai", "auto"].includes(v))
+        return "agent";
+    return null;
+}
+function cmdPlan(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "plan"));
+    if (values.file)
+        state.plan_path = path.resolve(String(values.file));
+    if (!state.plan_path) {
+        throw new Error('clipper-run plan needs --file <path to the written plan> (STORYBOARD.md, brief.md — whatever you wrote).');
+    }
+    note(state, "planned", state.plan_path);
+    const { gated } = completeStage(state, "plan", values.ask);
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, gated, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} Plan recorded for ${BOLD}${state.task_id}${RESET}: ${state.plan_path}`);
+        if (gated) {
+            console.log(`${YELLOW}STOP — hand the plan to the gigworker and wait.${RESET} ${DIM}${state.gate.ask}${RESET}`);
+            console.log(`${DIM}They answer: vidfarm clipper-run approve ${state.task_id}   ·   vidfarm clipper-run changes ${state.task_id} --note "…"${RESET}`);
+        }
+        else {
+            const next = nextAction(state);
+            console.log(`  ${DIM}next (${next.who}):${RESET} ${next.what}`);
+        }
+    });
+}
+function cmdRaws(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "raws"));
+    const dir = state.raws_dir ?? path.join(taskDir(root, state.task_id), "raws");
+    mkdirSync(dir, { recursive: true });
+    state.raws_dir = dir;
+    const have = readdirSync(dir).filter((f) => !f.startsWith("."));
+    note(state, "raws_folder", `${have.length} file(s)`);
+    const { gated } = completeStage(state, "raws", values.ask);
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, gated, raws_dir: dir, files: have, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} Raws folder for ${BOLD}${state.task_id}${RESET}:`);
+        console.log(`  ${BOLD}${dir}${RESET}  ${DIM}${have.length} file(s)${RESET}`);
+        if (gated) {
+            console.log("");
+            console.log(`${YELLOW}STOP — offer the folder to the gigworker.${RESET} ${DIM}${state.gate.ask}${RESET}`);
+            console.log(`${DIM}A human eye picks better clips than any keyword scan, and it costs $0. But it is OPTIONAL —${RESET}`);
+            console.log(`${DIM}if they say "go", approve it yourself on their word: vidfarm clipper-run approve ${state.task_id} --note "gigworker said go"${RESET}`);
+        }
+        else {
+            const next = nextAction(state);
+            console.log(`  ${DIM}next (${next.who}):${RESET} ${next.what}`);
+        }
+    });
+}
+function cmdCut(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "cut"));
+    if (values.file)
+        state.cut_path = path.resolve(String(values.file));
+    if (values["clean-master"])
+        state.clean_master = path.resolve(String(values["clean-master"]));
+    if (!state.cut_path)
+        throw new Error("clipper-run cut needs --file <path to the WATERMARKED cut>.");
+    note(state, "cut_ready", state.cut_path);
+    const { gated } = completeStage(state, "cut", values.ask);
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, gated, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} Cut recorded for ${BOLD}${state.task_id}${RESET}: ${state.cut_path}`);
+        if (!state.clean_master) {
+            console.log(`  ${YELLOW}No --clean-master given${RESET}${DIM} — the watermarked cut is what the buyer sees; the clean master goes in the proof's private note.${RESET}`);
+        }
+        if (gated) {
+            console.log("");
+            console.log(`${YELLOW}STOP — the gigworker watches this before it is submitted.${RESET}`);
+            console.log(`${DIM}${state.gate.ask}${RESET}`);
+            console.log(`${DIM}Play it: vidfarm serve   ·   fast look: vidfarm stills ${state.cut_path}${RESET}`);
+            console.log(`${DIM}They answer: vidfarm clipper-run approve ${state.task_id} · changes … --note "…" · drop … --reason "…"${RESET}`);
+        }
+        else {
+            console.log(`  ${YELLOW}auto-submit${RESET}${DIM} — no human watches this one. A rejection lands on the public trust score.${RESET}`);
+            const next = nextAction(state);
+            console.log(`  ${DIM}next (${next.who}):${RESET} ${next.what}`);
+        }
+    });
+}
+function cmdApprove(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "approve"));
+    if (!state.gate)
+        throw new Error(`${state.task_id} is not waiting for anybody — it is at stage "${state.stage}". Run: vidfarm clipper-run status ${state.task_id}`);
+    const stage = state.gate.stage;
+    const at = new Date().toISOString();
+    note(state, `approved:${stage}`, values.note ?? null);
+    // Only the CUT gate is the "a human watched the video" record — that is the
+    // one the ledger and the buyer's trust score care about.
+    if (stage === "cut")
+        state.reviewed_by_gigworker = at;
+    state.gate = null;
+    state.stage = nextStage(stage);
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, approved: stage, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} ${BOLD}${state.task_id}${RESET} approved at ${BOLD}${stage}${RESET} → stage ${BOLD}${state.stage}${RESET}`);
+        const next = nextAction(state);
+        console.log(`  ${DIM}next (${next.who}):${RESET} ${next.what}`);
+    });
+}
+function cmdChanges(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "changes"));
+    const text = values.note?.trim();
+    if (!text)
+        throw new Error('clipper-run changes needs --note "<what to fix>" — that note is the whole point.');
+    const stage = state.gate?.stage ?? state.stage;
+    note(state, `changes_requested:${stage}`, text);
+    state.gate = null;
+    // Send it back to the stage that produced the thing being rejected, so the
+    // agent redoes THAT step rather than starting the task over. "not these
+    // templates" means shortlist again, which is the stage BEFORE the list.
+    state.stage = stage === "cut" ? "build" : stage === "shortlist" ? "claimed" : stage;
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, state, next: nextAction(state) }, () => {
+        console.log(`${GREEN}✓${RESET} Changes recorded on ${BOLD}${state.task_id}${RESET} at ${BOLD}${stage}${RESET} → back to ${BOLD}${state.stage}${RESET}`);
+        console.log(`  ${DIM}${text}${RESET}`);
+        console.log(`  ${DIM}Redo that step with a FRESH subagent and the note above, then return to the same gate.${RESET}`);
+    });
+}
+function cmdDrop(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "drop"));
+    const reason = values.reason?.trim() || "no reason given";
+    note(state, "discarded", reason);
+    state.gate = null;
+    state.stage = "discarded";
+    writeState(root, state);
+    appendLedger(root, {
+        ts: new Date().toISOString(),
+        gig_id: state.gig_id,
+        task_id: state.task_id,
+        template_id: state.template_id,
+        run_mode: state.mode,
+        status: "discarded",
+        reason
+    });
+    out(Boolean(values.json), { ok: true, state }, () => {
+        console.log(`${GREEN}✓${RESET} Dropped ${BOLD}${state.task_id}${RESET} — ${reason}`);
+        console.log(`  ${DIM}Logged to LEDGER.jsonl. On Custom Requests, release it or let it expire — never submit a cut the gigworker rejected.${RESET}`);
+    });
+}
+function cmdSubmitted(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "submitted"));
+    state.proof_id = values.proof ?? null;
+    note(state, "submitted", state.proof_id);
+    state.gate = null;
+    state.stage = "done";
+    writeState(root, state);
+    appendLedger(root, {
+        ts: new Date().toISOString(),
+        gig_id: state.gig_id,
+        task_id: state.task_id,
+        proof_id: state.proof_id,
+        template_id: state.template_id,
+        harness: state.harness,
+        run_mode: state.mode,
+        locked_price: state.price,
+        status: "submitted",
+        reviewed_by_gigworker: state.reviewed_by_gigworker ?? (state.mode === "auto-submit" ? "auto_submit" : null),
+        paid_out_at: null
+    });
+    out(Boolean(values.json), { ok: true, state }, () => {
+        console.log(`${GREEN}✓${RESET} ${BOLD}${state.task_id}${RESET} closed as submitted${state.proof_id ? ` ${DIM}(${state.proof_id})${RESET}` : ""}`);
+        console.log(`  ${DIM}Ledger row appended. approved is not paid — reconcile with: vidfarm gigs proof ${state.gig_id ?? "<gig>"} ${state.proof_id ?? "<proof-id>"}${RESET}`);
+    });
+}
+function cmdStatus(root, values, positionals) {
+    const json = Boolean(values.json);
+    if (positionals[0]) {
+        const state = readState(root, positionals[0]);
+        out(json, { ok: true, state, next: nextAction(state) }, () => {
+            console.log(stageLine(state));
+            if (state.template_id)
+                console.log(`      ${DIM}template ${state.template_id} (${state.template_picked_by})${RESET}`);
+            if (state.plan_path)
+                console.log(`      ${DIM}plan ${state.plan_path}${RESET}`);
+            if (state.cut_path)
+                console.log(`      ${DIM}cut  ${state.cut_path}${RESET}`);
+            const next = nextAction(state);
+            console.log(`      ${DIM}next (${next.who}):${RESET} ${next.what}`);
+        });
+        return;
+    }
+    const rows = listStates(root);
+    const open = rows.filter((s) => s.stage !== "done" && s.stage !== "discarded");
+    out(json, { ok: true, root, run_mode: resolveMode(root, values).mode, tasks: rows }, () => {
+        const mode = resolveMode(root, values);
+        console.log(`${BOLD}run mode: ${mode.mode}${RESET} ${DIM}(${mode.isSet ? "set" : "not set"}) · ${root}${RESET}`);
+        if (!rows.length) {
+            console.log(`${DIM}No tasks yet. Claim one, then: vidfarm clipper-run start <task-id> --gig <gig-id>${RESET}`);
+            return;
+        }
+        for (const state of open)
+            console.log(stageLine(state));
+        const closed = rows.length - open.length;
+        if (closed)
+            console.log(`${DIM}  …and ${closed} closed task(s).${RESET}`);
+        const waiting = open.filter((s) => s.gate).length;
+        console.log("");
+        console.log(waiting
+            ? `${YELLOW}${waiting} task(s) waiting on the gigworker${RESET}${DIM} — the list is in ${path.join(root, "REVIEW_QUEUE.md")}${RESET}`
+            : `${DIM}Nothing waiting on the gigworker.${RESET}`);
+    });
+}
+function cmdNext(root, values) {
+    const rows = listStates(root).filter((s) => s.stage !== "done" && s.stage !== "discarded");
+    const waiting = rows.filter((s) => s.gate);
+    const actionable = rows.filter((s) => !s.gate);
+    out(Boolean(values.json), {
+        ok: true,
+        run_mode: resolveMode(root, values).mode,
+        waiting_on_gigworker: waiting.map((s) => ({ task_id: s.task_id, stage: s.gate.stage, ask: s.gate.ask })),
+        next: actionable.map((s) => ({ task_id: s.task_id, stage: s.stage, ...nextAction(s) }))
+    }, () => {
+        if (!rows.length) {
+            console.log(`${DIM}No open tasks. Find work: vidfarm gigs earn  →  vidfarm gigs claim <gig-id>  →  vidfarm clipper-run start <task-id> --gig <gig-id>${RESET}`);
+            return;
+        }
+        if (actionable.length) {
+            console.log(`${BOLD}Do this now${RESET}`);
+            for (const state of actionable) {
+                const next = nextAction(state);
+                console.log(`  ${BOLD}${state.task_id}${RESET} ${DIM}(${state.stage})${RESET}`);
+                console.log(`     ${next.what}`);
+            }
+        }
+        else {
+            console.log(`${DIM}Nothing for you to do — every open task is waiting on the gigworker.${RESET}`);
+        }
+        if (waiting.length) {
+            console.log("");
+            console.log(`${YELLOW}Waiting on the gigworker — do NOT work around these${RESET}`);
+            for (const state of waiting) {
+                console.log(`  ${BOLD}${state.task_id}${RESET} ${DIM}at ${state.gate.stage} since ${state.gate.since}${RESET}`);
+                console.log(`     ${DIM}${state.gate.ask}${RESET}`);
+            }
+        }
+    });
+}
+function cmdReview(root, values) {
+    const rows = listStates(root).filter((s) => s.gate);
+    writeReviewQueue(root);
+    out(Boolean(values.json), { ok: true, waiting: rows }, () => {
+        if (!rows.length) {
+            console.log(`${DIM}Nothing waiting for the gigworker.${RESET}`);
+            return;
+        }
+        console.log(`${BOLD}${rows.length} task(s) waiting for you${RESET} ${DIM}(also written to ${path.join(root, "REVIEW_QUEUE.md")})${RESET}`);
+        for (const state of rows) {
+            console.log("");
+            console.log(`  ${BOLD}${state.task_id}${RESET} ${DIM}${state.gate.stage} · ${state.mode}${state.price === null ? "" : ` · $${state.price.toFixed(2)}`}${RESET}`);
+            if (state.gate.stage === "shortlist") {
+                for (const row of state.shortlist)
+                    console.log(`     ${BOLD}${row.template_id}${RESET}${row.why ? ` ${DIM}— ${row.why}${RESET}` : ""}`);
+            }
+            if (state.gate.stage === "plan" && state.plan_path)
+                console.log(`     plan: ${state.plan_path}`);
+            if (state.gate.stage === "raws" && state.raws_dir)
+                console.log(`     drop footage in: ${state.raws_dir}`);
+            if (state.gate.stage === "cut" && state.cut_path)
+                console.log(`     watch: ${state.cut_path}`);
+            console.log(`     ${DIM}${state.gate.ask}${RESET}`);
+            console.log(`     ${DIM}vidfarm clipper-run approve ${state.task_id}${state.gate.stage === "shortlist" ? ` (or: pick ${state.task_id} <template_id>)` : ""}${RESET}`);
+        }
+    });
+}
+/**
+ * The pre-submit check. Exits non-zero while a human gate is open, so a loop
+ * script can be written as `vidfarm clipper-run gate $TASK && vidfarm gigs
+ * submit …` and be physically unable to send an unreviewed cut.
+ */
+function cmdGate(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "gate"));
+    const blocked = Boolean(state.gate) || (state.stage !== "submit" && state.stage !== "done");
+    out(Boolean(values.json), {
+        ok: !blocked,
+        task_id: state.task_id,
+        stage: state.stage,
+        gate: state.gate,
+        may_submit: !blocked,
+        reviewed_by_gigworker: state.reviewed_by_gigworker
+    }, () => {
+        if (!blocked) {
+            console.log(`${GREEN}✓ CLEARED TO SUBMIT${RESET} ${BOLD}${state.task_id}${RESET}${state.reviewed_by_gigworker ? ` ${DIM}(gigworker approved the cut at ${state.reviewed_by_gigworker})${RESET}` : ` ${DIM}(auto-submit — no human watched this)${RESET}`}`);
+            return;
+        }
+        console.log(`${YELLOW}HOLD${RESET} ${BOLD}${state.task_id}${RESET} ${DIM}is at ${state.stage}${state.gate ? ` and waiting on the gigworker (${state.gate.stage})` : ""}${RESET}`);
+        if (state.gate)
+            console.log(`  ${DIM}${state.gate.ask}${RESET}`);
+    });
+    if (blocked)
+        process.exitCode = 2;
+}
+function cmdNote(root, values, positionals) {
+    const state = readState(root, requireTask(positionals[0], "note"));
+    const text = positionals.slice(1).join(" ").trim() || String(values.note ?? "").trim();
+    if (!text)
+        throw new Error('clipper-run note needs some text: vidfarm clipper-run note <task-id> "buyer wants the logo bigger"');
+    note(state, "note", text);
+    writeState(root, state);
+    out(Boolean(values.json), { ok: true, state }, () => {
+        console.log(`${GREEN}✓${RESET} Noted on ${BOLD}${state.task_id}${RESET}.`);
+    });
+}
+function requireTask(raw, verb) {
+    if (!raw)
+        throw new Error(`clipper-run ${verb} needs a task id: vidfarm clipper-run ${verb} TASK_01H…`);
+    return raw;
+}
+// ── help + dispatch ──────────────────────────────────────────────────────────
+export const CLIPPER_RUN_HELP = `vidfarm clipper-run — how much of the gigworker's attention each task costs, and where the loop is up to
+
+THE FOUR RUN MODES (they differ ONLY in which stages stop for the human)
+  full-interactive    stops at shortlist · plan · raws · cut   best quality on a weak model
+  quick-interactive   stops at shortlist · cut                 the gigworker approves ONE template, then watches the cut
+  auto-batch          stops at cut                             builds everything unattended, submits nothing until reviewed
+  auto-submit         stops nowhere                            fully unattended. Opt-in, in the gigworker's own words.
+
+  clipper-run mode [<mode>]        Show or set the run mode (writes CLIPPER/run.json + MISSION.md)
+  clipper-run init                 Create the mission folder (MISSION.md, MACHINES.md, LEDGER.jsonl, …)
+
+ONE TASK, START TO FINISH
+  clipper-run start <task-id>      --gig <id> --price <usd> --machine <slug> --title "<brief>"
+                                   --harness <url> --brief <file.md>
+  clipper-run shortlist <task-id>  --template <id> --why "<why it fits>"   (repeat per candidate)
+  clipper-run pick <task-id> <template-id>      The choice. Closes the shortlist gate.
+  clipper-run plan <task-id> --file ./work/STORYBOARD.md
+  clipper-run raws <task-id>       Print (and create) this task's local raws folder
+  clipper-run cut <task-id> --file ./final-watermarked.mp4 --clean-master ./final-clean.mp4
+  clipper-run gate <task-id>       MAY I SUBMIT? exits non-zero while a human gate is open
+  clipper-run submitted <task-id> --proof <proof-id>     Close the row + append the ledger
+
+THE GIGWORKER ANSWERS
+  clipper-run approve <task-id> [--note "<text>"]
+  clipper-run changes <task-id> --note "<what to fix>"
+  clipper-run drop    <task-id> --reason "<why>"
+
+WHERE AM I
+  clipper-run next                 THE ONE COMMAND — what to do right now, per open task
+  clipper-run status [<task-id>]   Every task, its stage, and who it is waiting on
+  clipper-run review               The batch review list (also written to REVIEW_QUEUE.md)
+  clipper-run note <task-id> "<text>"
+
+  Common: --dir <mission folder, default ./CLIPPER> · --mode <run mode, for this call only> · --json
+  State lives in files on purpose: a weak model loses the thread, a file does not.
+  The loop this serves: https://vidfarm.cc/agentic-clipper.md`;
+function options() {
+    return {
+        dir: { type: "string" },
+        mode: { type: "string" },
+        json: { type: "boolean" },
+        gig: { type: "string" },
+        machine: { type: "string" },
+        price: { type: "string" },
+        title: { type: "string" },
+        harness: { type: "string" },
+        brief: { type: "string" },
+        template: { type: "string", multiple: true },
+        why: { type: "string", multiple: true },
+        file: { type: "string" },
+        "clean-master": { type: "string" },
+        proof: { type: "string" },
+        note: { type: "string" },
+        reason: { type: "string" },
+        ask: { type: "string" },
+        by: { type: "string" }
+    };
+}
+export async function runClipperRunCommand(argv) {
+    const sub = (argv[0] ?? "help").toLowerCase();
+    if (["help", "--help", "-h", ""].includes(sub)) {
+        console.log(CLIPPER_RUN_HELP);
+        return;
+    }
+    const parsed = parseArgs({ args: argv.slice(1), allowPositionals: true, options: options() });
+    const values = parsed.values;
+    const rest = parsed.positionals;
+    const root = missionRoot(values);
+    switch (sub) {
+        case "init": return cmdInit(root, values);
+        case "mode":
+        case "run-mode": return cmdMode(root, values, rest);
+        case "start":
+        case "open": return cmdStart(root, values, rest);
+        case "shortlist":
+        case "suggest": return cmdShortlist(root, values, rest);
+        case "pick":
+        case "choose": return cmdPick(root, values, rest);
+        case "plan": return cmdPlan(root, values, rest);
+        case "raws":
+        case "footage": return cmdRaws(root, values, rest);
+        case "cut":
+        case "built": return cmdCut(root, values, rest);
+        case "approve":
+        case "ok": return cmdApprove(root, values, rest);
+        case "changes":
+        case "revise": return cmdChanges(root, values, rest);
+        case "drop":
+        case "discard": return cmdDrop(root, values, rest);
+        case "submitted":
+        case "sent": return cmdSubmitted(root, values, rest);
+        case "status":
+        case "state": return cmdStatus(root, values, rest);
+        case "next":
+        case "what-now": return cmdNext(root, values);
+        case "review":
+        case "queue": return cmdReview(root, values);
+        case "gate":
+        case "may-i-submit": return cmdGate(root, values, rest);
+        case "note": return cmdNote(root, values, rest);
+        default:
+            console.error(`Unknown clipper-run subcommand: ${sub}\n`);
+            console.log(CLIPPER_RUN_HELP);
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=clipper-run.js.map