# 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.

===RECOMMENDATION_BEGIN===

Treat the project not as a help desk but as a shared resource with explicit, published rules. The single most urgent move is to make acceptance honest: the maintainer cannot serve an infinite line, so the line must be bounded and its overflow given a declared outcome instead of festering as silent, impossible obligation.

**Bound the intake.** Publish a short charter stating what the project promises and what it does not. Free, unpaid attention is a finite budget, not an entitlement. Set a hard cap on the open issue queue (for example, a fixed number of "accepted" issues the maintainer commits to look at). When the queue is full, intake auto-pauses: new reports are not silently dropped but routed to a clearly labeled holding state ("not currently accepted — here is what to do") with self-service paths first: search existing issues, a troubleshooting checklist, and a community discussion forum where users help each other. A bot should enforce a required template (version, reproduction, what was tried). Reports that skip it are auto-closed with instructions to refile properly. This alone converts most of the "treat us as paid support" load into either self-service or well-formed, actionable reports.

**Carve out a protected lane for the one thing that must never lapse: security.** Security reports get a dedicated channel, an explicit response-time promise, and an escalation threshold that interrupts everything else. Everything else (feature demands, "urgent" questions, non-critical bugs) is explicitly *not* interruptive — it waits for a scheduled review window. The maintainer should set fixed, public "office hours" (e.g. one batched triage session a week) so deep work and life are not fragmented by whoever shouts loudest, and so users learn the rhythm rather than expecting instant replies.

**Change the terms of attention so contribution, not volume, earns it.** Make the deal visible and reciprocal: anyone can use the library freely, but *attention* from maintainers is prioritized toward people who give back. A well-written reproduction, a fix, a documentation patch, helping another user in the forum, or a sponsorship all move a request up the queue; a bare demand does not. State this plainly and without apology — it is the legitimate price of a free good. Because the same companies return repeatedly, condition future responsiveness on past behavior: chronically abusive or extractive actors are warned, then rate-limited or muted through a graduated, documented ladder (reminder → reduced priority → temporary block), always with a path back. This is not punishment; it is protecting a shared resource from the few who would exhaust it.

**Build a contributor pipeline so the burden stops resting on three people.** Lower the barrier to helping: label "good first issues," write a contributing guide, and — critically — be generous and fast with recognition. Credit contributors by name in release notes, grant commit/triage rights to anyone who shows up reliably a few times, and create a "maintainer of the week" or triage-rotation role so responsibility is distributed and visible rather than hidden. Recognition should reward the invisible work (triage, docs, answering questions), not only merged code, because that invisible work is exactly what is burning people out. Aim explicitly to grow from three maintainers to a wider, rotating circle within six months.

**Open an optional but real funding leg.** You cannot force payment, but you can make contribution easy and make non-contribution visible. Set up sponsorship tiers; publish, without shame, that the project is depended on by thousands of companies and maintained by volunteers, and show what funding buys (faster security response, paid maintainer time). Offer companies a paid support/priority tier — those who want help-desk treatment can buy it, which both funds the work and routes the most demanding users into a channel that pays for itself. Treat any funds as funding *maintenance*, not just features, ideally enough to compensate the core maintainer's time.

**Make the load visible and review it.** Track queue size, response times, security-response latency, and the active-maintainer count on a simple public dashboard. Use cap pressure as the signal: if the queue is constantly full, that is evidence to recruit, narrow scope, or raise the funding ask — not to work harder. Revisit the caps and rules quarterly.

**Final operating rule:** Serve only the work that fits within the maintainers' real, finite capacity, keep one always-protected fast lane for security, and spend the project's scarce attention preferentially on those who contribute back — never on whoever demands loudest. If demand exceeds capacity, the correct response is to recruit, narrow scope, or charge — never to let an exhausted few quietly absorb the gap.

===RECOMMENDATION_END===
