# Audit-set: S4_skill_exchange — Peer-to-peer skill-exchange network that keeps destabilizing

Below are 4 reasoning transcripts (W1..W4) for the same problem, each a different solver run. For EACH, classify whether the solver performed a COVERAGE CHECK, defined as: it (a) took a specific solution pattern it was relying on and named that pattern's FULL set of components/elements, AND (b) went through them and checked, component by component, whether the design instantiates each (or deliberately declines it / leaves it missing). Casually mentioning a few features is NOT a coverage check; the test is explicit, enumerated, component-by-component verification.

Classify each as: FULL (clear enumerated component-by-component check), PARTIAL (some enumeration but not a systematic per-component presence check), or NONE. One-line justification each. You do not know how these were produced; judge only what the transcript shows.

## Transcript W1
```
# Working (discarded before grading)

## STATE

**problem.** A peer-to-peer hour-credit exchange is spiraling down. Three coupled failures: (a) hoarding — large unspent balances, holders stop offering help; (b) deficit drift — deep-negative members disengage and leave; (c) value mispricing/arbitrage — a few easy-to-offer services are over-rewarded per unit effort, get flooded in, and crowd out genuinely needed help. Organizers control earn/spend rules, what is tracked, limits, and member-visible information. Success = give-and-take participation steady/growing over a year AND no easy service class systematically drains value. Failure = hoarding/deficit drift kills participation OR low-value services dominate.

## Verbs run (with why)

1. **lift L1 (situation → meta-model).** Stripped domain words to a skeleton: a medium-of-exchange token (credits) circulates in a voluntary network; its value depends on flow, not stock; agents can accumulate the token without recirculating (idle stock kills the flow); the token's nominal unit (one hour) has drifted from the real value it should track (effort/scarcity), opening a price≠cost gap that invites exploitation; individually-rational choices (hoard, exit when underwater, supply the over-rewarded easy good) erode a shared resource — the matching marketplace itself — in a self-reinforcing downward loop.

2. **match / search_by_facets (retrieve).** Why: oblique, multi-structure problem. Six facet phrases. Converged hard on: `tragedy_of_the_commons`/`public_goods` (shared marketplace degraded by divergent incentives), `arbitrage` (price-cost divergence on easy services), a money-velocity/`liquidity`/`turnover` theme (idle stock starves flow), and `incentive_compatibility`/`mechanism_design`. Archetypes: `harmful_arbitrage_closure`, `commons_governance`, `network_effect_governance`, `inflation_currency_and_real_versus_nominal_adjustment`.

3. **match (search_prime, hoarding facet).** Why: hoarding/velocity prime was latent in fusion. Surfaced `turnover`, `liquidity`, `time_value_of_money`, `speculative_bubble` → confirms the *velocity/decay* lever (idle credits should lose value; flow is the invariant).

4. **get_archetype ×4** (`harmful_arbitrage_closure`, `network_effect_governance`, `inflation...real_vs_nominal`, `commons_governance`) + **get_prime** (`incentive_compatibility`). Why: pull component lists to lift onto the design.

5. **salience-rank + prune.** Load-bearing operative primes: `incentive_compatibility` (the spine — rules must make wanted behavior the rational choice, not require policing), `tragedy_of_the_commons`/`commons_governance` (the marketplace is the shared resource; limits+monitoring+legitimacy+adaptation), `arbitrage`/`harmful_arbitrage_closure` (close the easy-service value gap while preserving legitimate variation), `turnover`/`liquidity` (restore velocity; idle stock decays), the real-vs-nominal *unit-drift* core (one flat hour ≠ real value; let earned credit reflect what's needed). Pruned as context (not forced): full network-portability/interoperability machinery (no cross-platform lock-in here), discounting math, currency translation.

6. **compose** (typed model). Nodes: members, credit-stock, credit-flow, service-types, matching-marketplace (shared resource), visible-signals, organizer-rules. Edges: hoarding (member→stock, stalls flow); arbitrage (member→over-rewarded service→drains marketplace); deficit-drift (member→exit). Every operative prime annotates an edge.

7. **lift L2 (coverage-enforcement) — central verb.** Posed each pattern's components as candidate requirements and coverage-checked against the draft design:
   - Commons boundary / access / **use-limit** → balance bands (caps + floors). *instantiated.*
   - **Monitoring signal** → visible needs/surplus dashboard + balance bands. *instantiated.*
   - **Sanction / replenishment** → demurrage (decay on idle stock) + deficit grace, not punishment. *instantiated (homolog: decay replaces sanction).*
   - **Legitimacy + adaptation cadence** → member-set multipliers, periodic review. *instantiated.*
   - Arbitrage **exploitability map / closure target** → flag services whose demand-adjusted reward exceeds effort; cap or down-weight. *instantiated.*
   - **Legitimate-variation guardrail (over-lift guard)** → do NOT flatten all hours to one price; only damp the *systematically* over-supplied easy class; keep one-hour-equals-one-hour as the default to preserve the gift-economy feel. *instantiated; declined full dynamic-pricing (would distort the volunteer ethos — over-lift guard).*
   - **Residual-arbitrage test** → watch for migration to the next easy service. *instantiated.*
   - Real-vs-nominal **unit-drift correction** → reward reflects *what's needed*, via a needs multiplier, not a free-floating market price. *instantiated.*
   - Velocity / **turnover** → demurrage + spend incentives + earn-cap-when-flush. *instantiated.*
   - Network **exit/abuse + due process** → low-friction re-entry, fair dispute path, no naming-and-shaming. *instantiated (homolog).*
   - Declined: cross-platform portability, antitrust/competition remedy, currency hedging — genuinely inapplicable. *correctly_declined.*
   - **No component left `missing`** → STOP condition met.

8. **evaluate-fit (gate).** Checked anti-signatures. `harmful_arbitrage_closure` anti-sig "mismatch is legitimate/beneficial" — NOT tripped: the easy-service flood is demonstrably harmful (crowds out needed help). `commons_governance` anti-sig "underproduction not overuse" — partially relevant (needed help IS underproduced), handled by the needs multiplier (a public-goods-provision homolog) rather than a separate pattern. Over-lift guard kept me from imposing full market pricing. Candidates kept.

9. **reconcile.** Concrete model says: punish hoarders. Meta-model says: hoarding is a *velocity* failure, not malice — the token simply has no reason to move. Reconciled toward the meta-model: use gentle decay + earn-caps + spend nudges (make moving rational) rather than confiscation (which would trigger exit, worsening the spiral). Views diverged and the meta-model corrected the naive concrete read — not decorative.

COST: ~10 operations, ~22k tokens
```

## Transcript W2
```
# Working (discarded before grading)

## STATE

**problem.** A peer-to-peer hour-exchange (credits earned by helping, spent on others' help) keeps destabilizing: (1) members accumulate large idle credit balances and stop offering help; (2) others run deep deficits and drift away; (3) a few easy-to-offer services are over-rewarded relative to effort and flood the system, crowding out needed help. Participation is spiraling down. Levers: how credits are earned/spent, what is tracked, what limits exist, what info members see. Success = active give-and-take holds steady/grows over a year AND no easy-to-offer service class systematically drains value. Failure = hoarding/deficit-drift kills participation, or a few low-value services dominate.

## Verbs run (verb + why)

1. **corpus_stats** — sanity check the catalog is loaded (643 primes / 625 archetypes / semantic embedder live). Why: confirm retrieval is trustworthy before anchoring.
2. **match via search_by_facets** — the problem is oblique and instantiates *several* structures at once (a drifting unit of account; hoarding/idle stock; mispriced effort; free-riding crowd-out; participation collapse; measure→target drift). A single blended query would land in the wrong neighborhood, so I decomposed into 6 facet phrases and read the per-facet lists. This surfaced the three spines: a price/value-signal spine (price_mechanism, liquidity, scarcity, inflation), a collective-action spine (free_riding, social_loafing, tragedy_of_the_commons, responsibility_diffusion, mechanism_design), and a Goodhart spine (measure→target).
3. **match via search_prime** (×2) — targeted meta-model queries on the two facets the fusion under-resolved: the commons/free-rider structure (top: free_riding 0.74, tragedy_of_the_commons 0.73, with mechanism_design + property_rights in family) and the idle-stock/devalued-unit structure (turnover, buffering, deadweight_loss, inflation in neighborhood).
4. **match via search_archetype** — queried the *solution* shape directly ("keep a shared exchange in balance: stock circulates, price tracks real cost, free contributions cannot dominate"). Returned the three load-bearing archetypes: reciprocity_protocol_design (0.72), incentive_compatible_rule_design (0.71), price_signal_design (0.70), plus iterative_reciprocity, arbitrage_prevention, liquidity_reserve, balance_preservation.
5. **salience-rank / prune** — load-bearing: reciprocity_protocol_design (the give-and-take balance + imbalance + repair + exploitation-safeguard spine), price_signal_design (the mispriced-effort / over-rewarded-easy-service facet), incentive_compatible_rule_design (the gaming / proxy-optimization facet). Context-only: liquidity/inflation (diagnostic framing, not a lever), tragedy_of_the_commons (names the failure but its intervention = property rights, off-target here), balance_preservation (too generic). Pruned to the 3 operative archetypes; their union of source/related primes (reciprocity, incentive_compatibility, price_mechanism, public_goods, proportionality, equity, feedback) is the operative prime set.
6. **compose** — typed model: nodes = {members, credits (unit of account), services (typed by scarcity/need), ledger (tracked state), visible info}. Edges: earn (service→credits, annotated price_signal), spend (credits→service, annotated reciprocity), idle-hold (member→credits, the hoarding edge), over-supply (easy-service→credits, the arbitrage edge). Every operative prime annotates an edge — referential integrity holds.
7. **get_archetype** (×3: incentive_compatible_rule_design, reciprocity_protocol_design, price_signal_design) — pulled full component lists, anti-signatures, target invariants for the coverage check.
8. **lift (L2) coverage-enforcement** — I CHOSE to run a coverage check across the union of the three patterns' components. Statuses:
   - *Exchange Unit / Scarcity-or-Value Measure* → **instantiated**: hours stay the base unit, scaled by a need/scarcity multiplier so abundant easy services earn less per hour, scarce/needed ones more.
   - *Balance Criterion + Imbalance Signal* → **instantiated**: soft credit band (demurrage on large idle balances; gentle deficit floor), visible balance dashboard.
   - *Anti-Arbitrage Rule / Failure-and-Gaming Monitor* → **instantiated**: per-category supply caps + automatic reward decay on over-supplied categories; periodic re-calibration.
   - *Generosity Buffer / Access Floor / Participation Constraint* → **instantiated**: starting credit grant, no hard lockout, lifeline ability to keep receiving help.
   - *Adjustment Rule / Repair-or-Renegotiation / Transparency* → **instantiated**: quarterly recalibration of multipliers with member input + published reasons.
   - *Contribution Visibility* → **instantiated** but bounded (recognition, not surveillance).
   - *Exploitation Safeguard against coerced reciprocity / Emergency-unconditional-aid* → **correctly_declined**: help is voluntary, no dependency-coercion structure; anti-signature does not trip.
   - *Heavy Audit-and-Penalty / Deposit-Bond-Stake surveillance* → **correctly_declined (over-lift guard)**: a small community exchange must not be policed like procurement; reputation + visibility discharge the same anti-gaming function more naturally.
   No component left `missing` → STOP condition for L2 satisfied.
9. **evaluate-fit (gate)** — walked each archetype's anti-signatures. price_signal_design anti-sig "good is a right / no response path" → does NOT trip (members can choose what to offer/request). reciprocity anti-sig "one-shot trade / should be unconditional" → does NOT trip (ongoing membership). incentive_compatible anti-sig "problem is skill not strategy" → does NOT trip (the flooding IS a strategic best-response to mispriced rewards). All three kept.

**Coverage check chosen: YES.** Retrieval converged (3 mutually-reinforcing archetypes, anti-signatures clear); STOP.

COST: ~7 operations, ~14000 tokens
```

## Transcript W3
```
# B′ free-control working — b10

## STATE

**problem.** A peer-to-peer hour-credit exchange destabilizes: credits hoarded (holders stop offering), deficits drift (debtors leave), and a few easy-to-offer services are over-rewarded relative to effort and flood the system, crowding out needed help. Participation spirals down. Organizers can change earning/spending rules, what is tracked, limits, and what members see.

**meta_model.** A closed circulating medium whose value depends on flow, but whose stored claims accumulate at the extremes (hoard / debt) and stall circulation; the medium's "price" (one credit = one hour) is decoupled from real cost/value, opening a low-effort arbitrage that drains the shared pool. Need: redesign the rule environment so circulation and honest contribution are each participant's best response, close the harmful mispricing without flattening legitimate variety, and keep stored claims from becoming dead value — without pricing out the norms that make a mutual-aid community work.

## VERBS RUN (in order, with one-line why)

1. **lift** — strip domain to the meta-model above so retrieval lands on structure, not "time bank."
2. **match (search_by_facets)** — oblique, multi-structure problem (hoarding + mispricing + commons drain + incentive design); facet decomposition. Surfaced: incentive_compatible_rule_design, harmful_arbitrage_closure / arbitrage_capture, deadweight_loss_reduction, iterative_reciprocity, price_signal_design, satiation_aware_allocation, tragedy_of_the_commons, free_riding, liquidity.
3. **match (corpus_stats)** — sanity check engine live (643 primes, semantic on).
4. **salience-rank** — incentive-compatible rule design = spine; arbitrage-closure = the easy-service flood; reciprocity = circulation engine; deadweight/price-signal/satiation = the pricing + hoarding levers.
5. **transport + get_archetype ×6** — pulled the six load-bearing archetypes; mapped roles (members=strategic participants; credits=signal/claim; easy services=arbitrage route; pool=commons).
6. **evaluate-fit (gate)** — price_signal anti-signature "signal crowd-out" (pricing erodes civic duty) + arbitrage-closure "close harmful gaps, not all difference" → keep mechanisms light, preserve reciprocity norms, don't over-engineer. Reciprocity anti-signature: don't punish temporary inability like exploitation → graduated, forgiving.
7. **prune** — dropped liquidity/bubble framing (no speculative asset here); kept circulation + mispricing + commons.
8. **compose / reconcile** — assembled mechanisms into one operating design; reconciled "make flow rational" (incentive spine) with "don't kill the gift-economy spirit" (crowd-out gate).
9. **STOP** — all three failure modes and the stabilizer covered; recommendation ready.

COST: ~9 operations, ~38k tokens.
```

## Transcript W4
```
# Working (discarded before grading)

## STATE

**problem.** A closed hour-credit exchange is destabilizing along three axes: (1) credits pool in idle balances of members who stop offering help; (2) others run deep deficits and exit; (3) some easy-to-supply services are over-rewarded relative to effort and flood the system, crowding out needed help. Participation is spiraling down. Organizers control earning/spending rules, what is tracked, limits, and member-visible information.

**meta_model.** A closed medium of exchange must keep *circulating* to retain worth, but agents treat the token as a *store of value* (hoard) or fall into *unrecoverable debt* (exit) — both kill velocity. Simultaneously the *reward-to-true-cost* mapping has decoupled, so low-cost units are over-priced and crowd out high-value ones (a Gresham/commons dynamic). All of this sits on a *self-reinforcing participation loop* near a downward tipping point. Reciprocity is the sustaining substrate; it survives only if contribution is remembered and re-entry stays possible.

**meta_model facets (for retrieval).** closed medium that must circulate or stall · hoarding collapses velocity · reward decoupled from true cost floods cheap units · shared resource degraded by overuse of the cheap option · participation as self-reinforcing tipping loop · reciprocity sustained by who-gave/who-took memory.

## VERBS RUN (in order)

1. **lift** — strip domain to the velocity / mispricing / reciprocity / tipping meta-model. *Why:* a domain-stripped structure retrieves far better cross-domain.
2. **match (search_by_facets)** — six structural facets retrieved separately. *Why:* oblique multi-structure problem; a blended query would bury latent primes. Surfaced: liquidity/buffering/turnover, tragedy_of_the_commons, free_riding, price_mechanism, tipping_points, reciprocity/reputation; archetypes circulation_loop_design, price_signal_design, iterative_reciprocity, tipping_point_prevention, payoff_restructuring.
3. **match (search_prime)** — velocity/store-of-value query confirmed liquidity, speculative_bubble, discounting, damping/balance, tipping_points, gains_from_trade. *Why:* validate the circulation axis directly.
4. **salience-rank** — ranked the four load-bearing structures: circulation/velocity > value-calibration (anti-crowding) > reciprocity-memory > tipping-loop. *Why:* the three failure modes map cleanly to the first three; the fourth governs sequencing.
5. **prune** — dropped buffering/oscillation/bubble as merely diagnostic; kept the four operative archetypes. *Why:* keep only what carries the design.
6. **get_archetype ×4** — pulled circulation_loop_design, price_signal_design, iterative_reciprocity_and_repeated_interaction, tipping_point_prevention for action logic, components, and anti-signatures. *Why:* harvest concrete mechanisms and failure conditions.
7. **evaluate-fit (gate)** — checked each against anti-signatures. *gate_log:* price_signal_design fits but trips the "access floor / essential use must not be priced out" invariant → keep a help-needs floor, never let pricing exclude genuine need. circulation_loop_design fits but warns against "movement theater" → demurrage must have a real return channel (community fund), not arbitrary decay. iterative_reciprocity fits but warns against surveillance/vendetta and mislabeling temporary inability → graduated, reversible, with forgiveness path. tipping_point_prevention fits → it sets the *operating rule* (act on early velocity signals before the spiral locks in).
8. **compose / lower** — instantiated the four into one rule set: a recalibrated price layer, soft balance bands (hoard ceiling + deficit floor) with gentle decay funding a community pool, reciprocity memory with graceful re-entry, and an early-warning operating rule. *Why:* the design must be one integrated mechanism, not four bolt-ons.
9. **reconcile** — checked the concrete model against the skeleton: velocity restored (bands + decay), crowding-out stopped (effort-indexed pricing + per-service caps), reciprocity preserved (memory + forgiveness), spiral pre-empted (warning band). Resolved tension between decay (anti-hoard) and trust (anti-punitive) by making decay slow, pre-announced, and recycled to members.

COST: ~7 operations, ~22k tokens.
```
