# Working — control policy trace

## problem
- statement: a peer time-exchange (hours of help = credits) keeps destabilizing.
- failure modes observed: (a) hoarders accumulate credit and stop offering; (b) deficit drifters fall behind and leave; (c) a few easy-to-supply services are over-rewarded vs. effort and flood the system, crowding out needed help. Participation spiraling down.
- success: active give-and-take holds/grows over a year AND no easy-service class systematically drains value.
- levers: how credits are earned/spent, what's tracked, what limits exist, what members see.

## verbs run (verb — why)
1. **match (search_by_facets)** — oblique, multi-structure; passed 6 domain-stripped facets (stagnant store of value; reward decoupled from cost + flooding; individually-rational degradation of a shared resource; reinforcing loop toward collapse; proxy optimized over goal; prices not tracking scarcity/need). Read per-facet lists, not just fusion.
2. **match (get_archetype ×5)** — pulled arbitrage_capture, price_signal_design, circulation_loop_design, payoff_restructuring, commons_governance.
3. **match (search_prime)** — confirmed the demurrage facet ("idle medium loses value") → `turnover`/`liquidity`/`buffering` (structural).
4. **salience-rank / prune** — see operative_primes.
5. **compose** — relational model (below); referential integrity checked.
6. **lift L1** — domain-stripped skeleton + witness check.
7. **lift L2 (coverage)** — coverage map on the operative pattern set.
8. **evaluate-fit** — anti-signature gate (below).

## operative_primes (post salience-rank + prune)
- `tragedy_of_the_commons` — load_bearing. The shared resource here is the *trust/liquidity of the exchange itself*; individually-rational hoarding, deficit-walking, and flooding degrade it. (Integrating frame.)
- `incentive_compatibility` / `reciprocity` — load_bearing. System currently pays for the wrong behavior (hold credits, dump cheap services); must make contributing-and-circulating the rational choice.
- `price_mechanism` (mixed-framed) — load_bearing. The earn-rate is a signal of effort/scarcity that has come unglued from real cost → repricing.
- `turnover` / `liquidity` (structural) — load_bearing. Credits pool and stop circulating; need decay/turnover pressure + a return path.
- `feedback` / `homeostasis` (via balancing_loop_stabilization) — load_bearing. The down-spiral is an uncorrected loop; need a deviation→correction structure.
- context (pruned to context-only): `arbitrage` (the flooding is the *evil twin* of capture — closure, not capture, is operative), `externality`, `accountability`, `legitimacy`.

## model (typed relational — referential integrity)
nodes: M(member), C(credit-balance), S(service-class), R(earn/spend-rules), V(visible-info), G(governance-body), P(exchange-as-shared-pool).
edges (every edge references declared nodes; each operative prime annotated):
- M —earns/spends→ C  [price_mechanism: earn-rate is the signal]
- C —idle-decay→ C  [turnover/liquidity: demurrage keeps it moving]
- M —floods→ S —crowds-out→ P  [tragedy_of_the_commons; arbitrage(closure)]
- R —sets price-of→ S  [price_mechanism; incentive_compatibility]
- G —monitors→ P, —adjusts→ R  [feedback/homeostasis: balancing loop]
- V —shows→ M (balances, prices, needs)  [accountability/legitimacy]
- M —reciprocates→ M  [reciprocity]
Referential integrity: ✓ all edges connect declared nodes; all load_bearing primes appear as annotations.

## meta_model (lift L1 — domain-stripped; witnesses in model)
- roles: agents holding a transferable token; a shared medium whose health = circulation; a rule-setter; an information surface. (witnesses: M, P, G, V)
- relations: token earned at a rate that should track real cost; token decays if idle; agents can over-supply a cheap option that depletes the shared medium; rule-setter senses deviation and corrects. (witnesses: edges above)
- invariants: token must keep circulating; supply must track need not ease-of-supply; the corrective loop must hold the agent-base in a viable range. (no domain terms remain ✓)

## coverage map — operative pattern: COMMONS_GOVERNANCE (integrating), with price_signal_design / payoff_restructuring / circulation_loop_design / balancing_loop_stabilization sub-patterns folded in
| component | status | witness / reason |
|---|---|---|
| Shared Resource Boundary | instantiated | the exchange's liquidity+trust is the commons; membership defines the boundary. |
| Access Rule | instantiated | active membership = ability to earn/spend; lapsed inactive accounts pause. |
| Use Quota / Use Limit | instantiated | per-service-class weekly cap so one cheap class can't flood (anti-crowding limit). |
| Monitoring Signal | instantiated | dashboard of circulation rate, balance spread, per-class supply-vs-requested. |
| Sanction Rule | homolog | not punitive fines but graduated: idle-credit decay + soft balance bands + nudges (proportional, legitimacy-preserving). |
| Replenishment Rule | instantiated | starter credit grant + community-need bounties fund under-supplied help. |
| Legitimacy Basis | instantiated | members vote periodically on price weights and caps; rules are published. |
| Dispute Resolution Path | instantiated | small elected review group hears repricing/quality appeals. |
| Adaptation Cadence | instantiated | quarterly review of prices, caps, decay rate vs. observed behavior. |
| Contribution Rule | instantiated | balance bands require periodic give-and-take; pure hoarders gently capped. |
| Funding Pool | homolog | a small system "tax"/decay feeds a community-needs bounty pool. |
| Exception Process | correctly_declined-as-homolog | handled by the appeals/review group above; no separate machinery needed. |
| Transparency Record | instantiated | public ledger of prices, needs, and rule changes (the visible-info surface). |
| — price_signal_design: Scarcity/Value Measure | instantiated | earn-rate tied to a need-vs-supply ratio, not flat per hour. |
| — price_signal_design: Access Floor / Lifeline | instantiated | everyone keeps a baseline ability to request essential help regardless of balance. |
| — price_signal_design: Anti-Arbitrage Rule | instantiated | per-class caps + dynamic down-weighting close the flood gap. |
| — payoff_restructuring: Desired Equilibrium | instantiated | steady give-and-take; design rewards offering needed help + spending, not accumulating. |
| — circulation_loop_design: Driving Gradient + Return Channel | instantiated | idle-decay is the gradient; bounty pool is the return channel back into circulation. |
| — balancing_loop_stabilization: Target Range + Deviation + Actuator | instantiated | target = stable active-participant count + circulation rate; G adjusts decay/prices/caps when out of band. |
| — balancing_loop_stabilization: Deadband / anti-overshoot | instantiated | soft bands + gradual decay + quarterly (not instant) reprice to avoid churn. |
No component is `missing`. ✓

## evaluate-fit (anti-signature gate)
- commons_governance: "resource fully private / use doesn't affect others" — NOT tripped (use is mutually depleting). "underproduction of a non-rival good rather than overuse/neglect" — partially relevant (deficit-drift is under-contribution) but the design already adds public_goods-style provision (bounties), so not disqualifying. → keep.
- price_signal_design: "behavior is mandatory regardless of willingness to pay" — n/a, no rights-floor violated (lifeline preserved). "actors can't respond" — false, members can switch what they offer. "main problem is gaming not unclear scarcity" — gaming IS present (flooding), so the design pairs pricing with anti-arbitrage caps rather than pricing alone. → keep, with caps.
- payoff_restructuring: "actors already prefer desired behavior but lack capability" — partly (some just don't see needs) → addressed by the info surface, not only incentives. "unenforceable" — decay/caps are automatic, enforceable. → keep.
- circulation_loop_design: "payload should be sequestered not recirculated" — false; "movement theater without a real gradient" — avoided (decay is a real gradient, bounty is a real return path). → keep.
- balancing_loop_stabilization: "no observable signal / no actuator" — false (dashboard + rule levers). "target contested/adaptive" — target is governed by member vote. "one-off not recurring" — recurring loop. → keep.
- arbitrage_capture: anti-signature "better response is to CLOSE a harmful gap than capture it" — TRIPPED, correctly. So we do NOT instantiate capture; we instantiate gap-closure (caps + repricing). → drop as generative pattern, retain as closure logic.

Gate verdict: design survives; no disqualifying condition. Over-lift guard: declined a separate Exception Process (folded into appeals) rather than bolting on machinery.

COST: ~9 operations (1 stats, 1 facet, 6 archetype/prime fetches, 1 prime search), ~16k tokens.

===RECOMMENDATION_BEGIN===
Treat the exchange itself — its liquidity and the trust that the hour you bank can be redeemed — as the shared asset everyone is quietly draining. Every rule below protects that asset while keeping help flowing.

**Price help by what the community needs, not by how easy it is to supply.** Keep the hour as the base unit, but attach a need-multiplier to each service category. A category that is over-supplied relative to requests earns a little less than an hour per hour; a category people are waiting for earns a little more. Recompute these weights on a slow cadence (quarterly) from the previous period's supply-versus-requests data, so the signal is stable enough to plan around and members can see why it moved. This closes the gap that let a few cheap services flood the system: the moment a category is over-offered, its reward drifts down automatically, and chronically scarce help is worth more to provide.

**Cap how much any one category can be banked per member per week.** A hard ceiling on credits earnable from a single easy-to-offer service stops anyone from manufacturing value out of low-effort volume. The cap protects the rest of the exchange even before the price weights catch up.

**Make idle credit gently melt.** Balances above a comfortable working cushion lose a small percentage each month — enough that stockpiling is pointless but never enough to punish someone saving for a real need. The melt does not vanish: it flows into a community-needs pool. This single rule fixes hoarding (holding is now mildly costly, so credits keep circulating) and funds the next mechanism.

**Run bounties from the needs pool.** When requests pile up in an under-served category, the pool posts bonus credits for anyone who fills them. Decayed hoarder-credit thus returns to the system exactly where help is short — the asset recirculates instead of pooling.

**Hold balances inside soft bands rather than hard limits.** Set a generous positive ceiling and a modest debt floor. As a member approaches the top, prompt them with open requests they could fill and let them spend freely; as they approach the floor, prompt them with easy ways to give before they can keep drawing. Crucially, preserve a lifeline: anyone, regardless of balance, may always request a small amount of genuinely essential help. New members start with a modest credit grant so they can receive before they have given, which prevents the cold-start deficit spiral.

**Show everyone three things, always:** their own balance and where it sits in the bands; the current price weights and which categories are short; and the overall health of the exchange (how fast credits are circulating, how many members gave and received this month). Visibility turns private optimization into shared stewardship and lets members self-correct before rules have to.

**Govern with a light, legitimate loop.** A small elected review group watches a simple dashboard — active give-and-take count, circulation rate, and balance spread. Define a healthy operating range for those numbers. When the system drifts out of range, the group has a fixed set of dials to turn: the melt rate, the price weights, the category caps, and the size of the starter grant and bounties. They adjust gradually and explain each change, and members ratify the weighting scheme periodically by vote. The same group hears appeals on pricing and on poor-quality help. Adjust on the slow cadence so the system corrects drift without thrashing.

**Final operating rule:** a credit is a promise to give, not a trophy to hoard — so keep it always cheaper to hold than to use, always more rewarding to supply what is scarce than what is easy, and let the community itself watch the circulation rate and turn the dials before the spiral starts.
===RECOMMENDATION_END===
