feat(board): Board Programs — the complete twelve-program catalog (Phases 1-3) (#699)

* feat(board): Pest Control — the first project-scoped Board Program

The Product Owner hunts latent defects (what the org records but nobody
reads): a weekly cycle — accelerated off-schedule when the trailing-7-day
rework rate crosses pest_rework_threshold, with the cheap dedup/scope gates
evaluated before the metrics queries — opens one held exploration task
against the least-recently-explored opted-in project (deterministic
round-robin; opted_in_projects gains a stable ORDER BY), with server-
assembled evidence in the spawn prompt (rework hotspots, recurring-findings
and waived-minor ledger aggregates, all capped) plus prior-cycle LEARN
context. The PO calls the new PO-only propose_bug_hunt verb once: ≤5 items,
evidence required per item, targets validated against pest_control
participation. CEO decides per item — approve materializes a BACKLOG task
(source pest_control, never auto-starts), reject records the reason; both
feed the LEARN ledger by exploration task id; all-terminal completes the
cycle. Telegram queue pushes carry working Approve/Reject handlers
mirroring the roadmap kind. Doctrine: board.md Pest Control section +
product-owner verb entry + regenerated verb tables.

* feat(panel): Pest Control review queue

Command Center gains the pest review queue (per-item approve/reject with
reason, mirroring the roadmap queue); the Programs card and the project
settings participates-in checkboxes pick the new program up registry-driven
— the settings section renders for the first time now that a project-scoped
program exists.

* feat(board): Periscope — HoM market-research brief program

Weekly org-scoped cycle: a solo HoM spawn researches the market (web
research with mandatory source URLs — uncited findings are rejected) and
files one structured brief via the new HoM-only propose_market_brief verb:
headline, cited findings, threats/opportunities, positioning note, all
soup-checked and screened through the injection guard at persist time
(web-derived text later reaches prompts; flags recorded, content never
dropped). A brief is a report, not a proposal: the verb completes the
exploration in the same call (the x_feature asymmetry), the cycle ledger
auto-closes, and the CEO gets a best-effort notification with no
approve/reject surface (periscope deliberately never joins Telegram's
action kinds). The latest brief is injected into the roadmap exploration
prompt — Periscope feeds Printer, the first cross-role program input.

* feat(panel): Market Briefs tab (read-only)

Business page gains a Market Briefs tab listing Periscope briefs —
headline, cited findings, threats/opportunities — read-only by design; a
report has nothing to approve.

* feat(board): Coroner — event-triggered Auditor postmortems

The first EVENT program: no cron — three best-effort hooks open an autopsy
when a task bounces to its 3rd revision (the audit chokepoint), is
cancelled after work started, or is budget-blocked; all gated on arming +
one-open-autopsy dedup, none can fail the underlying transition. A solo
Auditor spawn reads the incident (server-assembled findings + transition
context) and files one propose_postmortem: incident summary, root cause,
failed stage (validated against the real status vocabulary), and ONE
process change — a playbook-kind change drafts via PlaybookService
directly into the normal pending-curation queue; the briefed draft_playbook
manifest grant was deliberately NOT added, preserving the existing
'auditor curates but never drafts' invariant test. Complete-at-propose
(report asymmetry), cycle ledger auto-closes, CEO notified link-only.
Integrated as a union with Periscope across the shared program surfaces.

* feat(panel): Coroner postmortems card

Read-only postmortems list under Business → Programs — incident, root
cause, failed stage, process change; nothing to approve, the process-change
artifact (a draft playbook) rides the existing curation queue.

* feat(board): Sentinel — Auditor drift-watch quality reports

Weekly org-scoped cycle: a solo Auditor spawn receives a server-assembled
drift context (waived-findings trend, open findings by severity,
conventions-violation hotspots, top spend — all capped, pure ORM) and files
one propose_quality_report: headline, 1-7 area-validated items with
evidence and suggested actions, overall assessment. Report semantics —
complete-at-propose, cycle auto-closes, CEO notified display-only (never on
Telegram's approve/reject surface); items are structured so a later
convert-to-task control is cheap. Integration adopts Sentinel's module-
level dict-dispatch for board-program routing (xenon-driven), folding all
prior programs in; app router mounting extracted to a helper for the same
budget.

* feat(panel): Quality Reports tab (read-only)

Business page gains the Sentinel quality-reports tab — headline, per-area
observations with evidence and suggested actions; read-only, a report has
nothing to approve.

* feat(board): Spackle — gap-fill audit program

Biweekly project-scoped PO cycle over the half-shipped surface area: API
routes without panel surfaces (and vice versa), armed flags without docs,
docs promises the code doesn't keep, dead-end tabs — the inventory diffing
is the PO's own read-tool work, ordered by the spawn prompt with file:line
citations required; the server injects only prior-cycle LEARN and the
rotation target. Rotation is now a shared module-level helper
(pick_rotation_target, parameterized by source) both project-scoped
engines use — pest_control delegates to it, behavior-identical, with a
cross-pollution test proving the two programs' rotations stay independent.
propose_gap_fill mirrors the bug-hunt verb (≤5 items, two-sided evidence
required, participation gate); per-item CEO decide materializes BACKLOG
source=spackle tasks; full Telegram kind incl. approve/reject handlers.
All seven program routers now mount from one helper.

* feat(panel): Spackle gap-fill review queue

Command Center gains the gap-fill queue mirroring the pest-control one —
per-item approve/reject with the two-sided gap evidence rendered.

* feat(board): Scales — monthly portfolio rebalance

Org-scoped PO cycle over the stale backlog: the spawn receives a capped
stale-task snapshot (BACKLOG/PENDING unclaimed >30 days) plus the charter
and prior-cycle LEARN, and files one propose_rebalance — 1-7 items, each a
resolvable task_ref with action reprioritize (validated new priority) or
cancel, rationale required. Per-item CEO decide: approve EXECUTES the
action (audited priority update, or the normal cancel path) — the first
program whose materializer mutates existing tasks instead of creating
them; reject records the reason; LEARN by exploration task id;
all-terminal completes the cycle. Full Telegram decide-kind wiring.
Integrated as the eight-program union (registry, dict dispatch, routers
helper, teardown enumerations).

* feat(panel): Scales rebalance review queue

Command Center gains the rebalance queue — per-item approve/reject with
the action, target task, and rationale rendered.

* feat(board): Mirror — quarterly positioning audit

Project-scoped HoM cycle over messaging surfaces: README claims vs shipped
reality, docs-site promises vs code, charter alignment — the audit is the
HoM's own read-tool work with citations required; the server injects the
charter, prior-cycle LEARN, and the shared rotation target. propose_
messaging_fixes mirrors the gap-fill verb (≤5 items, drift evidence naming
claim + contradicting reality, participation gate); per-item CEO decide
materializes BACKLOG source=mirror documentation tasks; full Telegram
decide-kind wiring. Nine-program union across the shared surfaces.

* feat(panel): Mirror messaging-fixes review queue

* feat(board): Megaphone — HoM standing editorial calendar

Cron cycle (3 days, org-scoped, gated on X credentials — drafting content
nobody can post is pointless): the HoM receives a shipped-this-week digest
plus Unreleased changelog bullets and files one propose_editorial_post
(angle-validated, ≤280, brand voice) that materializes a held x_editorial
draft through the SAME X-queue origination chokepoint release posts use —
zero new approval surface, notifications and CEO decide for free.
Complete-at-propose; cycle auto-closes. Ten-program union.

* feat(panel): x_editorial source labels in the X queue surfaces

* feat(board): Librarian — proactive playbook mining

Biweekly org-scoped Auditor cycle: mines recurring non-private learning
journals (≥2-count grouping with a recency fallback) against the existing
playbook-title inventory and files one propose_playbook_drafts — 1-3
drafts, each with the repeated-pattern evidence that justifies it,
duplicate titles rejected in-batch and against the live store. Drafts are
created via PlaybookService directly (the Coroner precedent — the
'auditor curates but never drafts' do-verb invariant stays intact and
tested) and land in the normal pending-curation queue the Auditor's own
triage already surfaces; no new panel surface. Complete-at-propose;
display-only CEO notification. Eleven-program union.

* feat(board): War Room — release campaign planning

EVENT program with a REAL originator (unlike coroner's stub): a release
publish hooks a campaign brief beside the release-post seam, and the CEO's
run-now originates on demand — the cron loop never fires it. The HoM
designs a 2-6 post arc (teaser → launch → follow-up → spotlight; 280-cap,
future strictly-ascending publish_after, stage vocabulary) and one
propose_campaign call materializes each post as a held x_campaign draft
through the X-queue chokepoint. V1 is manual-cadence by design: publish_
after renders as queue guidance and the CEO approves each post at its
moment — nothing auto-posts, ever; the auto-schedule upgrade is a
documented ceiling. Twelve-program union: full registry complete.

* feat(panel): x_campaign labels + publish-after guidance in the X queue

* feat(board): Barfly — adjacent-conversation replies

Cron cycle (2 days, org-scoped, X-credentials gated): the engine searches
X for conversations where RoboCo is relevant but unmentioned (new OAuth-
signed search_recent on the client; queries + candidate cap configurable),
screens every fetched tweet through the injection guard (stored unclamped
— a clamp was truncating the candidate under the envelope, caught by the
dev's own tests), dedupes via the existing x_seen_mentions ledger (no
migration; also prevents double-drafting against the mentions poll), and
opens one held HoM exploration carrying the screened candidates. propose_
conversation_replies enforces candidate-id-only replies (≤5, 280-cap);
each materializes a held x_barfly draft through the X-queue chokepoint,
threaded via a new in_reply_to seam on post_tweet that only x_barfly
drafts use. The X redraft machinery is now dict-dispatch over per-source
extractors with reply-ref carry for x_barfly. Thirteen-program registry.
War Room's test fakes gained the new abstract search_recent stub.

* feat(board): Dogfood — the PO walks the product

The fourteenth and final registry entry, completing the catalog. EVENT
program (release-publish hook beside the war-room hook + CEO run-now, both
through the same real originator; the cron loop never fires it), project-
scoped with shared rotation. The permission surface is the careful part:
the PO's dogfood spawn — and ONLY that spawn — gets the Playwright MCP
mounted, via a task-scoped fail-closed probe mirroring the video-authoring
precedent (a PO spawned for roadmap/pest/scales never sees browser tools;
tested both ways); the PM agent image bakes chromium unconditionally like
the ux image, the mount stays task-gated in code. The walk targets the
rotation target's live surfaces (panel_base_url only when the target is
the org's own project, honest degradation otherwise); propose_friction_
fixes files ≤5 walked-path-evidenced items; per-item CEO decide
materializes BACKLOG source=dogfood tasks; full Telegram decide kind.
Also: megaphone/librarian/war_room arming keys restored to the settings
validator — their panel toggles would have been rejected (dropped in
earlier unions; the same silent-arming class the drill killed once
already).

* feat(panel): Dogfood friction review queue

* chore(board): final whole-branch sweep fixes

The night's closing adversarial pass over the integrated fourteen-program
registry found ONE functional defect — the war-room test fakes' post_tweet
predated Barfly's in_reply_to_tweet_id kwarg (LSP violation, the only red
in an otherwise fully green gate) — plus doc/test drift, all fixed: the
source-parity test completes to fourteen (spackle/mirror were silently
absent while its neighboring comment claimed full coverage), the PO
identity doc gains its missing Dogfood verb, the auditor quick-list gains
propose_postmortem, three stale comments corrected (rotation docstring,
panel registry header, X source enumerations), the dogfood release-hook
gains the exception-swallow test its four sibling hooks already had, and
the CHANGELOG's Unreleased section documents the whole Board Programs
train. Full make quality: exit 0, all gates green.

* docs: full documentation sweep for the Board Programs train

CLAUDE.md's roadmap-engine entry superseded by the Board Program registry
entry (all fourteen programs, arming, scoping, LEARN, guardrails) with the
role verb tables and playwright row refreshed; docs/rag gains the agent-
facing architecture doc plus full propose_* call-shape sections in the
three board role docs, and corrects the strategy-engine section to shipped
reality (only idle→roadmap is wired); docs/map covers the registry + all
twelve engines with flags, gotchas, and drift notes. The 0.27.0 reference
inventory confirmed only the release-executor's canonical set carries the
version — left for the 0.28.0 cut.

* feat(board): human titles + descriptions on every program surface

Raw registry keys rendered as bare panel labels — an operator reading
x_feature had no idea what enabling or running it does. The registry
dataclass gains title/description (test-enforced non-empty for every
entry, unique titles), the API passes them through, and every surface
renders title-with-description-tooltip instead of the key: the Programs
card (label, toggle hint, run-now toast), and the project settings
participates-in/excluded-from checkboxes.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>

roboco/mcp/do_server.py

@@ -589,6 +589,107 @@ def propose_roadmap(cycle_goal: str, items: list[dict[str, Any]]) -> dict[str, A
     )
 
 
+def propose_bug_hunt(items: list[dict[str, Any]]) -> dict[str, Any]:
+    """Product Owner: propose a Pest Control bug hunt (1-5 evidence-backed items).
+
+    Call this exactly ONCE per exploration cycle, after hunting through the
+    findings ledger, rework hotspots (revision_count), and TODO/ponytail debt
+    for latent defects the org records but nobody reads. The CEO reviews and
+    approves/rejects each item individually; approved items land in the
+    backlog (nothing auto-starts).
+
+    Args:
+        items: 1-5 drafts, each a dict with: title, description,
+            acceptance_criteria (list[str]), project_slug, team
+            ('backend'|'frontend'|'ux_ui'), priority (int, default 2),
+            evidence (REQUIRED — the file:line / ledger row / metric that
+            justifies this as a real, live bug; no evidence, no item).
+    """
+    return _post("/api/v1/do/propose_bug_hunt", {"items": items})
+
+
+def propose_gap_fill(items: list[dict[str, Any]]) -> dict[str, Any]:
+    """Product Owner: propose a Spackle gap-fill audit (1-5 evidence-backed items).
+
+    Call this exactly ONCE per exploration cycle, after auditing half-shipped
+    surface area in the target project: API routes with no panel surface (and
+    vice versa), armed flags with no docs, docs promises the code doesn't
+    keep, coverage holes by module, dead-end panel tabs. The CEO reviews and
+    approves/rejects each item individually; approved items land in the
+    backlog (nothing auto-starts).
+
+    Args:
+        items: 1-5 drafts, each a dict with: title, description,
+            acceptance_criteria (list[str]), project_slug, team
+            ('backend'|'frontend'|'ux_ui'), priority (int, default 2),
+            evidence (REQUIRED — must name BOTH sides of the gap, e.g. the
+            route that exists and the panel surface that doesn't; no
+            evidence, no item).
+    """
+    return _post("/api/v1/do/propose_gap_fill", {"items": items})
+
+
+def propose_rebalance(items: list[dict[str, Any]]) -> dict[str, Any]:
+    """Product Owner: propose a Scales portfolio-rebalance plan (1-7 items).
+
+    Call this exactly ONCE per exploration cycle, after reviewing the
+    server-assembled stale-backlog snapshot against the company charter.
+    Each item re-prioritizes or cancels ONE live BACKLOG/PENDING task — this
+    never drafts a new task. The CEO reviews and approves/rejects each item
+    individually; approval MUTATES the target task in place (nothing here
+    changes anything itself).
+
+    Args:
+        items: 1-7 dicts, each with: task_ref (the id8 or exact title of the
+            live task this item targets), action ('reprioritize' or
+            'cancel'), new_priority (int 0-3, REQUIRED iff action is
+            'reprioritize' — 0 is P0/highest, 3 is P3/lowest), rationale
+            (REQUIRED — why this task should be re-prioritized or cancelled).
+    """
+    return _post("/api/v1/do/propose_rebalance", {"items": items})
+
+
+def propose_messaging_fixes(items: list[dict[str, Any]]) -> dict[str, Any]:
+    """Head of Marketing: propose a Mirror positioning audit (1-5
+    evidence-backed items).
+
+    Call this exactly ONCE per exploration cycle, after auditing the target
+    project's messaging surfaces (README, docs-site, website) against the
+    charter and shipped reality: claims the copy makes that the code doesn't
+    back, and shipped capabilities the copy doesn't mention. The CEO reviews
+    and approves/rejects each item individually; approved items land in the
+    backlog as docs tasks (nothing auto-starts).
+
+    Args:
+        items: 1-5 drafts, each a dict with: title, description,
+            acceptance_criteria (list[str]), project_slug, team
+            ('backend'|'frontend'|'ux_ui'), priority (int, default 2),
+            evidence (REQUIRED — must name the drifted claim AND the reality
+            it contradicts; no evidence, no item).
+    """
+    return _post("/api/v1/do/propose_messaging_fixes", {"items": items})
+
+
+def propose_friction_fixes(items: list[dict[str, Any]]) -> dict[str, Any]:
+    """Product Owner: propose a Dogfood friction audit (1-5 evidence-backed items).
+
+    Call this exactly ONCE per exploration cycle, after walking the target
+    project's live surfaces as a real user would (the panel via Playwright,
+    the docs site, the Telegram flow when reachable) and filing what broke or
+    felt wrong. The CEO reviews and approves/rejects each item individually;
+    approved items land in the backlog (nothing auto-starts).
+
+    Args:
+        items: 1-5 drafts, each a dict with: title, description,
+            acceptance_criteria (list[str]), project_slug, team
+            ('backend'|'frontend'|'ux_ui'), priority (int, default 2),
+            evidence (REQUIRED — the walked path, the actual clicks/pages,
+            and what broke or felt wrong; prose only, no screenshots; no
+            evidence, no item).
+    """
+    return _post("/api/v1/do/propose_friction_fixes", {"items": items})
+
+
 def propose_feature_spotlight(
     feature_slug: str = "",
     feature_title: str = "",
@@ -642,6 +743,201 @@ def propose_feature_spotlight(
     )
 
 
+def propose_market_brief(
+    headline: str,
+    findings: list[dict[str, Any]],
+    threats: list[str] | None = None,
+    opportunities: list[str] | None = None,
+    positioning_note: str = "",
+) -> dict[str, Any]:
+    """Head of Marketing: file the Periscope weekly market-research brief.
+
+    Call this exactly ONCE per exploration cycle, after researching
+    competitors, adjacent-tool releases, and positioning shifts (web_search /
+    web_fetch + the knowledge base). This is a REPORT, not a task queue: the
+    CEO reads it in the panel — nothing materializes, and there is no
+    per-item approve/reject.
+
+    Args:
+        headline: One-line summary of the cycle's biggest signal (<=200 chars).
+        findings: 1-7 dicts, each with: claim (<=500 chars), source_url
+            (REQUIRED, a real http(s) URL — an uncited claim is noise and the
+            verb rejects it), relevance (<=300 chars — why this matters to us).
+        threats: Optional list of up to 5 short threat notes (<=300 chars each).
+        opportunities: Optional list of up to 5 short opportunity notes
+            (<=300 chars each).
+        positioning_note: Optional note (<=500 chars) on a positioning shift
+            worth acting on.
+    """
+    return _post(
+        "/api/v1/do/propose_market_brief",
+        {
+            "headline": headline,
+            "findings": findings,
+            "threats": threats,
+            "opportunities": opportunities,
+            "positioning_note": positioning_note,
+        },
+    )
+
+
+def propose_editorial_post(
+    angle: str,
+    body: str,
+    rationale: str,
+) -> dict[str, Any]:
+    """Head of Marketing: draft ONE Megaphone editorial-calendar post.
+
+    Call this exactly ONCE per exploration cycle, after picking ONE angle off
+    the shipped-this-week digest in your briefing. The draft is held in the
+    SAME X post queue propose_feature_spotlight uses — nothing auto-posts.
+
+    Args:
+        angle: One of 'dev_log', 'behind_scenes', 'changelog_highlight',
+            'other'.
+        body: The tweet text (plain, <=280 chars, no invented facts).
+        rationale: Why this angle, this cycle (<=300 chars).
+    """
+    return _post(
+        "/api/v1/do/propose_editorial_post",
+        {"angle": angle, "body": body, "rationale": rationale},
+    )
+
+
+def propose_conversation_replies(items: list[dict[str, Any]]) -> dict[str, Any]:
+    """Head of Marketing: draft 1-5 replies to Barfly's screened X conversations.
+
+    Call this exactly ONCE per exploration cycle, after reviewing the
+    candidate conversations already gathered on this task (search results —
+    RoboCo is relevant but unmentioned). Each reply materializes its own held
+    draft in the X post queue; the CEO reviews and approves/rejects each one
+    individually.
+
+    Args:
+        items: 1-5 dicts, each with: tweet_id (REQUIRED — must name one of
+            this task's real candidate conversations; an invented tweet is
+            rejected), reply_body (the reply text, <=280 chars), rationale
+            (REQUIRED — why this conversation is worth replying to).
+    """
+    return _post("/api/v1/do/propose_conversation_replies", {"items": items})
+
+
+def propose_postmortem(
+    incident_summary: str,
+    root_cause: str,
+    failed_stage: str,
+    process_change: dict[str, Any],
+    playbook: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Auditor: author ONE Coroner postmortem for your open autopsy task.
+
+    Call this exactly ONCE per autopsy — after reading the incident task's
+    full journey (evidence(), the findings ledger, journal trail) — then
+    call i_am_idle(). It completes the autopsy task immediately: there is no
+    per-item CEO queue like roadmap/pest control, this is a single report.
+
+    Args:
+        incident_summary: What happened, <=500 chars.
+        root_cause: The systemic cause (not just the symptom), <=800 chars.
+        failed_stage: The task status where it actually broke down (a real
+            lifecycle status, e.g. 'awaiting_qa', 'in_progress').
+        process_change: {kind, description} — kind is one of
+            'playbook'|'prompt_fix'|'conventions_rule'|'other'; description
+            (<=800 chars) is the ONE process change you propose.
+        playbook: Required iff process_change.kind == 'playbook':
+            {title, body} — drafted immediately as a DRAFT playbook that
+            rides the normal pending-playbook curation queue.
+    """
+    return _post(
+        "/api/v1/do/propose_postmortem",
+        {
+            "incident_summary": incident_summary,
+            "root_cause": root_cause,
+            "failed_stage": failed_stage,
+            "process_change": process_change,
+            "playbook": playbook,
+        },
+    )
+
+
+def propose_quality_report(
+    headline: str,
+    items: list[dict[str, Any]],
+    overall_assessment: str,
+) -> dict[str, Any]:
+    """Auditor: file the Sentinel weekly "state of quality" report.
+
+    Call this exactly ONCE per exploration cycle, after assessing org-wide
+    drift: waiver-accumulation trends, conventions-violation hotspots, and
+    budget anomalies (the evidence is server-assembled for you in the task
+    prompt). This is a REPORT, not a task queue: the CEO reads it in the
+    panel — nothing materializes, and there is no per-item approve/reject.
+
+    Args:
+        headline: One-line summary of the cycle's biggest quality signal
+            (<=200 chars).
+        items: 1-7 dicts, each with: area (one of 'waivers', 'findings',
+            'conventions', 'budget', 'docs', 'other'), observation (<=500
+            chars — what you found), evidence (<=500 chars — the ledger row
+            / metric / file that backs it), suggested_action (<=300 chars —
+            what should happen next).
+        overall_assessment: A synthesis across all items (<=800 chars).
+    """
+    return _post(
+        "/api/v1/do/propose_quality_report",
+        {
+            "headline": headline,
+            "items": items,
+            "overall_assessment": overall_assessment,
+        },
+    )
+
+
+def propose_playbook_drafts(drafts: list[dict[str, Any]]) -> dict[str, Any]:
+    """Auditor: mine journals/learnings for repeated patterns and draft 1-3
+    playbooks for your open Librarian mining task.
+
+    Call this exactly ONCE per mining cycle, after reading the recurring-
+    learning-topics + existing-playbook-titles evidence server-assembled
+    into your task prompt. Each draft is created immediately as a real DRAFT
+    playbook riding the normal pending-playbook curation queue (the same one
+    your own approve_playbook/reject_playbook curate) — a LATER cycle
+    curates them, never this same call.
+
+    Args:
+        drafts: 1-3 dicts, each with: title (<=200 chars, must not duplicate
+            an existing playbook title — case-insensitive), body (<=4000
+            chars — the procedure itself), pattern_evidence (REQUIRED,
+            <=500 chars — which repeated journal/learning pattern justifies
+            this playbook).
+    """
+    return _post("/api/v1/do/propose_playbook_drafts", {"drafts": drafts})
+
+
+def propose_campaign(campaign_name: str, posts: list[dict[str, Any]]) -> dict[str, Any]:
+    """Head of Marketing: propose a War Room campaign (2-6 ordered X posts).
+
+    Call this exactly ONCE per exploration cycle, after designing the
+    campaign arc (teaser -> launch -> follow-up -> spotlight) for the release
+    named in your briefing, or from scratch on a CEO on-demand cycle. Every
+    post lands as a held draft in the X post queue; V1 is manual-cadence —
+    publish_after is GUIDANCE the CEO sees when reviewing each draft, never a
+    schedule anything acts on. Nothing here posts.
+
+    Args:
+        campaign_name: Short name tying the posts together (<=100 chars).
+        posts: 2-6 dicts, IN THE ORDER they should run, each with: body (the
+            tweet text, <=280 chars), publish_after (ISO 8601 datetime,
+            REQUIRED — must be in the future and strictly later than the
+            previous post's), stage_label (one of 'teaser', 'launch',
+            'follow_up', 'spotlight', 'other').
+    """
+    return _post(
+        "/api/v1/do/propose_campaign",
+        {"campaign_name": campaign_name, "posts": posts},
+    )
+
+
 def propose_video(
     composition_id: str,
     x_caption: str,
@@ -1002,7 +1298,19 @@ _TOOLS: dict[str, Any] = {
     "note": note,
     "pitch": pitch,
     "propose_roadmap": propose_roadmap,
+    "propose_bug_hunt": propose_bug_hunt,
+    "propose_gap_fill": propose_gap_fill,
+    "propose_rebalance": propose_rebalance,
+    "propose_messaging_fixes": propose_messaging_fixes,
+    "propose_friction_fixes": propose_friction_fixes,
     "propose_feature_spotlight": propose_feature_spotlight,
+    "propose_market_brief": propose_market_brief,
+    "propose_editorial_post": propose_editorial_post,
+    "propose_conversation_replies": propose_conversation_replies,
+    "propose_postmortem": propose_postmortem,
+    "propose_quality_report": propose_quality_report,
+    "propose_playbook_drafts": propose_playbook_drafts,
+    "propose_campaign": propose_campaign,
     "propose_video": propose_video,
     "dm": dm,
     "notify": notify,