# Audit-set: S5_oss_burnout — Open-source project collapsing under maintainer burnout and free-riding

Below are 4 reasoning transcripts (W1..W4) for the same problem, each a different solver run. For EACH, classify whether the solver performed a COVERAGE CHECK, defined as: it (a) took a specific solution pattern it was relying on and named that pattern's FULL set of components/elements, AND (b) went through them and checked, component by component, whether the design instantiates each (or deliberately declines it / leaves it missing). Casually mentioning a few features is NOT a coverage check; the test is explicit, enumerated, component-by-component verification.

Classify each as: FULL (clear enumerated component-by-component check), PARTIAL (some enumeration but not a systematic per-component presence check), or NONE. One-line justification each. You do not know how these were produced; judge only what the transcript shows.

## Transcript W1
```
# Working (discarded before grading)

## STATE

**problem.** An open-source library used by thousands of companies is maintained by three burned-out volunteers; demand (bugs, feature demands, urgent security questions) is unbounded, treated as paid support, and abusive; two maintainers have gone silent and the last is about to leave. The remaining maintainer controls how work is accepted, who gets attention, what users are expected to do, and how contribution is recognized — but cannot compel payment or help.

**meta_model.** A shared, non-excludable resource (a public good) whose upkeep falls on a tiny unprotected subgroup while many beneficiaries free-ride. The maintenance/attention capacity is a finite sink being overloaded by unpriced, unbounded demand. The lever available is not money or coercion but the *rules of access, attention, expectation, and recognition* — i.e. governance redesign that converts a one-sided demand relationship into bounded, reciprocal participation.

## VERBS RUN (verb — why)

1. **lift** — strip the OSS frame to the underlying structure: open-access commons + unpriced demand on a scarce sink + hidden maintenance exploitation. (done implicitly to form the meta-model query)
2. **match (search_by_facets)** — oblique, multi-structure problem; decomposed into six structural facets (free-riding, unpriced demand on capacity, private-cost/public-benefit, eroding volunteer effort, no triage, demand→reciprocity). Surfaced commons/public-goods primes + the operative archetypes.
3. **salience-rank** — ranked the retrieved archetypes by load-bearing fit: commons_governance (master frame) > bounded_backlog + attention_budgeting (the acute triage failure) > iterative_reciprocity (the contributor-pipeline fix) > contribution_visibility (recognition) > public_goods_provision (funding leg).
4. **transport/lower** — pulled the five archetype bundles (get_archetype ×5) and mapped each one's roles/components onto maintainers, companies, requests, contributors.
5. **evaluate-fit (gate)** — commons_governance vs public_goods_provision anti-signatures: the case is BOTH overuse of a maintenance sink (commons) AND underprovision of funding (public good); both pass, neither is excluded. iterative_reciprocity passes (users reappear; future-access can be conditioned). bounded_backlog passes ("endless stream" = unbounded waiting stock). attention_budgeting passes ("who gets attention"). No anti-signature tripped. Gate cleared.
6. **prune** — dropped pure-pricing framings (cannot force payment) and surveillance-heavy contribution tracking (anti-signature: would shame, not support). Kept the governance + triage + reciprocity + recognition + optional-funding spine.
7. **compose / reconcile** — assembled into one operating design; reconciled the central tension (bound the load hard enough to save the maintainer, but not so hard the contributor pipeline collapses) via graduated, legitimate, reversible rules with a fast-track exception for security.

**candidates kept:** commons_governance, bounded_backlog, attention_budgeting, iterative_reciprocity_and_repeated_interaction, contribution_visibility_design, public_goods_provision.

COST: ~7 operations, ~9 encyclopedia calls (1 search_by_facets + 5 get_archetype + corpus loads), ~22k tokens.
```

## Transcript W2
```
# Working — c17 (control-policy trace)

## STATE: problem
- Statement: an open-source library serving thousands of free-riding companies is maintained by 3 burning-out volunteers; 2 have gone silent, 1 near quitting. The remaining maintainer controls how work is accepted, who gets attention, what is expected of users, and how contribution is recognized; cannot force anyone to pay or help.
- Success: maintenance load matched to capacity within 6 months AND no lapse in security response.
- Failure: last maintainer burns out (lapse) OR gatekeeping so heavy the community/contributor pipeline collapses.

## Verbs run (verb + why)

**1. match (retrieve) — search_by_facets + search_prime.** The problem is oblique (multi-structure), so I decomposed it into facets: unbounded asymmetric demand on a few providers; depletion of a shared resource by cost-externalizing users; near-zero ask-cost / high answer-cost flooded channel; entitlement without reciprocity; access regulation without pipeline collapse; converting consumers to contributors.
- Per-facet primes surfaced a tight cluster: `tragedy_of_the_commons`, `free_riding`, `public_goods`, `scarcity`, `reciprocity`, `attention`/`cognitive_resource_depletion`, `access_control`, `mechanism_design_and_incentive_structure`, `externality`, `mediator_availability_constraint`, `load_balancing`.
- Per-facet archetypes surfaced: `contribution_visibility_design` (top fused), `attention_budgeting`, `gateway_mediation`, `incentive_compatible_rule_design`, `reciprocity_protocol_design`, `commons_governance`, `price_signal_design`. Recorded source-prime overlap → candidates.

**2. salience-rank (ablation test on each candidate).**
- LOAD-BEARING: the shared resource being depleted is **maintainer attention/capacity**, used non-rivally as code but rivalrously as support — this is a *maintenance commons* (commons by neglect, not extraction). Remove this framing and the whole design changes → `commons_governance` is the spine. Also load-bearing: `free_riding`/`reciprocity` (the asymmetry is the disease), `gateway_mediation` (the near-zero ask-cost flooded channel is the proximate mechanism), `attention`/`cognitive_resource_depletion` (the finite stock).
- CONTEXT: `public_goods` (true for the code, but the code is non-rival and not the thing depleting — provision is not the problem, so demote), `incentive_compatible_rule_design` (informs anti-gaming guardrails), `contribution_visibility_design` (informs recognition layer).

**3. prune.** Cut to operative subset (~6): commons_governance (spine), gateway_mediation (intake), free_riding/reciprocity (asymmetry), attention/cognitive_resource_depletion (finite stock), incentive_compatible_rule_design (anti-gaming), contribution_visibility_design (recognition). Cut `price_signal_design`/`congestion_pricing` to context-only: the maintainer **cannot force payment** (constraint) and pricing risks the pipeline-collapse failure mode — kept as an *optional sponsor-priority* mechanism, not a gate. Cut `load_balancing` (homolog handled by triage, not equivalent-handler distribution).

**4. compose.** Model: nodes = {maintainers (finite stock), users/companies (drawers), code (non-rival output), support-channel (the boundary), contributors (replenishers)}. Edges: users→support-channel (uncontrolled crossing = flood), support-channel→maintainers (depletion), maintainers→code (replenishment), users→code (free benefit), contributors→maintainers (reciprocity). Every operative prime annotates an edge (referential integrity holds).

**5. lift (L1) — model → meta_model.** Roles: STEWARDS (finite-capacity providers), DRAWERS (many, cost-externalizing), the SHARED-SINK (steward attention/tolerance), the CROSSING (ungoverned intake), REPLENISHERS. Invariants: sink stays viable across repeated use; maintenance not indefinitely shifted to a small unprotected subgroup; access protection ≠ arbitrary exclusion; the critical-renewal function (security) never lapses. No domain terms remain.

**6. lift (L2) — coverage-enforcement against commons_governance components (the central verb).** Coverage map:
- Shared Resource Boundary → INSTANTIATED: declare the project's scope/SLA boundary (what the maintainers owe vs. don't).
- Access Rule → INSTANTIATED: tiered intake — security via private path always; everyone else via a single structured front door.
- Use Quota / Use Limit → INSTANTIATED (homolog): not a numeric quota but a *triage policy* + "no-response is a valid response" norm; attention budget reserved for security.
- Monitoring Signal → INSTANTIATED: triage labels + a public backlog/health board.
- Sanction Rule → HOMOLOG: graduated, soft — entitled/abusive behavior met with templated close + code-of-conduct, not punishment of newcomers.
- Replenishment Rule → INSTANTIATED: contributor pipeline + funding pool (sponsorship/grants/paid stewardship) + the security-critical renewal guarantee.
- Legitimacy Basis → INSTANTIATED: published charter stating the volunteer compact, so enforcement reads as fair not arbitrary.
- Dispute Resolution / Exception Process → INSTANTIATED: explicit escalation/exception path (incl. paid-priority option).
- Adaptation Cadence → INSTANTIATED: periodic review of load vs. capacity.
- Contribution Rule → INSTANTIATED: PRs/triage/funding accepted on stated terms; "report ≠ assignment."
- Transparency Record → INSTANTIATED: the public board doubles as audit.
- Funding Pool → INSTANTIATED (optional-but-named).
No component left `missing` → stop-eligible.

**7. lift (L2) — gateway_mediation components (over-lift guard applied).** Intake Channel, Validation Rule (issue templates/repro requirements), Access Policy, Forwarding/Routing, Rate Limit (declined — over-lift: a hard rate limit distorts the legitimate-newcomer sub-structure; the triage + bot handles it naturally), Quarantine/Rejection Path (templated close), Service-Level Commitment (the *asymmetric* SLA: security fast, features best-effort/none), Escalation Path. Declined: heavy authentication broker (not the boundary's problem).

**8. lift (L2) — contribution_visibility_design + incentive_compatible_rule_design.** Effort Recognition → INSTANTIATED (credit, maintainer status as a path). Free-Ride Monitor → HOMOLOG (the board surfaces who only takes). Anti-gaming / Participation Constraint → INSTANTIATED (templates resist low-effort dumps without blocking real bugs). Safety Boundary → INSTANTIATED (recognition not shaming).

**9. evaluate-fit (gate).** Walked anti-signatures:
- commons_governance "problem is underproduction not overuse/neglect" → NOT tripped: this is genuinely neglect/overload of a finite sink, not provision of the code. KEEP.
- commons_governance "central authority can just allocate" → not tripped (no authority, no money lever). KEEP.
- gateway_mediation "only volume → rate limiting" → partially tripped → so gateway is used for *structure/translation/routing*, volume handled by triage, not promoted to pure rate-limit. KEEP, scoped.
- price_signal_design / congestion_pricing → TRIPPED by the "cannot force payment" constraint + pipeline-collapse failure risk → DROP as gate; retain only as voluntary sponsor-priority. 
- load_balancing → tripped (no equivalent handlers) → DROP.

**10. reconcile.** Concrete model says "stop answering" relieves load; meta-model warns the *renewal* invariant (security) must never lapse and the *legitimacy/pipeline* invariant forbids blanket withdrawal. Resolution consistent with both: withdraw *undifferentiated free support* while hard-guaranteeing the security-renewal channel and keeping a low-friction contributor on-ramp. Views diverged → meta-model not decorative.

STOP: coverage map complete, gates walked, no missing component. Recommendation ready.
```

## Transcript W3
```
# c12 — Open-source maintainer burnout / maintenance commons

## STATE + working (discarded before grading)

**problem.** A widely-used OSS library is maintained by 3 volunteers; thousands of firms free-ride. Unbounded inbound (bugs, feature demands, security questions) from non-contributing users who treat volunteers as paid support and escalate when ignored. Two maintainers have gone silent; the last is near exit → total lapse. Lever set: can change *how work is accepted, who gets attention, what is expected of users, how contribution is recognized*; CANNOT compel payment or labor. Success = load matched to capacity within 6 months AND no security-response lapse. Failure = last maintainer burns out, OR gatekeeping so heavy the user/contributor pipeline collapses.

### Verbs run (verb + why)

1. **match (search_by_facets)** — oblique, multi-structure problem, so decomposed into 6 structural facets (shared-upkeep-by-few, private-cost/public-benefit, unbounded-demand-vs-fixed-capacity, exhausted-few-vs-taking-many, no-filter-overuse, relied-upon-can-withdraw). Per-facet + fused rankings.
   - Fused primes: `tragedy_of_the_commons` (distinctive, mixed-framed, top), `public_goods`, `deadlock`, `scarcity`, `free_riding`, `margin_of_safety`, `solidarity`.
   - Fused archetypes: `capacity_reservation`, `contribution_visibility_design`, `commons_governance`, `bounded_backlog`, `comparative_advantage_specialization`, `queue_reservation`, `public_goods_provision`.
2. **match (corpus_stats)** — sanity: 643 primes / 625 archetypes, embedder live. OK.
3. **match (get_archetype ×3)** — pulled `commons_governance`, `bounded_backlog`, `contribution_visibility_design` for components + anti-signatures.
4. **match (search_archetype ×2)** — covered two latent facets a blended query buries: "who gets attention" (priority/triage) → `priority_based_admission`, `intake_queue_staging`, `attention_budgeting`; and "require contribution before granting" → `iterative_reciprocity_and_repeated_interaction`, `reciprocity_protocol_design`.
5. **match (get_archetype ×2)** — `iterative_reciprocity…` and `intake_queue_staging` for component grain.
6. **salience-rank.** Load-bearing: `tragedy_of_the_commons` (the spine — distributed benefit / concentrated maintenance cost, with *maintenance burnout* as a named failure mode and OSS as a named example), `bounded_backlog` (caps the unbounded obligation store), `intake_queue_staging` (separates *received* from *accepted* — kills the false support-desk commitment), `contribution_visibility_design` (recognition flips coasting to contributing), `iterative_reciprocity` (conditions attention on giving-back). Context only: `public_goods` (underproduction framing — see prune), `margin_of_safety`/`scarcity` (background), `deadlock`/`solidarity` (descriptive, no lever).
7. **prune.** Cut `public_goods_provision`: its own anti-signature in `commons_governance` says provision is for *underproduction of a non-rival benefit*; our failure is *overuse/neglect of a shared maintenance capacity* → commons governance, not provision. Kept ~5 operative patterns.
8. **compose** (mental model). Nodes: maintainers (finite capacity), users (taking firms / contributing users), inbound stream (bugs/features/security), the codebase+capacity (the commons). Edges: users→stream→capacity (depletion); maintainer→codebase (replenishment); reciprocity edge users↔attention. Every operative pattern annotates an edge. Referential integrity holds.
9. **lift L1** (situation→meta-model). Roles: STEWARDS (finite, can exit, uncompellable), BENEFICIARIES (many, can take w/o giving), SHARED-CAPACITY (depletes by neglect + overload), INBOUND-OBLIGATION (unbounded). Invariants: capacity must stay > security-critical load; stewardship must not rest on a hidden few; access must stay open enough to keep the contributor pipeline. No domain terms remain.
10. **lift L2 — coverage check (yes, I chose to run it).** Union the components of the operative patterns and status each against the draft design:
    - Shared-resource boundary → *instantiated* (scope statement: what the project owns vs. declines).
    - Use limit / backlog cap → *instantiated* (intake cap + triage SLAs).
    - Admission gate / received≠accepted → *instantiated* (issue template gate; "received" auto-label).
    - Overflow / clean-rejection path → *instantiated* (auto-close-with-pointer to discussions/paid lane).
    - Monitoring signal → *instantiated* (public backlog/age dashboard).
    - Sanction / graduated response → *homolog* (non-abuse code-of-conduct + rate-limited escalation, not punitive).
    - Replenishment / funding pool → *instantiated* (sponsorship + paid-priority lane; the exit-risk lever).
    - Contribution memory / reciprocity rule → *instantiated* (contributor standing → priority).
    - Effort recognition / credit → *instantiated* (CREDITS + maintainer tiers).
    - Legitimacy basis + adaptation cadence → *instantiated* (published charter, quarterly review).
    - Dispute/appeal path → *instantiated* (security exception lane + appeal).
    - Safety/exception (security) → *instantiated* (security never rate-limited; private disclosure + funded on-call).
    - Visibility safety boundary (anti-surveillance) → *correctly_declined* — contribution tracking here is voluntary public credit, not employee monitoring; the surveillance guard doesn't bind.
    - Over-lift guard: did NOT import full peer-evaluation / workload-heatmap machinery (distorts a 3-person volunteer group) — declined.
    - No component left `missing`. Stop condition met.
11. **evaluate-fit (gate).** `commons_governance` anti-sigs: not fully private; not mere underproduction (overuse+neglect both present); central command impossible (can't compel) → fits. `bounded_backlog` anti-sigs: problem is accumulated obligation stock not just inflow rate → fits (pair cap+rate-limit). `iterative_reciprocity` anti-sig: relationship IS repeatable + identity observable (GitHub handles) → available, but keep as mechanism inside governance, not the whole frame. No candidate tripped a disqualifier; security-exception requirement is the binding guardrail against over-gatekeeping. STOP.

COST: ~9 operations, ~30k tokens
```

## Transcript W4
```
# Working (free control policy — discarded before grading)

STATE
- problem: 3-volunteer OSS library; thousands of free-riding companies treat maintainers as paid support; 2 maintainers gone silent, 1 near walking away; redesign how work is accepted, who gets attention, what users are expected to do, and how contribution is recognized; cannot force payment/help. Success = load matched to capacity in 6mo + no security lapse; failure = burnout OR gatekeeping collapses community/pipeline.
- meta_model: a shared, non-excludable resource (maintainer attention) is depleted because many consume it freely while a tiny unprotected subgroup bears all the cost; unbounded intake hides overload and manufactures impossible obligations; a critical function rests on a single point of failure about to fail; redesign the decision environment so consumption is bounded, contribution is reciprocal and visible, and stewardship is replenished without illegitimate exclusion.

VERBS RUN (in order)
1. lift — strip the OSS frame to the structural meta-model (depleted shared resource + unbounded obligation store + single point of failure + incentive misalignment). Why: a blended raw query would land only in "open source funding" and miss the intake/governance structure.
2. match (search_by_facets) — six structural facets (free consumption depleting the few; entitled unbounded demand; demand>capacity throttling; redesign attention/expectations; reciprocity-or-deprioritize; single point of failure). Why: oblique multi-structure problem; per-facet retrieval surfaces latent primes a single vector buries.
3. match (search_prime) — confirm the commons/free-rider core. Why: cross-check the facet fusion.
4. salience-rank — fused archetypes: commons_governance (spine), public_goods_provision, bounded_backlog, queue_discipline_design, contribution_visibility_design; SPOF facet → redundant_backup. Why: order by load-bearing relevance.
5. get_archetype × commons_governance — Why: spine; mined maintenance-commons variant, "maintenance burnout" failure mode, invariant "duties not shifted to a small unprotected subgroup," graduated/proportional rules, legitimacy + adaptation.
6. get_archetype × queue_discipline_design — Why: order admitted work by urgency with anti-starvation so the contributor pipeline isn't starved; security = triage class.
7. get_archetype × contribution_visibility_design — Why: free-rider response via recognition + reciprocity, NOT shaming/surveillance (safety boundary = anti-collapse guard).
8. get_archetype × public_goods_provision — Why: convert diffuse corporate dependency into funded maintenance (sponsorship, dues, maintenance endowment); separate launch from maintenance funding; maintainer capacity is the public good.
9. get_archetype × bounded_backlog — Why: cap accepted work, clean rejection/deferral, intake gate; stops unbounded queue from manufacturing impossible obligations and moral injury.
10. evaluate-fit (gate) — checked the named failure: heavy exclusion → "illegitimate exclusion / club-good drift / contributor-pipeline collapse." Kept all rules least-coercive and reciprocal; rejected pure paywall/hard gate. Also confirmed commons (overuse of existing resource) over pure public-goods (underproduction): both apply — overuse of attention AND underprovision of funded stewardship, so I compose both.
11. compose / lower — instantiate the typed model into concrete OSS mechanisms, thresholds, and a final operating rule.
12. STOP — recommendation is sound; structure, intake, incentives, funding, and succession all covered; gate passed.

COST: ~11 operations, ~24k tokens
```
