# 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

===RECOMMENDATION_BEGIN===
Treat maintainer attention as the scarce shared resource the whole ecosystem draws on, and redesign the project so that resource is bounded, replenished, and never silently carried by a few. The aim is not to punish users but to change what each request costs and earns.

**Make the resource and its rules explicit.** Publish a short, plain governance note: what the maintainers commit to (security fixes, reviewing well-formed contributions, periodic releases), what they do not (free debugging, on-demand support, feature delivery on anyone's timeline), and how decisions are made. This converts an implicit, infinite obligation into a stated, finite one, and gives the remaining maintainer legitimate ground to decline work without guilt.

**Bound the intake.** Replace the open firehose with a small number of governed lanes, each with a cap. Security reports get a private channel and a guaranteed response path — this lane is never closed. Bug reports require a reproducible, minimal example using a template; reports that don't meet the bar are auto-closed with a courteous note explaining what's missing and inviting resubmission. Feature requests go to a separate discussion area where they must gather support and, ideally, a contributor before becoming work. Set a visible open-issue ceiling per lane; when full, intake pauses with an honest "at capacity, reopening when drained" message rather than accumulating an unanswerable backlog. The default answer to a well-formed request is a pointer to where it sits, not a promise of when it ships.

**Order the work by harm, not by volume or by who shouts loudest.** Serve in this priority: security first, then defects affecting many users, then reviewing community pull requests, then everything else. Protect a slice of attention for reviewing contributions even when bug volume is high — if the contributor lane starves, the pipeline that could relieve the maintainers dies, which is the collapse you must avoid. Entitled escalation earns no priority bump; make that explicit and apply it consistently, because inconsistent exceptions are what reintroduce favoritism and resentment.

**Shift the default from "we fix it" to "we merge it."** Make contributing the fast path: clear contribution guide, "good first issue" labels, fast acknowledgement of pull requests, and a documented route from contributor to reviewer to co-maintainer based on demonstrated reliable work. Recognize all contribution publicly — including triage, docs, and review, not just code — so the people sustaining the project are visible and credited. This is reciprocity made concrete: those who give back get attention and standing; those who only consume get the public artifact and the documented self-serve paths, but not a private support desk.

**Convert dependence into funded stewardship.** The companies that rely on the library are the beneficiaries who currently pay nothing; give them a legitimate way to contribute money or labor. Offer sponsorship tiers and, for organizations wanting reliability guarantees or priority triage, a paid support or retainer option — paid attention is a separate, honest lane, not a queue-jump for the free tier. Route funds toward maintainer compensation and toward a maintenance reserve, separating one-time enthusiasm from durable upkeep. Even modest funding lets the project pay for security audits or buy down a maintainer's hours, turning goodwill into capacity. Where money is impossible, ask dependent organizations for in-kind help: a rotating reviewer, a security contact, documentation.

**Remove the single point of failure.** Document everything required to run a release so no knowledge dies with one person. Recruit at least one additional maintainer or trusted reviewer within the six-month window, and name a security backup so response never depends on one individual being awake. Set a low-ceremony release cadence the team can sustain rather than heroic bursts. If recruitment stalls, the governance note should already declare a graceful-degradation mode — security-only maintenance — so the library survives in reduced form rather than collapsing silently.

**Keep it legitimate and adaptive.** Apply rules proportionally and transparently; pair every "no" with a path (self-serve docs, the contribution route, paid support, or a later intake window). Watch a few signals quarterly: maintainer hours and morale, security response time, open-issue age, contributor count, and any work leaking into private channels. If the caps over-reject genuine need, or if maintainers are still drowning, retune the thresholds — the design is meant to flex with demand, not to ossify.

**Final operating rule:** the maintainers owe the ecosystem a maintained, secure artifact and a fair, open path to contribute — not unbounded free labor on demand. Accept only the work you can honestly serve, serve it by harm and by reciprocity, make contribution the fastest way to get attention, fund stewardship from those who depend on it, and never let the project's survival rest on one exhausted person.
===RECOMMENDATION_END===
