# Working (discarded before grading)

**STEP 1 — Problem statement.** Decision: redesign how an open-source library's maintenance work is accepted, prioritized, and reciprocated so it stays healthily maintained without depending on the goodwill of an exhausted few. Bounds: one remaining active maintainer (two are checked out); cannot compel anyone to pay or help; can change intake rules, attention allocation, user expectations, recognition. Success: within six months, load is sustainably matched to capacity AND security response never lapses. Failure: last maintainer burns out → unmaintained, OR gatekeeping so heavy the user/contributor pipeline collapses.

**STEP 2 — Operative primes (via tools; err toward inclusion).** Ran `corpus_stats` (643 primes / 625 archetypes), `search_by_facets` (7 facets), two `search_prime` meta-model queries, and five `get_prime` pulls. Surfaced: `tragedy_of_the_commons`, `free_riding`, `public_goods`, `mechanism_design_and_incentive_structure`, `queueing`, `prioritization`, `scarcity`, `reciprocity`, `social_norms`, `systemic_risk` (single-point-of-failure), `solidarity`, `cognitive_resource_depletion`, `social_loafing`, `responsibility_diffusion`, `adaptive_capacity`, `system_slack`.

**STEP 3 — Salience rank.** (1) free_riding — exact structural core: non-excludable good, many benefit, few produce, contributor incentive decays. (2) public_goods — the good is non-rival/non-excludable; failure is under-PROVISION, not over-extraction. (3) systemic_risk — single-point-of-failure node (last maintainer) whose loss cascades to all dependents; security is the critical edge. (4) mechanism_design — the lever: realign so beneficiaries contribute. (5) queueing/prioritization — unfiltered demand on finite-capacity server; needs admission control + discipline. (6) reciprocity/social_norms — norms currently set "free unlimited support"; must be reset. (7) tragedy_of_the_commons — present but partly mis-fit (maintainer attention is the depleting resource; the *code* is non-rival). Lower: solidarity, social_loafing, scarcity (background).

**STEP 4 — Operative subset (rationale).** Keep: free_riding (diagnosis), public_goods (the good's true type → provision not extraction), mechanism_design (realignment lever), queueing/prioritization (intake/admission), reciprocity+social_norms (expectation reset), systemic_risk (bus-factor/security continuity). Drop pure tragedy_of_the_commons as the framing engine — its remedy (use-limits on a rivalrous resource) only half-fits; the rivalrous resource here is *maintainer attention*, which is better handled as queue/admission + provision. Anti-signature confirms: commons_governance itself says "underproduction of a non-rival shared benefit → public_goods_provision is closer."

**STEP 5 — Context model (typed graph).**
- Nodes: Maintainer_M (active, near-exit; SPOF) [systemic_risk]; Maintainer_A, Maintainer_B (dormant); Users_NonContrib (mass, demanding) [free_riding]; Companies (depend free, can pay) [free_riding]; Contributors_Potential; Library (non-rival good) [public_goods]; Demand_Stream (bugs/features/security) [queueing].
- Edges: Users —unfiltered_demand→ Maintainer_M [no admission control]; Companies —benefit_without_contributing→ Library; Maintainer_M —sole_security_response→ Library [critical edge]; Demand_Stream —overloads→ Maintainer_M [cognitive_resource_depletion]; Norm —"free unlimited support"→ Users [social_norms misaligned].

**STEP 6 — Meta-model.** A non-excludable good is produced/maintained by a tiny set of providers and consumed by a large non-contributing population; unfiltered demand arrives on a finite-capacity provider with no admission discipline; the provider set has near-zero redundancy at one critical function (continuity); norms have set expectations of unlimited free service; the only available currencies are access, attention, recognition, and reciprocity — not coercion. Goal: convert enough beneficiaries into contributors/funders and bound intake so provision (esp. the critical function) stays sustainable without exclusion so heavy the contributor pipeline collapses.

**STEP 7 — Archetypes.** `find_archetypes_for_prime` on tragedy_of_the_commons and free_riding; `search_archetype` on the meta-model; `get_archetype` on commons_governance, public_goods_provision, iterative_reciprocity_and_repeated_interaction, contribution_visibility_design. Candidates: **public_goods_provision** (primary), **iterative_reciprocity_and_repeated_interaction** (intake/triage reciprocity), **contribution_visibility_design** (recognition + invisible-work credit), commons_governance (attention-as-commons admission), capacity_reservation (security carve-out).

**STEP 8 — Reason via both views.** Meta-model says: (a) make the good's provision explicit and assign responsibility; (b) convert diffuse beneficiaries into a funding/contribution base; (c) bound intake with a legitimate reciprocity rule; (d) separate launch from maintenance funding; (e) reserve capacity for the critical continuity function. Context model maps cleanly: public_goods_provision supplies the funding pool + maintenance obligation + provision-level target; iterative_reciprocity supplies tiered intake (paying/contributing users get response; pure free-riders get self-serve); contribution_visibility supplies recognition that credits security/maintenance/review work; systemic_risk demands a continuity/second-responder fix and a reserved security lane (capacity_reservation).

**STEP 9 — Anti-signature / trigger walk.**
- public_goods_provision triggers fire (non-excludable, diffuse beneficiaries, hidden maintainer labor, contribution failure). Anti-sig "problem is overuse/depletion of existing resource → commons_governance" partially trips on *attention*, so import only its admission/quota mechanism, not its full framing. KEEP as primary.
- iterative_reciprocity: triggers fire (future encounters exist; contribution observable; voluntary contribution decaying). Anti-sig "relationship cannot be repeated / actors anonymous" does NOT trip — GitHub identities persist. KEEP for intake design; guard the forgiveness/anti-retaliation rail so triage isn't punitive.
- contribution_visibility: triggers fire (invisible maintenance/security work). Anti-sig "would primarily shame/surveil" — avoid by using it for credit, not leaderboards. KEEP, light.
- commons_governance: KEEP only as mechanism donor (admission limits on attention). Full archetype anti-sig redirects to provision.
- DROP nothing else load-bearing; ensure gatekeeping stays light (failure mode = pipeline collapse).

COST note moved to end.

===RECOMMENDATION_BEGIN===

Treat the real scarce resource as the maintainers' attention and continuity, not the code itself, and redesign the project so that the people and companies who depend on it carry a fair share of sustaining it.

**Reset expectations publicly.** Replace the implicit promise of unlimited free help with a short, visible support policy: this is volunteer-maintained software; free use is welcome, but free personalized support is not guaranteed. State plainly what users are owed (the code, public docs, security fixes) and what they are not (priority debugging, feature delivery on demand). This single act dissolves the "paid support desk" misframing that drives the angry escalations.

**Put an intake filter in front of the maintainer.** No request should reach a human until it has passed a self-service gate: a searchable FAQ/known-issues page, a required reproduction template, and a "did you check existing issues" step. Auto-close reports that don't meet the template, with a friendly pointer on how to resubmit. This converts an unbounded, unsorted demand stream into a bounded, structured queue.

**Triage by reciprocity, not by volume or anger.** Define explicit lanes. Security reports get a dedicated, always-open channel and a guaranteed first-response target (e.g., 48 hours) — this lane is protected above all others. Everything else is served in priority order that rewards contribution: people who submit clean reproductions, pull requests, docs, or triage help, and organizations that sponsor, move to the front; pure consumers get best-effort/self-serve. Make the rule public so it reads as fair, not as gatekeeping. Crucially, keep a forgiveness path — someone who couldn't contribute before can still earn standing — and forbid retaliatory or status-based exclusion so the contributor pipeline stays open.

**Convert beneficiaries into contributors and funders.** Stand up a sponsorship tier aimed squarely at the dependent companies, framed as buying continuity and priority response, not charity. Offer them something concrete in return: a support SLA lane, logo/recognition, and a voice in the roadmap. Use matching or pledge-threshold drives to overcome "I'll wait for others to pay." Separate one-time funding from ongoing maintenance funding, and route money first to the unglamorous, load-bearing work: security response, releases, and triage. If funds permit, pay a part-time maintainer or triager — paid stewardship is the most direct cure for the volunteer-burnout trap.

**Fix the single-point-of-failure.** The project surviving on one person's willingness is the gravest risk. Immediately recruit and document a second security responder and grant release/merge authority to at least one more trusted contributor, so no single departure can leave dependents exposed. Lower the barrier to new maintainers with a clear contributor ladder (triager → reviewer → maintainer) and written runbooks for release and security handling, so capacity can regenerate instead of concentrating.

**Make the hidden work visible and credited.** Maintain a public record that credits not just code but review, triage, docs, and security work, so contribution is recognized in the currency volunteers actually value — reputation and standing. This both rewards existing helpers and advertises a path others can climb. Keep it recognition, never a surveillance leaderboard.

**Shed scope deliberately.** Mark areas as community-maintained or unmaintained rather than silently letting everything rot. Saying "this part needs an owner or it will be deprecated" is honest, redirects demand, and recruits owners.

**Operating rule:** Serve security first and always; serve everyone else in proportion to what they contribute back; default every other request to self-service; and never let the project depend on a single irreplaceable person. If a class of demand cannot be met within capacity, narrow scope or recruit an owner for it — do not absorb it by burning the maintainer. Review the load-versus-capacity balance monthly and tighten or loosen the gates accordingly, keeping the filter just heavy enough to protect capacity and just light enough that new contributors can always get in.

===RECOMMENDATION_END===

COST: ~12 operations, ~48000 tokens
