Propagate a vendored artifact to N copies

Enumerate every copy, fan updates out in parallel, then prove the tree and lock agree afterwards.

Also usessuperpowers

Propagation is mechanical, parallel, and unforgiving: N-1 updated copies is a worse state than zero updated copies, because the drift is now invisible.

Start here

One prompt to start

This vendored artifact needs propagating to every copy -- list every copy and its canonical source exhaustively first, update them all in parallel in one dispatch, and then prove the working tree actually matches the committed lock instead of trusting that the copy loop worked.

Needscompass, superpowers, andon

Beats

Run these in order. Each prompt is copy-pasteable straight into Claude Code.

1. compass:compass-map-relationshipsalso in 4 other recipes

   • Run a read-only design study with an evidence legend
   • Check cross-forge CI parity
   • Collapse duplication hand-synced across N sites
   • Migrate a return shape or type representation

   The count must be exhaustive before the first write; a missed copy is silent drift.

   Run this beat on its own

   list every vendored copy of this artifact and the canonical source they're supposed to track

2. superpowers:dispatching-parallel-agentsalso in 2 other recipes

   • Triage an incident under time pressure
   • Execute a written plan across parallel workstreams

   Multiple dispatch calls in one response run in parallel, one per response runs sequentially.

   Run this beat on its own

   update all seven vendored copies in parallel — one agent per copy, all dispatched in the same message, mechanical tier model

3. andon:andon-verifyalso in 13 other recipes

   • Audit supply-chain pinning and dependencies
   • Finish and integrate a development branch
   • Investigate a job that reports success but changed nothing
   • Investigate a fix that did not stick
   • Investigate tests that pass while the code is broken
   • Root-cause a bugfix from a tracked issue
   • Build a new feature in an existing codebase
   • Collapse duplication hand-synced across N sites
   • Execute a written plan across parallel workstreams
   • Migrate a return shape or type representation
   • Audit your own agent and skill definitions for loop-reliability defects
   • Do oracle engineering and numerical V&V
   • Whole-branch review without re-trusting the branch's own self-assessment

   The lock is the stated contract; a successful copy loop is not evidence that it holds.

   Run this beat on its own

   prove the working tree now matches the committed artifact lock — strictly

Worked example

Grounded in — why this beat order is trustworthy

`inline-d3.html` exists in the seven `plugins/*/assets/` directories that carry one plus the canonical `tools/d3-subset/inline-d3.html`, and CI already carries the proof step: `plugin-checks.yml` runs `rrt artifacts --check --strict` specifically so a dropped copy fails a job instead of denying an edit months later.

Do / Don't

• ✓List every vendored copy and its canonical source exhaustively before the first write -- a missed copy is silent drift.
• ✓Dispatch all the copy updates in one message, one agent per copy, so they actually run in parallel.
• ✓Prove the working tree matches the committed lock afterward -- a successful copy loop is not evidence that it holds.

• ×Don't start updating copies before the enumeration is exhaustive -- N-1 updated copies is worse than zero, because the drift is now invisible.
• ×Don't dispatch the copy updates across separate responses expecting them to run in parallel.
• ×Don't treat a completed copy loop as proof the lock holds -- prove it strictly, the way CI's own `rrt artifacts --check --strict` step does.