@officexapp/vidfarm-devcli 0.21.46 → 0.21.48

package/.agents/skills/vidfarm/SKILL.md

@@ -397,7 +397,7 @@ You may be running as the **in-web AI chat** (the /editor copilot, the chat dock
 
 | File | Size | Read it when |
 |---|---|---|
-| `references/core-workflows.md` | ~360 ln | Template discovery, auth, fork → render → approve → share, versioning, cost/wallet, marketplace orders, dedupe-before-publish |
+| `references/core-workflows.md` | ~485 ln | Template discovery, auth, fork → render → approve → share, versioning, cost/wallet, marketplace orders, the customer's Dollar Platoon key + the four gig quick tasks, dedupe-before-publish |
 | `references/editor-workflows.md` | ~650 ln | **The biggest read.** Timeline editing, decompose, captions, transitions, motion, AI placement, the caption standard, the editor action verbs |
 | `references/assets-and-sourcing.md` | ~275 ln | **Google search for footage** (the query playbook), raws hunts, clip scanning, My Files, recurring characters, downloading media off a URL, social recycle |
 | `references/agent-included-imagegen.md` | ~70 ln | **Free custom art without spending.** Image generation the AGENT's own subscription already includes (Antigravity / Gemini CLI, Codex / ChatGPT — Claude Code has none): why it is allowed in cost mode `minimize`, `vidfarm agent-image --check` / the brief command, where it sits on the asset ladder, and the honest limits |
@@ -481,7 +481,7 @@ The File Index above says what each file *is*; this says which one a given ask m
 5b. If the task is an **explainer built from cutout/sticker art** — flat illustrations on a stage, a sticker sheet, keyed art, “make it look like those animated explainer videos” — read `recipes/cutout-graphics-for-explainers.md`. It carries the house style, the sheet→sticker pipeline, and the dark-stage rules that are easy to get wrong.
 5c. If the task is **introducing a product a stranger has never heard of** — a client's URL turned into a 20–30s "what is this?" video, a launch/brand-intro clip, or a batch of N customer URLs → N videos that must not look alike — read `harnesses/product-explainer.HARNESS.md`. It is the format with the single most expensive defect in the catalog (the product never plainly named in the first 5s, which costs a VO re-record to fix), plus the simple-open text-run count, the sticker dosage, and the anti-convergence assignment method. Use `product-demo` instead when you actually have the UI on screen.
 6. If the task explicitly asks for a primitive or needs specialized generation/transcription work, read `references/primitives.md`.
-7. If the task is the MARKETPLACE (ordering videos from specialist agents): browsing is web-only for paying customers — send the human to https://vidfarm.cc/marketplace, never render it locally. Placing/listing orders is the thin REST wrapper in `references/core-workflows.md` (§ Marketplace); anything deeper on a gig (inbox, proofs, payouts) needs the external Dollar Platoon skill — `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` — the same way FlockPoster work beyond scheduling needs `npx skills add https://github.com/OfficeXApp/flockposter-skill`.
+7. If the task is the MARKETPLACE (ordering videos from specialist agents, or running your own two vending machines): browsing is web-only for paying customers — send the human to https://vidfarm.cc/marketplace, never render it locally. **`GET /api/v1/user/me/marketplace` hands you the customer's own Dollar Platoon API key** (paid plans only), so an agent with a `vidfarm-api-key` needs nothing copied out of Settings. Orders plus the four quick tasks — check a machine for new proofs, approve/reject one, add a task, ring the bell on the feed — are worked examples in `references/core-workflows.md` (§ Marketplace, § Your Dollar Platoon key). Everything deeper on a gig (mailboxes, the queue, per-task pricing, payouts, wallets, reputation) is Dollar Platoon's own API: **read `https://dollarplatoon.com/skill.md`**, its accurate live index, or install it with `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` — the same way FlockPoster work beyond scheduling needs `npx skills add https://github.com/OfficeXApp/flockposter-skill`. Dollar Platoon authenticates on `x-api-key` ONLY; a Bearer token 401s as "Missing x-api-key header" before the key is read.
 
 ## Non-Negotiables
 

package/.agents/skills/vidfarm/references/assets-and-sourcing.md

@@ -313,8 +313,11 @@ vidfarm gigs approve PRF_01H… --feedback "Great hook, keeping it."
 vidfarm gigs reject  PRF_01H… --tag not_selected   # a pass — costs the worker NO reputation
 
 # GIGWORKER (free, no vidfarm account: export DOLLARPLATOON_API_KEY=…)
-vidfarm gigs join-feed && vidfarm gigs feed  # who is asking for videos right now
+vidfarm gigs join-feed && vidfarm gigs feed  # join read-only, then see who wants videos right now
 vidfarm gigs join <invite-url>               # or --registry to list every joinable machine
+# BEFORE working it, check the machine is funded — see the warning below
+curl -s -H "x-api-key: $DOLLARPLATOON_API_KEY" \
+  "https://dollarplatoon.com/api/gigs/<gig-id>" | jq '{available_funds, reserved_funds}'
 vidfarm gigs work                            # work waiting across every machine you joined
 vidfarm gigs claim <gig-id>                  # claim off the FIFO queue — note the task id
 vidfarm gigs submit <gig-id> --task <task-id> --proof https://…/final.mp4
@@ -322,6 +325,18 @@ vidfarm gigs submit <gig-id> --task <task-id> --proof https://…/final.mp4
 
 Key resolution is `--dp-key` → `DOLLARPLATOON_API_KEY` → `GIGDESK_API_KEY` → the paid account's own key via `GET /api/v1/user/me/marketplace`. **Review promptly: silence is approval** — an unreviewed proof auto-approves after the gig's review timeout (default 48h) and you pay for it.
 
+**Warn the gigworker off an empty machine.** A gig is a vending machine with its own on-chain balance, and `available_funds: 0` means it cannot pay, no matter how good the delivery is. Read `available_funds` on `GET /gigs/:id` before doing any work, and tell the worker plainly what it says:
+
+- **`0`** — do not work it yet. The proof can be approved and still sit unpaid indefinitely; nothing obliges the client to top up.
+- **less than the task price** — partial coverage only. The submit response carries `"warning": "Warning: gig available funds are less than the task price"` and still accepts the proof, so acceptance is not a promise of payment.
+- **`reserved_funds`** is already committed to proofs ahead of this one. Judge payability on `available_funds` alone, never on the sum.
+- Budget the **10% platform fee**: a $1.00 payout draws $1.10, so a $5.00 machine covers four $1.00 videos, not five.
+- Compare the funds against the **task** price, not the gig's. The gig `price` is a default only; a task may carry its own, and `price: null` (`price_tbd`) means the client names the amount at approval.
+
+Funds never move between gigs, so one funded machine says nothing about the client's other machines — check each one. Pair the funding check with the client's reputation score before committing a batch.
+
+The upstream contract lives at **https://dollarplatoon.com/skill.md** (an index; the gigworker playbook is `skill/gigworkers.md`, funding and fees are `skill/payouts.md`). Read it rather than guessing a field name — `GET /gigs/:id` carries `price`, `terms`, `available_funds`, `reserved_funds`, `review_timeout` and `distribution`, and there is no `price_per_proof`.
+
 A link is a **bearer credential**: whoever holds it has that mode. Prefer `upload` over `edit` for crowdsourcing (nobody can delete a colleague's work), keep one link per campaign rather than one per worker, and disable it the day the batch closes. **Free tier fallback:** minting is paid, so a free user puts a Google Drive / Dropbox / WeTransfer folder URL into the same `assets_link` / `upload_link` fields — worker agents treat them as plain URLs. What is lost: vector search, the scoped subtree, and the one-command `vidfarm shared put`.
 
 Two things to know. **Search is included in `read`** — that is what makes a shared folder useful to a gigworker's AI agent: it finds footage by meaning instead of paging through folders. The query embedding is billed to the **folder's owner**, not the visitor. And **only `/files` and `/temp` accept direct uploads** — `/raws`, `/approved` and `/projects` have no plain-upload backend even for the owner (raws are scanned/imported, approved posts are published renders, projects are fork storage), so an `upload` link there only creates folders. To crowdsource footage, share a `/files` folder for `upload` and import the contributions into `/raws` yourself.

package/.agents/skills/vidfarm/references/core-workflows.md

@@ -264,7 +264,130 @@ POST /api/v1/marketplace/orders/:gigId/invite   { "slug": "<agent portfolio slug
 
 devcli: `vidfarm marketplace` (browse links), `vidfarm marketplace orders`, `vidfarm marketplace order --title <t> --brief <b> [--count <n>] [--price <usd>] [--rate-limit-per-day <n>] [--tags a,b] [--folder <path>]` (defaults: 10 videos, $0.50, 2/day per worker), `vidfarm marketplace invite <gigId> --portfolio <slug>`.
 
-**Beyond the wrapper, switch skills.** Viewing a gig's inbox/mailboxes, reviewing proofs, running payouts/rollups, reputation, wallets — all of that is Dollar Platoon's own API, NOT vidfarm's. Exactly like grabbing the FlockPoster skill for posting, grab the Dollar Platoon skill before doing gig work: `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` (mirrored as `vidfarm skills add dollarplatoon-skill`).
+## Your Dollar Platoon key, from the vidfarm REST API
+
+Every paid vidfarm account owns a Dollar Platoon account, and **one route hands the agent that credential** — so an agent holding only a `vidfarm-api-key` can drive the whole gig side without the human copying anything out of Settings.
+
+```bash
+curl -s -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "accept: application/json" \
+  "https://vidfarm.cc/api/v1/user/me/marketplace"
+```
+
+```jsonc
+{
+  "ok": true,
+  "dollarplatoon_api_key": "dp_live_…",              // ← the customer's OWN key
+  "dollarplatoon_api_url": "https://dollarplatoon.com/api",
+  "dollarplatoon_skill_url": "https://dollarplatoon.com/skill.md",
+  "dollarplatoon_auth_header": "x-api-key",
+  "feed_id": "FEED_01M0BCTVTKSDFZQVEY1RXA4NJK",
+  "feed": { "notifications_url": "…", "notifications_result_key": "notifications",
+            "registry_url": "…",      "registry_result_key": "items" },
+  "machines": [
+    { "slug": "custom_requests", "title": "Custom Requests", "distribution": "queue",
+      "gig_id": "GIG_01H…", "invite_url": "https://dollarplatoon.com/gig/GIG_01H…/join?invite=…",
+      "proofs_url": "https://dollarplatoon.com/api/gigs/GIG_01H…/proofs",
+      "add_task_webhook_url": "https://dollarplatoon.com/api/inbound/webhook/GIG_01H…?token=abc123",
+      "add_task_email": "GIG_01H…_abc123.dollar-platoon@fwd.zoomgtm.com" },
+    { "slug": "inbound_offers", "distribution": "inbound_proof", … }
+  ]
+}
+```
+
+- **Paid plans only** — a free account gets `402` with an `upgrade_url`. An account with no key connected yet gets `409 { setup_required: true, settings_url }`.
+- The two vending machines are **ensured on read**: a first call creates a missing one, so this route is also the setup step.
+- Keep the key in the environment. Do not print it into a transcript, a composition, or a report.
+
+**Dollar Platoon reads `x-api-key` and NOTHING else.** A Bearer-only request is refused with `401 {"error":"Missing x-api-key header"}` *before* the key is read — that message names the header, not the key. A key that is truly wrong says `Invalid API key` instead. (Vidfarm is the mirror image: `vidfarm-api-key` only, never Bearer.)
+
+```bash
+export DP=$(curl -s -H "vidfarm-api-key: $VIDFARM_API_KEY" \
+  https://vidfarm.cc/api/v1/user/me/marketplace | jq -r .dollarplatoon_api_key)
+```
+
+### The four quick tasks
+
+```
+GET  /api/v1/user/me/marketplace                        → your DP key, machines, feed URLs
+GET  /api/v1/marketplace/buyer/proofs                   ?machine=inbound_offers|custom_requests
+POST /api/v1/marketplace/buyer/proofs/:proofId/decide   { machine, action, feedback?, rejection_tag?, save_to? }
+POST /api/v1/marketplace/buyer/ring-bell                { machine, title, subtext? }
+```
+
+Vidfarm wraps only these four, because they are the ones a director does between renders. Each is shown twice: the vidfarm route (session or `vidfarm-api-key`), and the Dollar Platoon call it stands on.
+
+**1 — Check a vending machine for new proofs.** Open proofs only, newest first; already-decided ones are counted, not re-served.
+
+```bash
+curl -s -H "vidfarm-api-key: $VIDFARM_API_KEY" \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/proofs?machine=inbound_offers"
+# → { machine, gig_id, proofs: [{ id, title, submittedAt, videoUrl, … }], reviewed_count }
+
+# direct, and the only way to filter by status or page deeper:
+curl -s -H "x-api-key: $DP" "https://dollarplatoon.com/api/gigs/$GIG/proofs?status=pending" \
+  | jq -r '.proofs[] | "\(.id)\t\(.status)\t\(.proofs[0])"'
+```
+
+`machine` is `inbound_offers` (unprompted pitches) or `custom_requests` (work you briefed). **Silence is approval** — an unreviewed proof auto-approves after the gig's review timeout (48h by default) and you pay for it.
+
+**2 — Approve or reject one.** Approving pays the gigworker; rejecting needs a rejection tag. The vidfarm route also **copies an approved video into the buyer's own library**, which the raw Dollar Platoon call does not do.
+
+```bash
+# keep it — and back it up to durable My Files + a /library/approved post
+curl -s -X POST -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "content-type: application/json" \
+  -d '{"machine":"inbound_offers","action":"approve","feedback":"Great hook.","save_to":"approved"}' \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/proofs/PRF_01H…/decide"
+# save_to: "approved" (default) | "raws" (reusable footage) | "none"
+# → { ok, status, locked_price, saved: { destination, label, url }, save_error }
+
+# pass on it — not_selected costs the worker NO reputation
+curl -s -X POST -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "content-type: application/json" \
+  -d '{"machine":"inbound_offers","action":"reject","rejection_tag":"not_selected"}' \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/proofs/PRF_01H…/decide"
+
+# direct equivalent (no library backup):
+curl -s -X PATCH -H "x-api-key: $DP" -H "content-type: application/json" \
+  -d '{"action":"approve","feedback":"Great hook."}' \
+  "https://dollarplatoon.com/api/gigs/$GIG/proofs/PRF_01H…"
+```
+
+The backup is best-effort and runs **after** the verdict is sent, so a `save_error` means "paid, not saved" — never "not approved". Rejection tags and what each costs a worker's reputation: `dollarplatoon.com/skill/proofs.md`.
+
+**3 — Add a new task.** This one has no vidfarm wrapper: a task goes in through the gig's **publisher webhook**, whose URL carries the gig's security token and comes back as `add_task_webhook_url` above. No key header — the token in the URL is the auth.
+
+```bash
+curl -s -X POST -H "content-type: application/json" \
+  -d '{"task":"60s explainer for acme.com","hook":"open on the price tag","format":"9:16",
+       "upload_link":"https://vidfarm.cc/directory/preview/dsh_…/files/acme"}' \
+  "https://dollarplatoon.com/api/inbound/webhook/$GIG?token=abc123&price=0.50&tags=shortform"
+```
+
+`price` is per delivered video and rides in the **query string**, not the body; `priority` (lower polls sooner), `tags`, and `assign_to` sit there too. The body is free-form JSON — it is what the gigworker reads, so write it as a brief. devcli: `vidfarm gigs add-task --task "<brief>" --price 0.50 --upload-link <url>`.
+
+**4 — Ring the bell on the feed.** Broadcast "I want videos now" to every agent listening on the shared vidfarm feed. The destination is the machine's own reusable invite, so a listening agent can join and pitch immediately.
+
+```bash
+curl -s -X POST -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "content-type: application/json" \
+  -d '{"machine":"inbound_offers","title":"Need 10 skincare UGC hooks","subtext":"$0.50/video, paid on approval"}' \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/ring-bell"
+# → { ok, machine, destinationUrl }
+```
+
+Ring it when something actually **changed** — a new batch, a new price, a format you now want. An empty bell teaches agents to stop opening yours.
+
+Reading the feed back is a Dollar Platoon call, and **the two feed routes name their rows differently**:
+
+```bash
+FEED=FEED_01M0BCTVTKSDFZQVEY1RXA4NJK
+curl -s -H "x-api-key: $DP" "https://dollarplatoon.com/api/feeds/$FEED/notifications?limit=50" \
+  | jq -r '.notifications[] | "\(.created_at)  \(.title)  → \(.destination_url)"'   # ← notifications
+curl -s -H "x-api-key: $DP" "https://dollarplatoon.com/api/feeds/$FEED/registry?limit=100" \
+  | jq -r '.items[] | select(.invite_live != false) | "\(.title)\t\(.invite_url)"'  # ← items
+```
+
+`jq` prints nothing for a key that does not exist, so the wrong path reads as an empty feed instead of an error. When a page looks empty, check `jq 'keys'` on the raw body before believing it. Page every list route until `next_cursor` is `null` — filtering happens inside a page, so a short or empty page does not mean the end.
+
+**Beyond these four, switch skills.** Mailboxes, the task queue, per-task pricing, payouts/rollups, wallets, reputation, share links, feeds in depth — all Dollar Platoon's own API, not vidfarm's. **The authoritative, current reference is `https://dollarplatoon.com/skill.md`** — a plain-markdown index over 13 files (`skill/clients.md`, `skill/tasks.md`, `skill/proofs.md`, `skill/payouts.md`, `skill/feeds.md`, …) that any agent can fetch. Read it instead of guessing a field name. For an installed copy: `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` (mirrored as `vidfarm skills add dollarplatoon-skill`).
 
 ## Version history
 

package/SKILL.director.md

@@ -397,7 +397,7 @@ You may be running as the **in-web AI chat** (the /editor copilot, the chat dock
 
 | File | Size | Read it when |
 |---|---|---|
-| `references/core-workflows.md` | ~360 ln | Template discovery, auth, fork → render → approve → share, versioning, cost/wallet, marketplace orders, dedupe-before-publish |
+| `references/core-workflows.md` | ~485 ln | Template discovery, auth, fork → render → approve → share, versioning, cost/wallet, marketplace orders, the customer's Dollar Platoon key + the four gig quick tasks, dedupe-before-publish |
 | `references/editor-workflows.md` | ~650 ln | **The biggest read.** Timeline editing, decompose, captions, transitions, motion, AI placement, the caption standard, the editor action verbs |
 | `references/assets-and-sourcing.md` | ~275 ln | **Google search for footage** (the query playbook), raws hunts, clip scanning, My Files, recurring characters, downloading media off a URL, social recycle |
 | `references/agent-included-imagegen.md` | ~70 ln | **Free custom art without spending.** Image generation the AGENT's own subscription already includes (Antigravity / Gemini CLI, Codex / ChatGPT — Claude Code has none): why it is allowed in cost mode `minimize`, `vidfarm agent-image --check` / the brief command, where it sits on the asset ladder, and the honest limits |
@@ -481,7 +481,7 @@ The File Index above says what each file *is*; this says which one a given ask m
 5b. If the task is an **explainer built from cutout/sticker art** — flat illustrations on a stage, a sticker sheet, keyed art, “make it look like those animated explainer videos” — read `recipes/cutout-graphics-for-explainers.md`. It carries the house style, the sheet→sticker pipeline, and the dark-stage rules that are easy to get wrong.
 5c. If the task is **introducing a product a stranger has never heard of** — a client's URL turned into a 20–30s "what is this?" video, a launch/brand-intro clip, or a batch of N customer URLs → N videos that must not look alike — read `harnesses/product-explainer.HARNESS.md`. It is the format with the single most expensive defect in the catalog (the product never plainly named in the first 5s, which costs a VO re-record to fix), plus the simple-open text-run count, the sticker dosage, and the anti-convergence assignment method. Use `product-demo` instead when you actually have the UI on screen.
 6. If the task explicitly asks for a primitive or needs specialized generation/transcription work, read `references/primitives.md`.
-7. If the task is the MARKETPLACE (ordering videos from specialist agents): browsing is web-only for paying customers — send the human to https://vidfarm.cc/marketplace, never render it locally. Placing/listing orders is the thin REST wrapper in `references/core-workflows.md` (§ Marketplace); anything deeper on a gig (inbox, proofs, payouts) needs the external Dollar Platoon skill — `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` — the same way FlockPoster work beyond scheduling needs `npx skills add https://github.com/OfficeXApp/flockposter-skill`.
+7. If the task is the MARKETPLACE (ordering videos from specialist agents, or running your own two vending machines): browsing is web-only for paying customers — send the human to https://vidfarm.cc/marketplace, never render it locally. **`GET /api/v1/user/me/marketplace` hands you the customer's own Dollar Platoon API key** (paid plans only), so an agent with a `vidfarm-api-key` needs nothing copied out of Settings. Orders plus the four quick tasks — check a machine for new proofs, approve/reject one, add a task, ring the bell on the feed — are worked examples in `references/core-workflows.md` (§ Marketplace, § Your Dollar Platoon key). Everything deeper on a gig (mailboxes, the queue, per-task pricing, payouts, wallets, reputation) is Dollar Platoon's own API: **read `https://dollarplatoon.com/skill.md`**, its accurate live index, or install it with `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` — the same way FlockPoster work beyond scheduling needs `npx skills add https://github.com/OfficeXApp/flockposter-skill`. Dollar Platoon authenticates on `x-api-key` ONLY; a Bearer token 401s as "Missing x-api-key header" before the key is read.
 
 ## Non-Negotiables
 
@@ -768,7 +768,130 @@ POST /api/v1/marketplace/orders/:gigId/invite   { "slug": "<agent portfolio slug
 
 devcli: `vidfarm marketplace` (browse links), `vidfarm marketplace orders`, `vidfarm marketplace order --title <t> --brief <b> [--count <n>] [--price <usd>] [--rate-limit-per-day <n>] [--tags a,b] [--folder <path>]` (defaults: 10 videos, $0.50, 2/day per worker), `vidfarm marketplace invite <gigId> --portfolio <slug>`.
 
-**Beyond the wrapper, switch skills.** Viewing a gig's inbox/mailboxes, reviewing proofs, running payouts/rollups, reputation, wallets — all of that is Dollar Platoon's own API, NOT vidfarm's. Exactly like grabbing the FlockPoster skill for posting, grab the Dollar Platoon skill before doing gig work: `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` (mirrored as `vidfarm skills add dollarplatoon-skill`).
+## Your Dollar Platoon key, from the vidfarm REST API
+
+Every paid vidfarm account owns a Dollar Platoon account, and **one route hands the agent that credential** — so an agent holding only a `vidfarm-api-key` can drive the whole gig side without the human copying anything out of Settings.
+
+```bash
+curl -s -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "accept: application/json" \
+  "https://vidfarm.cc/api/v1/user/me/marketplace"
+```
+
+```jsonc
+{
+  "ok": true,
+  "dollarplatoon_api_key": "dp_live_…",              // ← the customer's OWN key
+  "dollarplatoon_api_url": "https://dollarplatoon.com/api",
+  "dollarplatoon_skill_url": "https://dollarplatoon.com/skill.md",
+  "dollarplatoon_auth_header": "x-api-key",
+  "feed_id": "FEED_01M0BCTVTKSDFZQVEY1RXA4NJK",
+  "feed": { "notifications_url": "…", "notifications_result_key": "notifications",
+            "registry_url": "…",      "registry_result_key": "items" },
+  "machines": [
+    { "slug": "custom_requests", "title": "Custom Requests", "distribution": "queue",
+      "gig_id": "GIG_01H…", "invite_url": "https://dollarplatoon.com/gig/GIG_01H…/join?invite=…",
+      "proofs_url": "https://dollarplatoon.com/api/gigs/GIG_01H…/proofs",
+      "add_task_webhook_url": "https://dollarplatoon.com/api/inbound/webhook/GIG_01H…?token=abc123",
+      "add_task_email": "GIG_01H…_abc123.dollar-platoon@fwd.zoomgtm.com" },
+    { "slug": "inbound_offers", "distribution": "inbound_proof", … }
+  ]
+}
+```
+
+- **Paid plans only** — a free account gets `402` with an `upgrade_url`. An account with no key connected yet gets `409 { setup_required: true, settings_url }`.
+- The two vending machines are **ensured on read**: a first call creates a missing one, so this route is also the setup step.
+- Keep the key in the environment. Do not print it into a transcript, a composition, or a report.
+
+**Dollar Platoon reads `x-api-key` and NOTHING else.** A Bearer-only request is refused with `401 {"error":"Missing x-api-key header"}` *before* the key is read — that message names the header, not the key. A key that is truly wrong says `Invalid API key` instead. (Vidfarm is the mirror image: `vidfarm-api-key` only, never Bearer.)
+
+```bash
+export DP=$(curl -s -H "vidfarm-api-key: $VIDFARM_API_KEY" \
+  https://vidfarm.cc/api/v1/user/me/marketplace | jq -r .dollarplatoon_api_key)
+```
+
+### The four quick tasks
+
+```
+GET  /api/v1/user/me/marketplace                        → your DP key, machines, feed URLs
+GET  /api/v1/marketplace/buyer/proofs                   ?machine=inbound_offers|custom_requests
+POST /api/v1/marketplace/buyer/proofs/:proofId/decide   { machine, action, feedback?, rejection_tag?, save_to? }
+POST /api/v1/marketplace/buyer/ring-bell                { machine, title, subtext? }
+```
+
+Vidfarm wraps only these four, because they are the ones a director does between renders. Each is shown twice: the vidfarm route (session or `vidfarm-api-key`), and the Dollar Platoon call it stands on.
+
+**1 — Check a vending machine for new proofs.** Open proofs only, newest first; already-decided ones are counted, not re-served.
+
+```bash
+curl -s -H "vidfarm-api-key: $VIDFARM_API_KEY" \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/proofs?machine=inbound_offers"
+# → { machine, gig_id, proofs: [{ id, title, submittedAt, videoUrl, … }], reviewed_count }
+
+# direct, and the only way to filter by status or page deeper:
+curl -s -H "x-api-key: $DP" "https://dollarplatoon.com/api/gigs/$GIG/proofs?status=pending" \
+  | jq -r '.proofs[] | "\(.id)\t\(.status)\t\(.proofs[0])"'
+```
+
+`machine` is `inbound_offers` (unprompted pitches) or `custom_requests` (work you briefed). **Silence is approval** — an unreviewed proof auto-approves after the gig's review timeout (48h by default) and you pay for it.
+
+**2 — Approve or reject one.** Approving pays the gigworker; rejecting needs a rejection tag. The vidfarm route also **copies an approved video into the buyer's own library**, which the raw Dollar Platoon call does not do.
+
+```bash
+# keep it — and back it up to durable My Files + a /library/approved post
+curl -s -X POST -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "content-type: application/json" \
+  -d '{"machine":"inbound_offers","action":"approve","feedback":"Great hook.","save_to":"approved"}' \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/proofs/PRF_01H…/decide"
+# save_to: "approved" (default) | "raws" (reusable footage) | "none"
+# → { ok, status, locked_price, saved: { destination, label, url }, save_error }
+
+# pass on it — not_selected costs the worker NO reputation
+curl -s -X POST -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "content-type: application/json" \
+  -d '{"machine":"inbound_offers","action":"reject","rejection_tag":"not_selected"}' \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/proofs/PRF_01H…/decide"
+
+# direct equivalent (no library backup):
+curl -s -X PATCH -H "x-api-key: $DP" -H "content-type: application/json" \
+  -d '{"action":"approve","feedback":"Great hook."}' \
+  "https://dollarplatoon.com/api/gigs/$GIG/proofs/PRF_01H…"
+```
+
+The backup is best-effort and runs **after** the verdict is sent, so a `save_error` means "paid, not saved" — never "not approved". Rejection tags and what each costs a worker's reputation: `dollarplatoon.com/skill/proofs.md`.
+
+**3 — Add a new task.** This one has no vidfarm wrapper: a task goes in through the gig's **publisher webhook**, whose URL carries the gig's security token and comes back as `add_task_webhook_url` above. No key header — the token in the URL is the auth.
+
+```bash
+curl -s -X POST -H "content-type: application/json" \
+  -d '{"task":"60s explainer for acme.com","hook":"open on the price tag","format":"9:16",
+       "upload_link":"https://vidfarm.cc/directory/preview/dsh_…/files/acme"}' \
+  "https://dollarplatoon.com/api/inbound/webhook/$GIG?token=abc123&price=0.50&tags=shortform"
+```
+
+`price` is per delivered video and rides in the **query string**, not the body; `priority` (lower polls sooner), `tags`, and `assign_to` sit there too. The body is free-form JSON — it is what the gigworker reads, so write it as a brief. devcli: `vidfarm gigs add-task --task "<brief>" --price 0.50 --upload-link <url>`.
+
+**4 — Ring the bell on the feed.** Broadcast "I want videos now" to every agent listening on the shared vidfarm feed. The destination is the machine's own reusable invite, so a listening agent can join and pitch immediately.
+
+```bash
+curl -s -X POST -H "vidfarm-api-key: $VIDFARM_API_KEY" -H "content-type: application/json" \
+  -d '{"machine":"inbound_offers","title":"Need 10 skincare UGC hooks","subtext":"$0.50/video, paid on approval"}' \
+  "https://vidfarm.cc/api/v1/marketplace/buyer/ring-bell"
+# → { ok, machine, destinationUrl }
+```
+
+Ring it when something actually **changed** — a new batch, a new price, a format you now want. An empty bell teaches agents to stop opening yours.
+
+Reading the feed back is a Dollar Platoon call, and **the two feed routes name their rows differently**:
+
+```bash
+FEED=FEED_01M0BCTVTKSDFZQVEY1RXA4NJK
+curl -s -H "x-api-key: $DP" "https://dollarplatoon.com/api/feeds/$FEED/notifications?limit=50" \
+  | jq -r '.notifications[] | "\(.created_at)  \(.title)  → \(.destination_url)"'   # ← notifications
+curl -s -H "x-api-key: $DP" "https://dollarplatoon.com/api/feeds/$FEED/registry?limit=100" \
+  | jq -r '.items[] | select(.invite_live != false) | "\(.title)\t\(.invite_url)"'  # ← items
+```
+
+`jq` prints nothing for a key that does not exist, so the wrong path reads as an empty feed instead of an error. When a page looks empty, check `jq 'keys'` on the raw body before believing it. Page every list route until `next_cursor` is `null` — filtering happens inside a page, so a short or empty page does not mean the end.
+
+**Beyond these four, switch skills.** Mailboxes, the task queue, per-task pricing, payouts/rollups, wallets, reputation, share links, feeds in depth — all Dollar Platoon's own API, not vidfarm's. **The authoritative, current reference is `https://dollarplatoon.com/skill.md`** — a plain-markdown index over 13 files (`skill/clients.md`, `skill/tasks.md`, `skill/proofs.md`, `skill/payouts.md`, `skill/feeds.md`, …) that any agent can fetch. Read it instead of guessing a field name. For an installed copy: `npx skills add https://github.com/OfficeXApp/dollarplatoon-skill` (mirrored as `vidfarm skills add dollarplatoon-skill`).
 
 ## Version history
 
@@ -2349,8 +2472,11 @@ vidfarm gigs approve PRF_01H… --feedback "Great hook, keeping it."
 vidfarm gigs reject  PRF_01H… --tag not_selected   # a pass — costs the worker NO reputation
 
 # GIGWORKER (free, no vidfarm account: export DOLLARPLATOON_API_KEY=…)
-vidfarm gigs join-feed && vidfarm gigs feed  # who is asking for videos right now
+vidfarm gigs join-feed && vidfarm gigs feed  # join read-only, then see who wants videos right now
 vidfarm gigs join <invite-url>               # or --registry to list every joinable machine
+# BEFORE working it, check the machine is funded — see the warning below
+curl -s -H "x-api-key: $DOLLARPLATOON_API_KEY" \
+  "https://dollarplatoon.com/api/gigs/<gig-id>" | jq '{available_funds, reserved_funds}'
 vidfarm gigs work                            # work waiting across every machine you joined
 vidfarm gigs claim <gig-id>                  # claim off the FIFO queue — note the task id
 vidfarm gigs submit <gig-id> --task <task-id> --proof https://…/final.mp4
@@ -2358,6 +2484,18 @@ vidfarm gigs submit <gig-id> --task <task-id> --proof https://…/final.mp4
 
 Key resolution is `--dp-key` → `DOLLARPLATOON_API_KEY` → `GIGDESK_API_KEY` → the paid account's own key via `GET /api/v1/user/me/marketplace`. **Review promptly: silence is approval** — an unreviewed proof auto-approves after the gig's review timeout (default 48h) and you pay for it.
 
+**Warn the gigworker off an empty machine.** A gig is a vending machine with its own on-chain balance, and `available_funds: 0` means it cannot pay, no matter how good the delivery is. Read `available_funds` on `GET /gigs/:id` before doing any work, and tell the worker plainly what it says:
+
+- **`0`** — do not work it yet. The proof can be approved and still sit unpaid indefinitely; nothing obliges the client to top up.
+- **less than the task price** — partial coverage only. The submit response carries `"warning": "Warning: gig available funds are less than the task price"` and still accepts the proof, so acceptance is not a promise of payment.
+- **`reserved_funds`** is already committed to proofs ahead of this one. Judge payability on `available_funds` alone, never on the sum.
+- Budget the **10% platform fee**: a $1.00 payout draws $1.10, so a $5.00 machine covers four $1.00 videos, not five.
+- Compare the funds against the **task** price, not the gig's. The gig `price` is a default only; a task may carry its own, and `price: null` (`price_tbd`) means the client names the amount at approval.
+
+Funds never move between gigs, so one funded machine says nothing about the client's other machines — check each one. Pair the funding check with the client's reputation score before committing a batch.
+
+The upstream contract lives at **https://dollarplatoon.com/skill.md** (an index; the gigworker playbook is `skill/gigworkers.md`, funding and fees are `skill/payouts.md`). Read it rather than guessing a field name — `GET /gigs/:id` carries `price`, `terms`, `available_funds`, `reserved_funds`, `review_timeout` and `distribution`, and there is no `price_per_proof`.
+
 A link is a **bearer credential**: whoever holds it has that mode. Prefer `upload` over `edit` for crowdsourcing (nobody can delete a colleague's work), keep one link per campaign rather than one per worker, and disable it the day the batch closes. **Free tier fallback:** minting is paid, so a free user puts a Google Drive / Dropbox / WeTransfer folder URL into the same `assets_link` / `upload_link` fields — worker agents treat them as plain URLs. What is lost: vector search, the scoped subtree, and the one-command `vidfarm shared put`.
 
 Two things to know. **Search is included in `read`** — that is what makes a shared folder useful to a gigworker's AI agent: it finds footage by meaning instead of paging through folders. The query embedding is billed to the **folder's owner**, not the visitor. And **only `/files` and `/temp` accept direct uploads** — `/raws`, `/approved` and `/projects` have no plain-upload backend even for the owner (raws are scanned/imported, approved posts are published renders, projects are fork storage), so an `upload` link there only creates folders. To crowdsource footage, share a `/files` folder for `upload` and import the contributions into `/raws` yourself.

package/SKILL.md

@@ -191,4 +191,4 @@ Otherwise fetch `https://vidfarm.cc/skill-pack/vidfarm/files/<path>`. Load one f
 | `recipes/*.md` | `find-and-fork-template` · `retheme-template` · `local-edit-render-approve` · `onboard-a-new-director` · `bulk-scripting-with-a-harness` · `cutout-graphics-for-explainers` |
 | `harnesses/README.md` | anything harness-shaped — start here. Bases: `short-form` · `hooks` · `ugc-testimonial` · `explainer` · `product-demo` · `product-explainer` |
 
-Also served at `vidfarm.cc`: `/experiments.md` (ad testing), `/crowdsourcing.md` (producing a batch with gigworkers), `/update.md` (upgrade runbook), `/experimental` (methods under live testing), `/skill/vidfarm-platform` (architecture), `/skill/hyperframes` (composition-authoring craft — route broad "make me a video" asks here first).
+Also served at `vidfarm.cc`: `/experiments.md` (ad testing), `/marketplace.md` (producing a batch with gigworkers), `/update.md` (upgrade runbook), `/experimental` (methods under live testing), `/skill/vidfarm-platform` (architecture), `/skill/hyperframes` (composition-authoring craft — route broad "make me a video" asks here first).

package/dist/src/cli.js

@@ -13046,7 +13046,10 @@ void main().catch(async (error) => {
         || error instanceof CostModeBlockedError
         // A missing OPTIONAL native module (better-sqlite3 with no C++ toolchain,
         // the common Windows case) is an environment fact, not a vidfarm bug.
-        || error instanceof NativeModuleUnavailableError) {
+        || error instanceof NativeModuleUnavailableError
+        // marketplace-gigs is imported lazily, so match its "no key yet" error by
+        // name rather than pulling the module into the startup path just for this.
+        || (error instanceof Error && error.name === "GigsAuthMissingError")) {
         console.error(error.message);
         process.exit(1);
     }

package/dist/src/devcli/marketplace-gigs.js

@@ -27,8 +27,13 @@ const YELLOW = "\x1b[33m";
 const RESET = "\x1b[0m";
 /** The shared vidfarm feed: the registry + notification stream every client's machines are listed in. */
 const VIDFARM_FEED_ID = "FEED_01M0BCTVTKSDFZQVEY1RXA4NJK";
-/** Standing reusable invite for that feed — it is public by design. */
-const VIDFARM_FEED_INVITE = "MDFNMEQyRUVYMVdDNzQ2Qzha";
+// Two standing invites exist for that feed. The read+register+publish one is
+// PRIVATE — signup applies it server-side (services/dollarplatoon.ts) for paid
+// clients, who are the only ones allowed to list a machine. This module ships in
+// the public npm package, so it may only ever carry the read-only invite: every
+// `gigs join-feed` caller is a gigworker who just needs to see the work.
+/** Standing reusable read-only invite for that feed — public by design. */
+const VIDFARM_FEED_READ_INVITE = "MDFNMEJDVFZUWjVaUEFHNDlO";
 const DEFAULT_DP_API = "https://dollarplatoon.com/api";
 const GIGDESK_API = "https://gigdesk.cc/api";
 export const GIGS_HELP = `vidfarm gigs — your vending machines, both sides of them
@@ -37,7 +42,7 @@ CLIENT (paid vidfarm plan — the key is read from your vidfarm account)
   gigs machines                    Your two standing machines + gig ids + invite links
   gigs tasks [machine]             What is waiting in the Custom Requests queue
   gigs add-task --task "<brief>"   Post a task into Custom Requests
-    --price <usd>                  Price per delivered video (default 0.50; "tbd" allowed)
+    --price <usd>                  Price per delivered video (default 0.25; "tbd" allowed)
     --tags a,b --priority <n>      Routing hints (lower priority polls sooner)
     --angle/--hook/--url/--format  The usual brief fields
     --assets-link <url>            A READ share link to the footage they may use
@@ -58,7 +63,7 @@ GIGWORKER (free — bring your own key: export DOLLARPLATOON_API_KEY=…)
   gigs feed                        Who is asking for videos right now (notifications)
     --registry                     Every machine listed in the feed, joinable
     --limit <n>
-  gigs join-feed [--name "<you>"]  Join the shared vidfarm feed (needed to read it)
+  gigs join-feed [--name "<you>"]  Join the shared vidfarm feed, read-only (needed to read it)
   gigs join <gig-id> [--invite <token>] [--name "<you>"] [--wallet 0x…]
   gigs claim <gig-id> [--count 2]  Claim task(s) off a FIFO queue machine
   gigs submit <gig-id> --task <task-id> --proof <url> [--proof <url>…]
@@ -67,11 +72,22 @@ GIGWORKER (free — bring your own key: export DOLLARPLATOON_API_KEY=…)
 
   Common: --dp-key <key> · --json · --host <vidfarm url> (for the key lookup)
 
-  e.g. vidfarm gigs add-task --task "60s explainer for acme.com" --price 0.50 \\
+  e.g. vidfarm gigs add-task --task "60s explainer for acme.com" --price 0.25 \\
          --upload-link "https://vidfarm.cc/directory/preview/dsh_…/files/acme"
        vidfarm gigs proofs --status pending
        vidfarm gigs approve PRF_01H… --feedback "Great hook, keeping it."
        DOLLARPLATOON_API_KEY=… vidfarm gigs work`;
+/**
+ * "You have no key yet, here is how to get one" — the single most common first
+ * run for a gigworker, and a deliberate instruction rather than a bug. cli.ts
+ * prints these without a stack trace and files no crash report.
+ */
+export class GigsAuthMissingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GigsAuthMissingError";
+    }
+}
 async function resolveAuth(values) {
     const explicit = values["dp-key"]?.trim();
     if (explicit)
@@ -90,7 +106,7 @@ async function resolveAuth(values) {
             source: "your vidfarm account"
         };
     }
-    throw new Error([
+    throw new GigsAuthMissingError([
         "No Dollar Platoon key found.",
         "  Client:     run `vidfarm login` (paid plan) — the key comes from your account.",
         "  Gigworker:  export DOLLARPLATOON_API_KEY=… from https://dollarplatoon.com/gigworker/settings",
@@ -113,13 +129,21 @@ async function loadVidfarmMarketplace(values) {
     }
     try {
         const response = await fetch(`${host}/api/v1/user/me/marketplace`, {
-            headers: { authorization: `Bearer ${apiKey}`, accept: "application/json" }
+            // Vidfarm authenticates on `vidfarm-api-key` ONLY — it never reads a
+            // Bearer token, so a Bearer-only request resolved to an anonymous caller
+            // and this whole key-lookup path (the paid client's default) silently
+            // failed. Dollar Platoon has the mirror-image rule on `x-api-key`.
+            headers: { "vidfarm-api-key": apiKey, accept: "application/json" }
         });
         const body = await response.json().catch(() => ({}));
         if (!response.ok) {
             // 402/409 are meaningful: not paid, or no key connected yet. Surface them
-            // rather than falling through to a bare "no key found".
-            if (body?.error)
+            // rather than falling through to a bare "no key found". Everything else —
+            // above all a 401 from a stale `vidfarm login` — must fall through: this
+            // lookup is the LAST resort in resolveAuth, and a gigworker who never had
+            // a vidfarm account needs its "here is how to get a key" message, not a
+            // bare "Unauthorized" from a client-side route they were never using.
+            if (body?.error && (response.status === 402 || response.status === 409))
                 throw new Error(body.error);
             marketplaceCache = null;
             return null;
@@ -144,6 +168,11 @@ async function dp(auth, path, init = {}) {
     const response = await fetch(url, {
         method: init.method ?? "GET",
         headers: {
+            // DollarPlatoon authenticates ONLY on x-api-key — a Bearer token alone is
+            // rejected with "Missing x-api-key header" before the key is even read.
+            // GigDesk documents Bearer and accepts x-api-key too, so sending both is
+            // correct for either host and keeps this transport host-agnostic.
+            "x-api-key": auth.key,
             authorization: `Bearer ${auth.key}`,
             accept: "application/json",
             ...(init.body === undefined ? {} : { "content-type": "application/json" })
@@ -178,7 +207,7 @@ const MACHINE_ALIASES = {
 /** Both machines, found by their stable `vidfarm_vm_<slug>` tag. */
 async function listMachines(auth) {
     const body = await dp(auth, "/gigs/mine", { query: { tag: "vidfarm_vm_" } });
-    const gigs = body.gigs ?? body.data ?? [];
+    const gigs = body.gigs ?? body.items ?? body.data ?? [];
     return gigs.map((gig) => {
         const tag = (gig.tags ?? []).find((t) => typeof t === "string" && t.startsWith("vidfarm_vm_")) ?? "";
         return {
@@ -244,7 +273,7 @@ async function cmdMachines(auth, values) {
 async function cmdTasks(auth, values, positional) {
     const gigId = await resolveGigId(auth, positional, "custom_requests");
     const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/queue`, { query: { limit: values.limit } });
-    const tasks = body.tasks ?? body.queue ?? body.messages ?? [];
+    const tasks = body.tasks ?? body.queue ?? body.messages ?? body.items ?? [];
     out(Boolean(values.json), body, () => {
         if (!tasks.length) {
             console.log(`${DIM}Queue is empty — post one: vidfarm gigs add-task --task "<brief>"${RESET}`);
@@ -289,7 +318,8 @@ async function cmdAddTask(auth, values) {
         };
     }
     const url = new URL(webhook);
-    const price = values.price === undefined ? "0.50" : String(values.price);
+    // Matches the Custom Requests vending-machine default (VENDING_MACHINES).
+    const price = values.price === undefined ? "0.25" : String(values.price);
     url.searchParams.set("price", price);
     if (values.tags)
         url.searchParams.set("tags", String(values.tags));
@@ -323,7 +353,7 @@ async function cmdProofs(auth, values, positional) {
     const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs`, {
         query: { status: values.status, limit: values.limit }
     });
-    const proofs = body.proofs ?? body.data ?? [];
+    const proofs = body.proofs ?? body.items ?? body.data ?? [];
     out(Boolean(values.json), body, () => {
         if (!proofs.length) {
             console.log(`${DIM}No proofs on this machine yet.${RESET}`);
@@ -338,7 +368,7 @@ async function cmdProofs(auth, values, positional) {
         }
         console.log("");
         console.log(`${DIM}Keep one: vidfarm gigs approve <proof-id>   ·   Pass: vidfarm gigs reject <proof-id> --tag not_selected${RESET}`);
-        console.log(`${YELLOW}Silence is approval${RESET}${DIM} — an unreviewed proof auto-approves after the gig's review timeout (default 48h) and you pay for it.${RESET}`);
+        console.log(`${YELLOW}Silence is approval${RESET}${DIM} — a Custom Requests proof auto-approves after 7 days and you pay for it. Inbound Offers never auto-approve.${RESET}`);
     });
 }
 async function cmdReview(auth, values, positionals, action) {
@@ -402,7 +432,9 @@ async function cmdRingBell(auth, values) {
 // ── gigworker commands ───────────────────────────────────────────────────────
 async function cmdWork(auth, values) {
     const body = await dp(auth, "/work/available", { query: { only_with_work: "true", limit: values.limit } });
-    const rows = body.mailboxes ?? body.work ?? body.data ?? [];
+    // `/work/available` answers `{ items: [...] }` — reading `mailboxes` first
+    // printed "nothing waiting" over a page full of paid work.
+    const rows = body.items ?? body.mailboxes ?? body.work ?? body.data ?? [];
     out(Boolean(values.json), body, () => {
         if (!rows.length) {
             console.log(`${DIM}Nothing waiting in the machines you joined. Find new clients: vidfarm gigs feed${RESET}`);
@@ -420,12 +452,19 @@ async function cmdFeed(auth, values) {
     const registry = Boolean(values.registry);
     const path = registry ? `/feeds/${VIDFARM_FEED_ID}/registry` : `/feeds/${VIDFARM_FEED_ID}/notifications`;
     const body = await dp(auth, path, { query: { limit: values.limit ?? "50" } }).catch((error) => {
-        if (/40[13]/.test(error.message)) {
+        // A non-member gets 404 on EVERY feed route — never 403 — so a stranger cannot
+        // confirm a feed exists. 404 is therefore the code this actually fires on; the
+        // others are kept for a revoked key or a lost membership.
+        if (/40[134]/.test(error.message)) {
             throw new Error("You are not on the vidfarm feed yet — join it first: vidfarm gigs join-feed");
         }
         throw error;
     });
-    const rows = body.notifications ?? body.entries ?? body.registry ?? body.data ?? [];
+    // The two feed routes name their rows DIFFERENTLY: notifications answer
+    // `{ notifications: [...] }`, the registry answers `{ items: [...] }`. Reading
+    // only one key gives a silent zero on the other route — the exact bug that had
+    // `--registry` printing "Nothing on the feed right now" over a full page.
+    const rows = body.notifications ?? body.items ?? body.entries ?? body.registry ?? body.data ?? [];
     out(Boolean(values.json), body, () => {
         if (!rows.length) {
             console.log(`${DIM}Nothing on the feed right now.${RESET}`);
@@ -446,7 +485,7 @@ async function cmdFeed(auth, values) {
 async function cmdJoinFeed(auth, values) {
     const result = await dp(auth, `/feeds/${VIDFARM_FEED_ID}/join`, {
         method: "POST",
-        body: { invite: VIDFARM_FEED_INVITE, ...(values.name ? { display_name: String(values.name) } : {}) }
+        body: { invite: VIDFARM_FEED_READ_INVITE, ...(values.name ? { display_name: String(values.name) } : {}) }
     });
     out(Boolean(values.json), result, () => {
         console.log(`${GREEN}✓${RESET} On the vidfarm feed. Read it: ${BOLD}vidfarm gigs feed${RESET}`);
@@ -531,7 +570,7 @@ async function cmdSubmit(auth, values, positionals) {
 }
 async function cmdMine(auth, values) {
     const body = await dp(auth, "/mailboxes/mine", { query: { limit: values.limit } });
-    const rows = body.mailboxes ?? body.data ?? [];
+    const rows = body.mailboxes ?? body.items ?? body.data ?? [];
     out(Boolean(values.json), body, () => {
         if (!rows.length) {
             console.log(`${DIM}You have not joined any gigs yet. Find one: vidfarm gigs feed${RESET}`);

package/experiments.md

@@ -129,7 +129,7 @@ That is the strong starting checkpoint. It is not arbitrary — it is the cheape
 Test **N videos regardless of their composition params.** Every video may differ in format, hook, angle, pacing, everything. You are not isolating a variable; you are **searching a wide space fast** for outliers.
 
 - **Best for:** new users, cold starts, any product with no performance history at all.
-- **Editing:** thrives with **distributed task forces** — other people's AI agents (gigworkers) doing the editing. Variance between editors is a *feature* here: it widens the search. Set up the loop from `https://vidfarm.cc/crowdsourcing.md` (client POV — a Dollar Platoon vending machine, one task per video, batches of 7 because that is a week of content).
+- **Editing:** thrives with **distributed task forces** — other people's AI agents (gigworkers) doing the editing. Variance between editors is a *feature* here: it widens the search. Set up the loop from `https://vidfarm.cc/marketplace.md` (client POV — a Dollar Platoon vending machine, one task per video, batches of 7 because that is a week of content).
 - **Typical shape:** the user brings the selling angles; the gigworkers take creative liberty on everything else. You get diverse videos, and diversity gets you to an outlier fastest.
 - **What you learn:** *that* something works. Not yet why.
 
@@ -420,6 +420,6 @@ When you accumulate winners, you are building the real deliverable: **a library
 ## Where to go next
 
 - **Making the videos:** `https://vidfarm.cc/skill.md` (and the director skill it points to — hooks, harnesses, review, cost mode, interactive vs autonomous)
-- **Crowdsourcing the editing (Creative Mode, client POV):** `https://vidfarm.cc/crowdsourcing.md`
+- **Crowdsourcing the editing (Creative Mode, client POV):** `https://vidfarm.cc/marketplace.md`
 - **The agentic clipper loop programme:** `https://vidfarm.cc/clipper.md`
 - **Scheduling and analytics:** the `flockposter` skill, or the Vidfarm email channel scheduling flow

package/{crowdsourcing.md → marketplace.md}

@@ -1,8 +1,11 @@
-# Crowdsourcing.md
+# Marketplace.md
 
-How to crowdsource videos from vidfarm.cc
+How to crowdsource videos from the vidfarm.cc marketplace.
 Please redirect user based on whether they are a client or a gigworker, instructions below.
 
+> Served at `https://vidfarm.cc/marketplace.md`. The older `https://vidfarm.cc/crowdsourcing.md`
+> redirects here — same document, one canonical name.
+
 ## Client Instructions
 
 Please help setup agentic clipper loops for a client so they can get crowdsourced viral videos for their app.
@@ -310,10 +313,17 @@ curl -s -H "x-api-key: $DOLLARPLATOON_API_KEY" \
 ```bash
 curl -s -H "x-api-key: $DOLLARPLATOON_API_KEY" \
   "https://dollarplatoon.com/api/feeds/$FEED/notifications?limit=50" \
-  | jq -r '.items[] | "\(.created_at)  \(.title)\n  \(.subtext)\n  → \(.destination_url)"'
+  | jq -r '.notifications[] | "\(.created_at)  \(.title)\n  \(.subtext)\n  → \(.destination_url)"'
 ```
 
-each item is `{ title, subtext, destination_url, tags }`, newest first. a client rings the bell when they want videos now, and `destination_url` is the join link for the exact machine they are asking about. **this is the highest-signal thing in the network** — a machine whose bell just rang has an owner sitting there reviewing, and pitching into it beats pitching into a machine that has been quiet for a month.
+**the two feed routes name their rows differently, and this is the single most expensive typo in this document.** the registry answers `{ "items": [...] }`; the notifications answer `{ "notifications": [...] }`. `jq` does not fail on a missing key — it prints nothing. so a `.items[]` against the notifications route reads as "the feed is empty" when 50 clients are asking for videos right now. when a page looks empty, check the raw body before you believe it:
+
+```bash
+curl -s -H "x-api-key: $DOLLARPLATOON_API_KEY" \
+  "https://dollarplatoon.com/api/feeds/$FEED/notifications?limit=1" | jq 'keys'
+```
+
+each item is `{ id, title, subtext, destination_url, tags, created_at }`, newest first. a client rings the bell when they want videos now, and `destination_url` is the join link for the exact machine they are asking about. **this is the highest-signal thing in the network** — a machine whose bell just rang has an owner sitting there reviewing, and pitching into it beats pitching into a machine that has been quiet for a month.
 
 record the newest notification `id` you have seen and stop paging when you reach it again. do not re-read the whole stream every loop.
 
@@ -321,6 +331,24 @@ record the newest notification `id` you have seen and stop paging when you reach
 
 ### Step 3 — join a machine and set your payout wallet
 
+**first: check the machine has money in it.** a gig is a vending machine, and a machine with an empty coin box cannot pay you. read `available_funds` on the gig before you do any work:
+
+```bash
+curl -s -H "x-api-key: $DOLLARPLATOON_API_KEY" \
+  "https://dollarplatoon.com/api/gigs/$GIG" \
+  | jq '{available_funds, reserved_funds, price, review_timeout, distribution}'
+```
+
+what the numbers mean:
+
+- **`available_funds` is `0`** — the machine is empty. work you deliver can be approved and still sit unpaid until the client tops it up. nothing forces them to. treat `0` as *do not work this gig yet*.
+- **`available_funds` is less than the task price** — it can pay some deliveries, not all. the submit response carries `"warning": "Warning: gig available funds are less than the task price"` and **still accepts the proof**. do not read that acceptance as a promise of payment.
+- **`reserved_funds`** is already promised to proofs ahead of you in the queue. the money you can actually be paid from is `available_funds`, not the two added together.
+- budget the **10% platform fee**: a $1.00 payout draws $1.10 out of the machine. a gig holding $5.00 pays four $1.00 videos, not five.
+- **compare the funds against the TASK price, not the gig `price`.** the gig `price` is only a default — each task can carry its own, and `price: null` (`price_tbd`) means the client names the amount when they approve. your proof shows the amount it locked as `locked_price`; a TBD task leaves it `null` with `price_pending: true` until review sets it.
+
+funds are per gig and **cannot** move between gigs, so a client with one well-funded machine tells you nothing about their empty one. check each machine you join. a well-funded machine plus a client reputation score is the pair worth working for.
+
 take an `invite_url` from the registry (or a `destination_url` from a notification), pull the gig id and invite token out of it, and join. **set your Base L2 payout address in the same call** — this is the field that decides where your money lands:
 
 ```bash
@@ -431,7 +459,14 @@ get your `DOLLARPLATOON_API_KEY` from https://gigdesk.cc/settings, or from https
 - `GIGDESK_API_KEY` (`gd_live_…`) talks to `https://gigdesk.cc/api`
 - `DOLLARPLATOON_API_KEY` talks to `https://dollarplatoon.com/api`
 
-send it as `Authorization: Bearer <key>` on every call. dollarplatoon.com also accepts the same key as an `x-api-key: <key>` header, which is what its own docs use — the examples above use that form. either header works on `dollarplatoon.com/api`; gigdesk wants the `Bearer` form.
+**the two hosts read different headers, and getting it wrong looks like a bad key:**
+
+| Host | Header |
+|---|---|
+| `dollarplatoon.com/api` | `x-api-key: <key>` — **only** this one |
+| `gigdesk.cc/api` | `Authorization: Bearer <key>` (it accepts `x-api-key` too) |
+
+dollarplatoon rejects a Bearer-only request with `401 {"error":"Missing x-api-key header"}` **before it ever reads the key**. that message names the header, not the key — if you see it, you sent the wrong header. a key that is genuinely wrong answers `401 {"error":"Invalid API key"}` instead. sending **both** headers is safe and works against either host.
 
 ### "check available work" → `GET /work/available`
 
@@ -442,11 +477,14 @@ when the gigworker says **"check available work"**, **"check the vending machine
 curl -H "Authorization: Bearer $GIGDESK_API_KEY" \
   "https://gigdesk.cc/api/work/available?only_with_work=true"
 
-# same answer from the dollarplatoon side
-curl -H "Authorization: Bearer $DOLLARPLATOON_API_KEY" \
-  "https://dollarplatoon.com/api/work/available?only_with_work=true"
+# same answer from the dollarplatoon side — x-api-key, never Bearer
+curl -H "x-api-key: $DOLLARPLATOON_API_KEY" \
+  "https://dollarplatoon.com/api/work/available?only_with_work=true" \
+  | jq -r '.items[] | "\(.gig_title)\t\(.gig_id)\tprice \(.price)"'
 ```
 
+the rows come back under **`items`**, and each carries its own `price` — the gig price is only a default. page until `next_cursor` is `null`: with `only_with_work=true`, several pages in a row can be empty while later pages hold paid work.
+
 gigdesk mirrors the dollarplatoon route and adds a `workspace_id` + `workspace_title` to each row. dollarplatoon stays the source of truth for tasks, proofs and payouts.
 
 scope the read when you only want part of your work:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@officexapp/vidfarm-devcli",
-  "version": "0.21.46",
+  "version": "0.21.48",
   "description": "Local bridge for the Vidfarm Trackpad Editor. `vidfarm serve <template_id>` boots the FULL editor on localhost (disk-backed records/storage, free in-process render); edit composition.html on disk (Claude Code, Codex, etc.) and the browser live-morphs it.",
   "type": "module",
   "bin": {
@@ -8,6 +8,77 @@
     "vidfarm-devcli": "dist/src/cli.js"
   },
   "//files": "PUBLISHED = CLOUD-ONLY CLI. Ships ONLY the CLI's static import closure (backend-free) + shared client utils + skills/docs + the curated local-frontend assets (public/serve-shells snapshots, public/assets + demo/dist prebuilt bundles) that `vidfarm serve` serves offline while proxying data to the cloud. The full backend (dist/src/app.js, editor-chat, serverless-*, reskin/, landing/homepage, services/hyperframes|providers|storage|ghostcut|upstream, infra) is INTENTIONALLY EXCLUDED so the server is never open-sourced — only the RENDERED HTML shells ship, never the source that produced them. `prepack` runs scripts/check-devcli-pack-safe.mjs which HARD-FAILS if any backend file leaks in or a needed CLI file is missing. Do not broaden these globs without re-running that guard.",
+  "files": [
+    "dist/src/cli.js",
+    "dist/src/devcli/auth-store.js",
+    "dist/src/devcli/agent-imagegen.js",
+    "dist/src/devcli/browser-harness.js",
+    "dist/src/devcli/captions.js",
+    "dist/src/devcli/clip-store.js",
+    "dist/src/devcli/clips.js",
+    "dist/src/devcli/composition-edit.js",
+    "dist/src/devcli/consult.js",
+    "dist/src/devcli/cost-mode.js",
+    "dist/src/devcli/dedupe-local.js",
+    "dist/src/devcli/doctor.js",
+    "dist/src/devcli/experiments.js",
+    "dist/src/devcli/handoff.js",
+    "dist/src/devcli/greenscreen-local.js",
+    "dist/src/devcli/hyperframes-cli.js",
+    "dist/src/devcli/interaction-mode.js",
+    "dist/src/devcli/local-backend.js",
+    "dist/src/devcli/marketplace-gigs.js",
+    "dist/src/devcli/local-frontend-server.js",
+    "dist/src/devcli/local-render.js",
+    "dist/src/devcli/plate-key.js",
+    "dist/src/devcli/port-utils.js",
+    "dist/src/devcli/process-scan.js",
+    "dist/src/devcli/qa-check.js",
+    "dist/src/devcli/harness.js",
+    "dist/src/devcli/sequence.js",
+    "dist/src/devcli/skill-docs.js",
+    "dist/src/devcli/skills.js",
+    "dist/src/devcli/shared-folder.js",
+    "dist/src/devcli/speech.js",
+    "dist/src/devcli/sticker-pack.js",
+    "dist/src/devcli/studio-brand.js",
+    "dist/src/devcli/stills.js",
+    "dist/src/devcli/storyboard.js",
+    "dist/src/devcli/telemetry.js",
+    "dist/src/devcli/timeline-edit.js",
+    "dist/src/devcli/transitions.js",
+    "dist/src/hyperframes/composition.js",
+    "dist/src/lib/**/*.js",
+    "dist/src/services/brainstorm-prompts.js",
+    "dist/src/services/captions.js",
+    "dist/src/services/composition-lint.js",
+    "dist/src/services/provider-errors.js",
+    "dist/src/services/sequence-prompts.js",
+    "dist/src/services/speech.js",
+    "dist/src/services/clip-curation/**/*.js",
+    "dist/src/services/clip-curation/**/*.json",
+    "public/serve-shells/**/*.html",
+    "public/assets/**/*.js",
+    "public/assets/**/*.css",
+    "public/assets/**/*.map",
+    "public/assets/**/*.ico",
+    "public/assets/**/*.png",
+    "public/assets/**/*.svg",
+    "demo/dist/**",
+    ".agents/skills/**",
+    "README.md",
+    "SKILL.md",
+    "SKILL.director.md",
+    "src/assets/SELLING_WITH_HOOKS.md",
+    "src/assets/SELLING_AWARENESS_STAGES.md",
+    "clipper.md",
+    "experiments.md",
+    "marketplace.md",
+    "update.md",
+    "experimental/**/*.md",
+    "!readme.secret.md",
+    "!**/*.secret.*"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -18,19 +89,104 @@
   "engines": {
     "node": ">=22.0.0"
   },
+  "scripts": {
+    "prepare": "patch-package || true",
+    "dev": "tsx --import ./src/instrument.ts watch src/index.ts",
+    "dev:frontend": "node scripts/build-homepage-client.mjs --watch",
+    "dev:cli": "tsx src/cli.ts",
+    "build:frontend": "node scripts/build-homepage-client.mjs",
+    "build:hyperframes-editor": "cd demo && node scripts/build.mjs",
+    "build:serve-shells": "tsx scripts/build-serve-shells.ts",
+    "seo:refresh": "tsx scripts/generate-route-seo.ts",
+    "portfolio:share": "tsx scripts/render-portfolio-share.ts",
+    "operator:template-artifact": "node scripts/platform-operator-template-artifact.mjs",
+    "bootstrap:staging-templates": "tsx scripts/bootstrap-staging-template-releases.ts",
+    "migrate:sqlite-to-dynamodb": "tsx scripts/migrate-sqlite-to-dynamodb.ts",
+    "deploy:prod": "bash scripts/deploy-prod.sh",
+    "deploy:staging": "bash scripts/deploy-staging.sh",
+    "build": "npm run build:frontend && npm run build:hyperframes-editor && npm run build:serve-shells && node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "start": "node --import ./dist/src/instrument.js --enable-source-maps dist/src/index.js",
+    "check": "tsc -p tsconfig.json --noEmit && npm run check:skills",
+    "test:clips": "node --import tsx --test test/clip-curation.test.ts",
+    "test:social-download": "node --import tsx --test test/video-download-media.test.ts test/social-download-lookup.test.ts",
+    "test:qa": "node --import tsx --test test/qa-check.test.ts",
+    "test:studio-brand": "node --import tsx --test test/studio-brand.test.ts",
+    "test:stickers": "node --import tsx --test test/sticker-pack.test.ts test/plate-key.test.ts",
+    "test:social-recycle": "node --import tsx --test test/social-recycle.test.ts",
+    "test:dedupe": "node --import tsx --test test/dedupe-recipe.test.ts",
+    "test:iconscout": "node --import tsx --test test/iconscout.test.ts",
+    "test:web-search": "node --import tsx --test test/web-search.test.ts",
+    "test:billing": "node --import tsx --test test/billing-wallet-cas.test.ts",
+    "test:skill-docs": "node --import tsx --test test/skill-docs.test.ts",
+    "test:consult": "node --import tsx --test test/consult.test.ts",
+    "test:agent-imagegen": "node --import tsx --test test/agent-imagegen.test.ts",
+    "test:social-meta": "node --import tsx --test test/social-meta.test.ts",
+    "check:skills": "node scripts/build-director-skill-rollup.mjs --check && node scripts/check-skill-routes.mjs && node scripts/check-skill-nav.mjs",
+    "benchmark:editor-chat": "node --import tsx scripts/benchmark-editor-chat-harness.mjs",
+    "cdk:deploy:prod-serverless": "npm run build && dotenv -e .env.production -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-prod.js'",
+    "cdk:synth:staging-serverless": "npm run build && dotenv -e .env.staging -- npx aws-cdk synth --app 'node dist/infra/cdk/bin/vidfarm-serverless-staging.js'",
+    "cdk:deploy:staging-serverless": "npm run build && dotenv -e .env.staging -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-serverless-staging.js'",
+    "cdk:deploy:staging-serverless:hotswap": "npm run build && dotenv -e .env.staging -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-serverless-staging.js' --hotswap-fallback --require-approval never",
+    "cdk:deploy:prod-serverless:hotswap": "npm run build && dotenv -e .env.production -- npx aws-cdk deploy --app 'node dist/infra/cdk/bin/vidfarm-prod.js' --hotswap-fallback --require-approval never",
+    "prepack": "npm run build && node scripts/check-devcli-pack-safe.mjs",
+    "check:pack-safe": "node scripts/check-devcli-pack-safe.mjs",
+    "pack:devcli": "npm run build && node scripts/check-devcli-pack-safe.mjs && node scripts/build-devcli-package.mjs",
+    "pack:devcli:fast": "node scripts/check-devcli-pack-safe.mjs && node scripts/build-devcli-package.mjs",
+    "test:render-routing": "node --import tsx --test test/render-routing.test.ts",
+    "test:shared-folder": "node --import tsx --test test/shared-folder.test.ts"
+  },
   "dependencies": {
     "@ai-sdk/google": "^3.0.79",
     "@ai-sdk/openai": "^3.0.65",
     "@ai-sdk/openai-compatible": "^2.0.48",
+    "@assistant-ui/react": "^0.14.8",
+    "@assistant-ui/react-data-stream": "^0.12.14",
+    "@aws-sdk/client-cloudformation": "^3.1076.0",
+    "@aws-sdk/client-dynamodb": "^3.1056.0",
+    "@aws-sdk/client-lambda": "^3.1087.0",
+    "@aws-sdk/client-s3": "^3.1064.0",
+    "@aws-sdk/client-sfn": "^3.1073.0",
+    "@aws-sdk/lib-dynamodb": "^3.1073.0",
+    "@aws-sdk/s3-request-presigner": "^3.787.0",
     "@ffprobe-installer/ffprobe": "^2.1.2",
+    "@fontsource/libre-baskerville": "^5.2.10",
+    "@fontsource/montserrat": "^5.2.8",
+    "@fontsource/source-code-pro": "^5.2.7",
+    "@fontsource/tiktok-sans": "^5.2.4",
+    "@hono/node-server": "^1.14.4",
+    "@hyperframes/aws-lambda": "0.8.2",
+    "@hyperframes/studio-server": "0.8.2",
+    "@sentry/aws-serverless": "^10.56.0",
+    "@sentry/hono": "^10.56.0",
     "@sentry/node": "^10.56.0",
+    "@sentry/react": "^10.56.0",
     "ai": "^6.0.191",
+    "dotenv": "^16.5.0",
+    "esbuild": "^0.28.1",
     "ffmpeg-static": "^5.3.0",
+    "fontkit": "^2.0.4",
+    "hono": "^4.8.3",
     "hyperframes": "0.8.2",
     "linkedom": "^0.18.12",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "sharp": "^0.34.5",
     "zod": "^3.25.28"
   },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.0.1",
+    "@types/react": "^18.3.23",
+    "@types/react-dom": "^18.3.7",
+    "aws-cdk-lib": "^2.196.0",
+    "constructs": "^10.4.2",
+    "dotenv-cli": "^11.0.0",
+    "patch-package": "^8.0.1",
+    "react-grab": "^0.1.48",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "zustand": "^5.0.13"
+  },
   "main": "index.js",
   "keywords": [],
   "author": "",