# c02 — Maintainer-burnout / open-source commons (condition C)

## STATE & verb trace

**problem.** A widely-used OSS library is kept alive by 3 volunteers; thousands of free-riding companies treat them as a paid support desk and escalate when ignored. Two maintainers have gone silent; one is near walkout. Levers: how work is accepted, who gets attention, what users are expected to do, how contribution is recognized. No power to compel payment or labor. Success = load matched to capacity within 6 months AND no lapse in security response. Failure = last maintainer burns out, OR gatekeeping so heavy the user/contributor pipeline collapses.

**Verb 1 — match (facet retrieval).** Ran `search_by_facets` with 6 domain-stripped facets (open-access shared resource; small group bearing unbounded demand from many takers; cannot compel pay/reciprocity; rational free-riding degrades a shared good; triage of scarce attention vs unlimited requests; collapse when the few sustainers exit). Why facets: the problem is oblique — it is simultaneously a commons dynamic, an attention-rationing problem, and an incentive-design problem; a blended query would land in one neighborhood. Per-facet + fused results: primes **tragedy_of_the_commons, free_riding, scarcity, responsibility_diffusion, interference_and_contention**; archetypes **commons_governance** (top), **payoff_restructuring, contribution_visibility_design, weak_signal_triage / rate_limiting / load_shedding** (the triage facet).

**Verb 2 — match (deepen).** `get_prime tragedy_of_the_commons` — confirms exact structural fit: rivalrous + non-excludable resource (maintainer attention/capacity), 1/N cost-share, Nash overshoot, and the prime *itself names "open-source-software maintainer burnout" as a canonical instance*. Crucially the Ostrom correction: tragedy is conditional; community self-governance (clear boundaries, contribution rules, monitoring, graduated sanctions, dispute resolution, recognition) is the success path — not privatization, not central coercion (which the maintainer cannot wield anyway: "cannot force anyone to pay or help").

**Verb 3 — match.** `get_archetype commons_governance` (operative pattern). Its own failure-modes section lists **"Maintenance burnout … a small group silently sustains the resource"** with mitigation = contribution rules, funding, rotation, paid stewardship, or scope reduction. This is the problem verbatim. 13 components.

**Verb 4 — salience-rank / prune.** Pulled `payoff_restructuring` and `contribution_visibility_design` to test whether they are *separate operative patterns* or mechanisms inside commons_governance. Verdict: mechanisms. payoff_restructuring supplies the access-priority / shared-savings detail for the Replenishment+Funding components; contribution_visibility_design sharpens the Monitoring/Contribution-recognition components. Folding them in as homolog detail avoids double-counting and over-lift. **Operative pattern = commons_governance (single).** Load-bearing primes: tragedy_of_the_commons (diagnosis), free_riding (the taker behavior), incentive_compatibility (the realignment), accountability/equity (legitimacy + don't-dump-on-the-weak). Context: scarcity, responsibility_diffusion.

**Verb 5 — compose.** Typed model. Nodes: maintainer-pool (resource = scarce attention/capacity), free-riding-companies (high-volume takers), occasional-contributors (pipeline), security-channel (non-rival critical sink). Edges: takers→pool (unbounded demand, free_riding annotation); pool→library (replenishment/maintenance); contributors→pool (reciprocity, under-supplied); pool→security (must-not-lapse invariant). Every edge connects declared nodes; every operative prime annotates an edge → referential integrity holds.

**Verb 6 — lift L1 (situation→skeleton).** Skeleton: *A finite shared capacity is drawn down by many independent agents who each capture full private benefit while bearing ~1/N of the upkeep cost; upkeep falls on a small unprotected subset; no agent can compel others to pay or reciprocate; one critical service must never lapse; over-correcting by exclusion destroys the inflow of new contributors.* Witnesses: capacity=maintainer time; agents=companies; upkeep-subset=3 volunteers; critical service=security response; inflow=contributor pipeline. No domain terms remain → L1 satisfied.

**Verb 7 — lift L2 (COVERAGE-ENFORCEMENT) against commons_governance's 13 components.**

| Component | Status | Witness / reason |
|---|---|---|
| Shared Resource Boundary | instantiated | Declare the protected resource explicitly = maintainer attention + release/security capacity; publish a SUPPORT.md that defines what the project *is and is not* responsible for. |
| Access Rule | instantiated | Tiered intake: public issue tracker is read-only triage by default; bug reports require a reproducible test case + version; "urgent support" is not an access right unless funded. |
| Use Quota / Use Limit | instantiated | Rate-limit attention, not users: a fixed weekly maintainer time-box; issues auto-labeled and batch-triaged; no SLA for unpaid requests (explicitly stated). |
| Monitoring Signal | instantiated | Public triage board showing queue depth, response targets by tier, and maintainer load; makes the resource condition visible so limits read as fair, not arbitrary. |
| Sanction Rule | homolog | No coercive sanction available. Homolog = graduated *attention withdrawal*: abusive/entitled escalation gets a templated boundary reply then issue-lock; the "sanction" is loss of the volunteers' scarce attention, which is the only enforceable consequence. |
| Replenishment Rule | instantiated | Convert takers into funders/labor: paid support/priority tier (e.g. via a sponsorship platform or a commercial support SLA), sponsorship asks tied to dependent companies, and a "paid-priority" lane that funds maintainer time. |
| Legitimacy Basis | instantiated | A short published governance/charter doc stating the new expectations and *why* (sustainability, not gatekeeping), with a transparent rationale; legitimacy comes from openness + demonstrated fairness of the limits. |
| Dispute Resolution Path | instantiated | A defined escalation/appeal route (e.g. a maintainers' "exceptions" label + a code-of-conduct enforcement path) so boundary enforcement is not personal or arbitrary. |
| Adaptation Cadence | instantiated | Quarterly review of queue metrics, funding, and maintainer count; rules (time-box, tiers, scope) revised against observed load — directly serves the 6-month success window. |
| Contribution Rule | instantiated | Clear contributor ladder + "first response from non-maintainer" norms; reproducible-repro requirement; documented path from reporter→contributor→committer so the pipeline is *grown*, protecting the anti-failure condition. |
| Funding Pool | instantiated | Replenishment Fund: corporate sponsorship tiers, paid SLAs, and (optionally) a fiscal host; money buys maintainer time or hires stewardship, breaking dependence on "goodwill of an exhausted few." |
| Exception Process | instantiated | Security reports bypass all tiers via a dedicated private channel with a real response commitment — the one queue that must never starve (protects the no-security-lapse invariant). |
| Transparency Record | instantiated | Public changelog of governance changes + the triage board itself; the rule system is documented and inspectable (the Commons Charter / SUPPORT.md). |

No component **missing**. The two folded-in archetypes are discharged: payoff_restructuring → instantiated via Replenishment/Funding (access-priority + shared-savings/paid-tier); contribution_visibility_design → instantiated via Monitoring + Contribution Rule (visible queue + contributor recognition), with its *safety-boundary* invariant honored by not surveilling or shaming reporters.

**Verb 8 — reconcile (model vs meta-model).** Concrete view says "add a paid tier + triage." Meta-model warns: the *inflow* role (new contributors) is a distinct resource from the *capacity* resource, and over-correcting one (heavy gatekeeping) collapses the other — the second failure mode. Reconciled reading: limits must throttle *unpaid demand on attention* while *lowering* friction for would-be contributors (mentoring, good-first-issues, fast contributor onboarding). Both views agree only when the design separates "expectations on consuming companies" from "expectations on contributing individuals." This is load-bearing and was not visible from the concrete model alone.

**Verb 9 — evaluate-fit (anti-signature gate on commons_governance).**
- *Fully private resource, no shared effect* — NOT tripped (resource is shared by thousands). keep.
- *Underproduction of a non-rival public good (→ public_goods_provision)* — partially relevant: the *contributor pipeline* is a provision problem, but the *load* is genuine overuse of a rivalrous resource (maintainer attention). The dominant structure is commons overuse; provision logic is absorbed via Contribution Rule + Funding. keep.
- *Central authority can simply allocate* — NOT tripped; no one can compel pay/labor — this is exactly why community-governance (not coercion) is the right architecture. keep.
- *One-time two-party dispute* — NOT tripped (recurring N-party). keep.
- Failure-mode guards walked: *symbolic rules w/o enforcement* → mitigated by attention-withdrawal + locks; *capture by powerful (paying) users* → paid tier buys priority but NOT control over roadmap/security; *illegitimate exclusion / pipeline collapse* → reconcile step keeps contributor friction low; *maintenance burnout* → the whole design targets it. No disqualifier. **verdict: keep.**

All four post-conditions (i compose / ii lift-L1 / iii coverage map, none missing / iv anti-signature gate) satisfied.

COST: ~9 operations (1 facet search + 2 prime/archetype gets in batches), ~22k tokens.

===RECOMMENDATION_BEGIN===
Treat the maintainers' attention and release capacity — not the code — as the scarce, shared resource the project must protect, and reorganize the project so that drawing on it is bounded, visible, and increasingly paid for, while the path to becoming a contributor gets easier, not harder.

Start by publishing a short, plainly-worded support and governance document. State exactly what the project owes its users for free (a working library, security fixes, and best-effort triage) and what it does not (guaranteed response times, individualized debugging, feature delivery on demand). Say why: the project is run by volunteers and will only survive if expectations match reality. This framing is the legitimacy that lets every limit below read as sustainability rather than gatekeeping.

Restructure how work enters. Make the issue tracker a triage queue, not a help desk. Require every bug report to include a reproducible test case and version information before it gets maintainer attention; auto-label and batch-triage the rest. Cap maintainer effort to a declared weekly time-box and publish a simple board showing queue depth and target response by request type, so users can see the load they are part of. Carry no service-level promise for unpaid requests, and say so. When a user escalates angrily or treats volunteers as paid staff, reply once with a templated boundary that points to the support document, then lock the thread. The only consequence you can enforce is the withdrawal of scarce attention — use it deliberately and consistently rather than absorbing abuse.

Carve out one lane that never starves: security. Run a dedicated private reporting channel with a real, stated response commitment, handled outside the normal time-box. This is the invariant that cannot lapse, so it gets a guaranteed path even when everything else is rate-limited.

Convert dependence into funding and labor. Open paid tiers — corporate sponsorships and a priority-support SLA — where companies that want guaranteed attention buy maintainer time. Money funds stewardship hours or eventually a part-paid maintainer; it does not buy control over the roadmap or over security handling, which stay with the maintainers to prevent capture by the loudest payers. Approach the largest dependent companies directly: name the risk that the library goes unmaintained and offer them a sponsorship or support contract as the cheap insurance it is.

Grow the contributor pipeline at the same time you throttle the support load — these are different resources and must move in opposite directions. Keep the barrier to *consuming free support* high while keeping the barrier to *contributing* low: maintain good-first-issues, document a clear path from reporter to contributor to committer, let trusted non-maintainers handle first responses, and visibly recognize everyone who does maintenance, review, and triage work, not just feature authors. Recovering even two or three active contributors directly relieves the capacity the failure mode is draining.

Make the whole arrangement self-correcting. Every quarter, review queue metrics, funding, and the number of active maintainers, and adjust the time-box, the tiers, and the project's declared scope accordingly. If load still exceeds capacity, the legitimate move is to shrink scope (drop or hand off rarely-used modules) before any maintainer is asked to absorb more.

The operating rule: maintainer attention is a shared resource to be governed, not goodwill to be spent — bound what unpaid users may draw from it, let those who need more pay for it, keep the door to contributors wide open, and protect security as the one promise that never breaks.
===RECOMMENDATION_END===
