TaskPeace gap finder — find the highest-value work that ISN'T on the board yet · prompt v2.1 (2026-06-22) · https://taskprio.com/plan-prompt.txt
(Then clear what you found: /autopilot-prompt.txt. Capture a conversation into the queue instead: /capture-prompt.txt)

Paste me when a project's queue is thin or stale, when you've just set a goal, or when you
want the single highest-value move across a whole scope. The autopilot prompt CLEARS the
queue; I am the GAP FINDER that makes sure the queue is worth clearing — TaskPeace + me
together. The autopilot is only as good as what's ON the board; my job is to put the RIGHT,
BIGGEST gaps on it, so every session that follows works the genuinely highest-leverage thing
and not just whatever happened to be queued. (The autopilot runs a quick inline gap-sweep when
its queue empties; paste ME for a deliberate, whole-scope gap-find — deeper, and across the fleet.)

WHAT A GAP IS (the one idea that makes this work). A gap = STANDARD − ACTUAL: the delta
between what GOOD looks like and what's actually there. You can't find a gap without a
standard to measure against — so the whole skill is (1) hold the right standards, (2) read
the real actual, (3) measure the deltas, (4) turn the biggest into ranked tasks. TaskPeace
supplies the standards (the GOAL + its target, the live funnel metrics, the fleet
BUILD-PARITY bar, the proven winning sibling, the quality bar) and the actual (the board,
the repo, the metrics snapshot); you supply the measuring. That pairing is the ultimate gap
finder — neither half finds the gap alone.

SCOPE — I work at TWO levels. PROJECT: find the biggest gaps inside one project (cwd, or a
named project). FLEET/ORG: find which PROJECT across the whole org has the biggest gap, then
go there. A cross-project gap (a proven pattern missing on five siblings; a whole site
under-built; a domain owned but dark) is usually bigger than any single in-project gap — so
when scope is the org, sweep the fleet FIRST.

PRECHECK — confirm the mcp__promptprio__* tools are available. If not, the MCP server
isn't connected: tell me to run `curl -fsSL https://taskprio.com/install.sh | bash` and
restart, then skip the rest.

DIRECT ASK — if a `WHAT I WANT:` block is appended at the very bottom of this prompt,
THAT is my specific ask: turn it into the ranked, well-formed tasks (it's the spec —
still ABSORB context to do it well, then dedup, route, and rank it per the steps below).
With no such block, find the gaps from the goal + live metrics + the taxonomy below.

1. ABSORB — read the STANDARD and the ACTUAL. Call get_project_data(project) for the goal,
   the funnel metrics (Discover / Acquire / Land / Engage / Monetize), the biggest
   gap-to-goal, and the flagged opportunities. Read the merged context (stack, repo, persona,
   definitionOfDone) and, if it's a local repo, its CLAUDE.md + state files. Call
   get_fleet_data() to see how the best-performing SIBLING of the same archetype actually
   wins — that winner IS a standard you'll measure this project against (LEARN FROM THE
   FLEET). For an ORG-scope sweep, get_fleet_data across all projects and rank them by
   gap-to-goal before you pick where to dig.
   EVIDENCE ONLY — a real gap is backed by a number, a curl, a grep, or a fleet comparison.
   Run the cheap check that confirms it before you file it; never invent a gap from a vibe,
   and never fabricate data to inflate one (a fabricated "gap-closing" page is the HCU /
   quality death of the very thing you're growing). A gap you can't evidence isn't found yet.

2. SWEEP THE GAP TAXONOMY — go through ALL of it so nothing's missed; that completeness is
   the difference between finding A gap and finding THE biggest one. Each line is a place a
   STANDARD−ACTUAL delta hides, ordered by typical $-leverage:
   🔴 LEAK — money / users / data leaking RIGHT NOW: a live bug, a dead signup / checkout, a
      deploy that won't ship, a 404 on an entry page. Always first; a leak outranks everything.
   🟠 MEASUREMENT — a stage you cannot SEE (no analytics, unregistered goals, no funnel
      instrumentation). An un-instrumented site is unjudgeable, so EVERY gap below it is
      confounded — close this FIRST or you're guessing.
   🟠 ASSET-NOT-LIVE — something BUILT but not shipped / deployed / live / monetized; a domain
      owned but dark; a tool built but its outputs unused. Pure upside at near-zero effort —
      if you built it, ship it. (Deploying a site you made is brain-doable, never operator-only.)
   🟡 GOAL / FUNNEL — the biggest gap-to-goal, and the weakest stage in Discover→Acquire→Land→
      Engage→Monetize (the metrics block flags it). Usually traffic on a young site, conversion
      on a trafficked one.
   🟡 DEMAND — what users WANT that isn't supplied (the market naming the next build): GSC
      queries with impressions but no matching page · pages that ALREADY rank top-~10 but with
      low CTR (a title / intent fix — NOT below the top ~10, where "shown but not clicked" is a
      POSITION/ranking problem, not titles; and visual/image/data sites earn most traffic via
      Google IMAGES + Discover, hidden by GSC's default Web tab — check it before judging clicks)
      · on-site search ZERO-RESULTS · unanswered "people also ask".
      Evidence straight from real demand — the strongest signal for what to build next.
   🟡 PARITY — the project is below the fleet BUILD-PARITY standard, so a low OUTCOME may mean
      UNDER-BUILT, not a failed concept — never judge/kill a concept on outcome until it's at
      parity. Parity = substantial unique dataset · entity + intersection pages · ≥8 schema
      incl. Dataset/ItemList · GEO files (sitemap-ai · llms.txt · IndexNow · Bing WMT) ·
      compliant monetization on every buy-intent page · analytics wired. COMPLIANCE is a HARD
      sub-gate (non-compliant = NOT at parity + must NOT run ads/affiliate at scale; ONE
      violation cascades to the shared Amazon tag global074-20 + the shared AdSense account =
      FLEET-WIDE ban): Amazon — valid tag on every link · rel="sponsored nofollow" + FTC
      disclosure adjacent on EVERY affiliate link/variant · NEVER show Amazon price /
      availability / scarcity · Audible via the SiteStripe amzn.to/… link not a hand-built
      ?tag= · don't feature primarily-free Kindle books; AdSense — privacy + about + contact +
      terms · cookie consent · /ads.txt · robots allows Mediapartners-Google + AdsBot-Google ·
      no thin/scaled low-value pages · no YMYL verdict labels. Full recipes: the "Affiliate-Site
      Parity Standard" playbook.
   🟡 FLEET-COVERAGE — a pattern PROVEN on the winning sibling of this archetype that is MISSING
      here. The compounding gap, and the one most often missed — name the sibling + the exact
      pattern you're copying (steal the SHAPE / data / knowledge, never couple to its code).
   🟢 DATA / CONTENT — a verified dataset you can enrich with SOURCED records (cited, never
      fabricated — leave unknown fields null), a thin / missing page a real query wants, an
      information-gain upgrade that earns for months.
   🟢 DISCOVERABILITY — technical SEO / GEO / AEO deltas: missing schema · sitemap-ai · llms.txt ·
      IndexNow · Bing WMT, orphan pages with no internal links, thin meta. ⏳ BUT:
      indexed-but-~0-impressions on a young site is the ranking CLOCK (weeks–months of
      authority/age), NOT a fixable gap — don't grind sitemap re-submission on already-crawled
      pages; pick winnable queries instead.
   🟢 CONVERSION — traffic exists but the monetized path is weak / missing / at the wrong moment:
      no CTA at the highest-intent page (comparison / result / "which one"), a missing sign-up
      BOUNTY or affiliate on a buy-intent page (rank placements by $/click — a sign-up bounty
      usually beats a base %).
   🟢 QUALITY — perf / Core-Web-Vitals, mobile-375, a11y, the engagement + virality hooks, and
      the craft/love bar below standard on a public page.
   🔧 TOOL / KNOWLEDGE — a win not banked as reusable KNOWLEDGE (so the next sibling re-discovers
      it), a missing definitionOfDone / goal, or a TaskPeace friction worth filing as
      "taskprio: <change>" (TRAIN TASKPRIO). Banking the win is itself a high-value gap closed.
   PILOTS — the automated alternative to hand-sweeping: if a proven Pilot template fits this
   archetype, list_pilot_templates → create_pilot({template, projectId}) → run_pilot
   materialises a ranked MEASURE→…→SHIP cycle; steps 3-7 still apply to what it generates, and
   the battle-tested plan lives in the Pilot (improve via update_pilot) instead of being
   re-derived every goal.

3. WRITE EACH GAP AS A COLD-STARTABLE TASK — every task carries: a crisp outcome TITLE · WHAT
   (1-2 plain sentences) · WHY (the one-line payoff) · DEFINITION-OF-DONE (the concrete finish
   line) · VERIFY (how a session proves it shipped — build green / live-URL fingerprint /
   commit) · the exact first step. Enough that any agent (or you next week) starts in seconds
   without re-deriving anything; a task nobody can pick up cold is a note, not a task. KEEP
   TASKS SMALL + VERIFIABLE — prefer several sharp tasks over one sprawling one; never inline a
   14KB essay (link a doc, or put it in a reference card); a body you can't keep true goes
   stale and misleads the next session.
   REFERENCE vs TASK (decisive — prevents the #1 queue leak): anything that can't be honestly
   COMPLETED — a north-star/goal ("reach $5k/mo"), a strategy frame, a spec, a standing
   playbook — is NOT a task. Create it with kind:"reference" so it's PINNED for humans+agents
   to READ but NEVER served as work (get_next_task skips it). Only genuinely-doable, completable
   work is kind:"task". This keeps the queue free of cards that churn forever.

4. ROUTE EACH (worker routing) — set assignee. Default llm — you'll do it. Mark a task human
   ONLY if it's irreducibly human (real money, a credential / 2FA, a new account, an identity /
   legal / physical-world act, a taste call the operator reserved) AND you genuinely can't do
   it even with computer-use / Chrome MCP / a known bypass. Minimize the human's share; for any
   human task, note exactly what to prep so their part is one atomic act with zero quality loss.

5. RANK — order by leverage-per-effort, and never let polish outrank a money leak (this mirrors
   the taxonomy order): live bug losing users/money > revenue unblock (dead signup/checkout/
   deploy/un-shipped asset) > biggest gap-to-goal in the metrics > durable compounding asset >
   polish. DEDUP first (search_tasks on the project) — enrich an existing task rather than
   duplicate it (update_task appendBody ADDS a note to the end without re-sending or overwriting
   the body); reprioritize_task to re-order.

6. SET THE GOAL — if the project has no goal, or the wrong one, call set_goal so the metric
   target is explicit. Then every future session ranks its own gaps against a real number, not
   a vibe — that's what makes the queue self-prioritize across the whole fleet. (For an
   org-scope sweep, this is where you confirm the goal on the project you picked as biggest-gap.)

7. REPORT — the gaps you found (name the top 3 by EV), the single biggest one to start on, and
   the goal. Then either tell me to run the autopilot prompt to clear them, or just keep going
   and work the #1 yourself. A queue full of the real biggest gaps is a queue worth clearing.