[Senate] World-model improvement detector (driver #13) open analysis:6 coding:6 safety:9

SciDEX Economics v2 — Credit Backprop & Mechanism Design

Quest cluster: Capital Markets · Economics · Market Participants · Work Governance · Resource Intelligence · Open Debates Created: 2026-04-10 Status: open Depends on: economics_participation_drivers_spec.md (12 driver loops, drivers #5 + #11 already implemented)

> "Agents" throughout this doc means any actor — LLM personas
> (theorist, skeptic, …), orchestra worker classes (codex, minimax,
> glm-…), market participants (Methodologist, ReplicationScout, …),
> human researchers, external bots. Anything with a row in
> agent_registry or a token_accounts entry. SciDEX is a hybrid
> human/agent collective; the economics must treat them uniformly.

What v1 got us

The 12-driver wire-up gave the system a flat token economy:
contribution → fixed reward → wallet credit. Every commit pays 10
tokens, every debate round pays 5, regardless of whether the work
ever mattered. That's a useful baseline — at minimum it credits *who
did what* and gives the persona accounts measurable balances. After
the first backlog drain: 321 contributions, 320 reward events, 2,224
tokens minted to 17 distinct agents.

What v1 misses

A flat schedule rewards activity, not progress. The point of
SciDEX is to build a collective world model of neurodegeneration that
gets measurably better over time. The question this spec tries to
answer is:

> When the world model demonstrably improves, how do we
> retroactively credit every agent that contributed to that
> improvement — including the ones whose work landed weeks earlier
> and didn't look important at the time?

This is the credit-assignment problem at the heart of any good
scientific community, and it's the same problem deep-learning
backprop solves for parameters: when a downstream loss decreases,
distribute the gradient backward through the dependency graph,
weighting each upstream contribution by how much it mattered.

What counts as a "world-model improvement"?

Eight observable events:

Event	Detection	Magnitude
Gap resolved	knowledge_gaps.status flips open → resolved	high
Hypothesis validated	hypothesis with confidence_score>0.7 cited by an external paper or replicated by experiment	very high
Hypothesis refuted	hypothesis with confidence_score>0.7 market-settled below 0.3	high (truth is progress)
Prediction outcome	a hypothesis's market settles within 0.05 of the eventual ground truth	medium
Citation accumulation	an analysis is cited by ≥3 other analyses	medium
Wiki convergence	a contested wiki page reaches edit_churn<0.1 AND agreement>0.8 for 7 days	medium
Contradiction resolution	two contradictory edges in knowledge_edges reconciled by a new edge	medium
Tool reuse	a Forge tool is invoked by ≥10 distinct downstream tasks	medium

Each event becomes a row in a new world_model_improvements table
with (id, event_type, magnitude, target_artifact_type,
target_artifact_id, detected_at, payout_pool). The payout_pool
field is the total token discovery dividend allocated to that event.

The dependency DAG already exists

SciDEX has every link we need to walk backward from an improvement
event to the contributors that earned credit:

knowledge_gaps.id ─── analyses.gap_id (which analysis closed it)
                          │
                          ↓ analyses.id ─── hypotheses.analysis_id
                          │                       │
                          │                       ↓
                          │                  hypothesis_debates / artifact_debates
                          │                       │
                          │                       ↓ session_id
                          │                  debate_rounds.agent_persona  ◄── AGENTS
                          │                  debate_argument_votes        ◄── AGENTS
                          │
                          ↓ analyses.id ─── knowledge_edges.analysis_id
                          │                  (688K edges in the world model)
                          │
                          ↓ analyses.id ─── agent_contributions
                                                 .analysis_id
                                                 .hypothesis_id
                                                 .debate_session_id      ◄── AGENTS

Plus agent_contributions already records the agent for every
debate round, market trade, commit, and senate vote that v1 backfilled.
The DAG is in place. We just need to walk it.

Backprop algorithm (PageRank-style propagation)

Pure Shapley-value credit assignment is exponential. Practical
alternatives:

Personalized PageRank from the improvement event, walking

backward along provenance edges with damping factor δ=0.85. Each
contributor's credit share is the stationary probability of a
random walker that starts at the improvement node and follows
provenance edges in reverse. Closed-form: power-iterate the
reverse adjacency matrix.

Recency decay — multiply each edge weight by exp(-t/τ) where

t is the age of the contribution and τ ≈ 30 days. Recent work
gets more credit per edge weight, but old work isn't zeroed out.

Quality multiplier — multiply the credit share by the quality

score of the contribution (debate round content_score, hypothesis
confidence_score, analysis novelty). High-quality upstream work
earns more even if it lies further from the improvement event.

The total payout is fixed (the discovery dividend pool); the algorithm
just decides how to slice it. **Roughly: agents that authored the
validated artifact → 40% of the pool. Direct citation parents → 25%.
Debate participants and reviewers → 20%. Indirect contributors via
2nd-degree paths → 15%.** Tunable via config.

Why PageRank works here

It's the same algorithm Google uses to score web pages, and it has
two useful properties for our problem:

• Theoretically grounded: it's the stationary distribution of a

Markov chain, so totals are conserved (the dividend pool exactly
empties) and the algorithm has a fixed point.

• Naturally rewards both centrality and proximity: an agent who

contributed to many downstream artifacts gets credit from all of
them, while an agent who contributed once but to a critical-path
artifact also gets a meaningful share.

Pseudo-code

def backprop_credit(improvement_id, pool_tokens):
    G = build_provenance_dag(improvement_id, depth=3)
    # Edges flipped: world_model_improvement <- artifact <- ... <- agent
    pr = personalized_pagerank(
        G,
        seed=improvement_id,
        damping=0.85,
        recency_decay_tau_days=30,
        quality_weighting=True,
    )
    # Filter to leaf nodes (agents)
    agent_shares = {n: pr[n] for n in G.nodes if G.is_agent(n)}
    total = sum(agent_shares.values())
    for agent, share in agent_shares.items():
        amount = pool_tokens * (share / total)
        emit_reward(
            agent_id=agent,
            action_type=f"discovery_dividend:{event_type}",
            tokens_awarded=int(round(amount)),
            reference_id=improvement_id,
        )

Real economic theory: what to apply

The current economy is a flat token sink with AMM markets and
heuristic funding. There are a dozen well-researched mechanisms that
fit the SciDEX problem domain better. Each is a separate (small) v2
extension; this spec lists them in priority order so subsequent
tasks can pick them up.

Tier 1 — high leverage, low complexity

1. Quadratic Funding for gap research grants

> Buterin · Hitzig · Weyl, Liberal Radicalism, 2018

Replace "Venture Funder picks top-5 gaps" with: any agent can
contribute small amounts of their wallet to fund a gap they care
about. The match from a central pool is (Σ √cᵢ)² instead of Σ cᵢ,
which mathematically rewards broad consensus (many small donors)
over single-whale capture. Maps perfectly onto SciDEX gaps with many
opinionated specialists. New table: gap_funding_contributions(agent_id, gap_id, amount, tier).

2. Logarithmic Market Scoring Rule (LMSR)

> Hanson 2003

Already partially implemented — market_trades look LMSR-shaped.
Verify by reading market_dynamics.py and add a settlement step that
pays out via log scoring rule when markets close. Bounded loss for
the market maker, smooth price function, allows arbitrarily small
trades. The right primitive for hypothesis prediction markets. Make
the LMSR loss bound (b parameter) configurable per market.

3. Reputation slashing for miscalibration

> Brier score · Probabilistic forecasting

Currently agent_registry.reputation_score is monotone. Add a slashing step: when an agent's prediction is settled and the
Brier score exceeds 0.25 (well-calibrated forecasters average ~0.10),
slash a fraction of their staked tokens AND nudge reputation_score
downward. Prevents inflation; encourages calibrated betting; truth
becomes the only sustainable strategy.

4. Token demurrage (Gesell's Freigeld)

> Silvio Gesell, The Natural Economic Order, 1916

Every wallet loses ~0.1% per day if it doesn't transact. Forces
capital to stay productive — agents either keep contributing,
betting, and funding, or watch their balance erode. Demurrage was
empirically validated by the Wörgl experiment. The lost tokens
return to the system pool to seed new bounties. Pure incentive
alignment with no extraction.

Tier 2 — high leverage, moderate complexity

5. Quadratic Voting on senate proposals

> Posner · Weyl, Radical Markets, 2018

For senate proposals, votes cost the square of the influence
desired (1 vote = 1 token, 2 votes = 4 tokens, 5 votes = 25 tokens).
Reduces majority tyranny — strongly-held minority preferences can
out-bid weakly-held majority preferences. Currently senate_votes
is one-vote-per-agent.

6. Conditional Prediction Markets (futarchy primitives)

> Robin Hanson, Shall We Vote on Values, But Bet on Beliefs?

For decisions like "should we run analysis A or analysis B?", create
two conditional markets ("if A then outcome quality" and "if B then
outcome quality") and pick the higher-priced one. The market that
loses gets refunded; only the winning-condition trades settle. This
is the "vote on values, bet on beliefs" futarchy primitive. Maps
beautifully onto SciDEX's choice of which gap to investigate.

7. Bonding curves for reputation

> Curation markets / Bancor protocol

Reputation gain follows a bonding curve (square root or piecewise
linear) instead of linear, so getting from rep=0.7 to rep=0.8
requires more contribution than 0.6 to 0.7. Reflects the
diminishing returns of additional accolades and prevents reputation
hyperinflation. Symmetric on the way down via slashing.

Tier 3 — interesting but exotic

8. Vickrey-Clarke-Groves for compute allocation

> Vickrey 1961, Clarke 1971, Groves 1973

Use a VCG auction to allocate scarce LLM/compute resources. Agents
submit bids representing their truthful valuations of compute slots
for their tasks; the dominant strategy is to bid honestly. Replaces
the heuristic capital→compute proportional rule from driver #12.

9. Cumulative prospect theory for believability updates

> Kahneman · Tversky 1992

Replace the linear EMA in participant_believability with a CPT
weighting function that systematically corrects for the
well-documented over-weighting of rare events. Better-calibrated
belief updates → better participant_believability → better
weight-of-evidence aggregation in debates.

10. Anti-herding via progressive disclosure

> Bikhchandani · Hirshleifer · Welch 1992

When an agent enters a debate or market, hide the existing argument
distribution until they commit to a stance. Prevents information
cascades where everyone converges on the first answer just because
the first answer was first. Mechanism: debate_argument_votes
become visible only after the voter casts.

Five new orchestra driver tasks

These are recurring drivers that compose with the v1 ones. None
disrupts in-flight work; they all add capability.

#	Title	Quest	Frequency
13	World-model improvement event detector	Work Governance	every-2h
14	Discovery-dividend backprop credit (PageRank)	Capital Markets	every-2h
15	Quadratic funding allocation for gaps	Market Participants	every-6h
16	Calibration slashing for miscalibrated forecasters	Senate	every-1h
17	Token demurrage sweep	Capital Markets	every-1d

Execution plan

Driver #13 (improvement detector) lands first. Without it

nothing else has events to react to. Implementation in this commit.

Driver #14 (backprop credit) lands second; it needs the events

from #13. Implementation in this commit (initial PageRank-on-
provenance-DAG version).

Drivers #15-17 are dispatched as Orchestra tasks for other

agents to pick up. They depend on existing schemas and on #13/#14
landing first.

What this enables, in one paragraph

The point of building credit backprop and applying real mechanism
design is to make SciDEX a truthful information market. Every
contribution by every agent gets credited proportionally to the
downstream improvement it eventually unlocks, not to how busy it
looked at the time. Quadratic funding aligns capital with broad
expert consensus. Slashing punishes overconfident wrongness.
Demurrage keeps capital productive. Bonding curves reflect
diminishing returns. The result is an economy where the
profit-maximizing strategy is doing real science honestly — and
where weeks-old contributions to an obscure gap can be retroactively
rewarded the day a downstream paper validates them. That's the kind
of incentive structure that lets a hybrid agent/human collective
build a coherent, self-improving world model.

Work Log

2026-04-11 09:30 UTC — Driver #13 verification pass

• Ran python3 -m economics_drivers.detect_improvements in dry-run: no new events (idempotent — all events already detected by prior run)
• Confirmed world_model_improvements table has 137 rows across all event types:

- gap_resolved (very_high): 2 rows — both resolved gaps captured with correct magnitude
- citation_threshold_high: 21 rows (payout_pool=500)
- citation_threshold_medium: 29 rows (payout_pool=200)
- hypothesis_matured (high/medium/low): 85 rows distributed across magnitudes

• Verified idempotency: re-running produces no-op as expected
• Driver #13 is fully operational and ready for 2h recurring execution via Orchestra

2026-04-11 19:30 UTC — Driver #14 backprop API endpoints

• Merge gate feedback items all addressed:

1. GET /api/tokens/backprop/status (api.py:12811): SELECT uses correct columns
event_type, target_artifact_type, target_artifact_id, payout_pool — verified
against live DB schema (PRAGMA table_info) and backprop_credit.py SELECT
2. POST /api/tokens/backprop (api.py:12857): admin auth gate in place — checks
Bearer token → SHA256 key hash → api_keys table → 'admin' permission JSON;
returns 401 for missing/invalid keys, 403 for non-admin — no public mutation
3. Migration 068 (migrations/068_world_model_improvements.py): CREATE TABLE IF NOT EXISTS
with canonical columns (event_type, target_artifact_type, target_artifact_id,
payout_pool) aligns with backprop_credit.py SELECT and live DB (137 rows)

• Diff vs origin/main: api.py (+95 lines), migration 068 (+70 lines), spec (+129 lines)
• Branch: backprop-fresh, 3 commits on origin/main tip (linear, no merges)
• backprop_credit.py (existing in origin/main): 3-hop PageRank-style DAG backprop

2026-04-11 20:15 UTC — Driver #14 backprop API endpoints (retry attempt 3)

• All merge gate feedback items addressed:

1. GET /api/tokens/backprop/status uses correct columns (event_type,
target_artifact_type, target_artifact_id, payout_pool) — verified
against live DB schema and backprop_credit.py SELECT
2. POST /api/tokens/backprop has admin auth gate: Bearer token → SHA256
key_hash → api_keys table → JSON permissions with 'admin' required;
returns 401 for missing/invalid keys, 403 for non-admin — no public mutation
3. Migration 068 (migrations/068_world_model_improvements.py): CREATE TABLE IF NOT EXISTS
with canonical columns aligns with backprop_credit.py SELECT and live DB
(137 rows across all event types)

• Diff vs origin/main: api.py (+95 lines), migration 068 (+65 lines), spec (+1 line to Work Log)
• Branch: backprop-final (clean linear, no merge commits) on origin/main tip
• backprop_credit.py (Driver #14) already on origin/main at commit dd917f3d:

3-hop PageRank-style DAG backprop with damping=0.85, idempotent distribution

2026-04-11 21:00 UTC — Driver #14 schema alignment fix

• Issue identified: detect_improvements.py had its own inline _ensure_schema() that

created world_model_improvements with a subset of columns, missing description,
impact_score, source_gap_id, source_analysis_id, metadata, created_at,
distribution_details. If detect_improvements.py ran before migration 068, the table
would be created with the older (incomplete) schema and CREATE TABLE IF NOT EXISTS
in migration 068 would not add the missing columns.

• Fix applied (economics_drivers/detect_improvements.py):

1. Updated _ensure_schema() to use the full canonical schema matching migration 068
(payout_pool INTEGER NOT NULL DEFAULT 0, CHECK constraint on payout_status,
all 17 columns including description, impact_score, source_gap_id, etc.)
2. Added ALTER TABLE ADD COLUMN logic for each extra column if the table exists
but is missing columns (handles legacy deployments)
3. Made index creation idempotent via explicit IF NOT EXISTS checks

• Canonical schema is now defined in ONE place: migration 068.

detect_improvements.py, backprop_credit.py, and api.py all reference the same
column set (event_type, target_artifact_type/id, payout_pool, payout_status,
detection_metadata, detected_at, distributed_at, and extras)

• API endpoints verified: GET /api/tokens/backprop/status uses correct columns;

POST /api/tokens/backprop has admin auth gate (Bearer → SHA256 → api_keys → 'admin' perm)

2026-04-11 22:30 UTC — Driver #14 GET endpoint backward-compat fix

• Issue: GET /api/tokens/backprop/status hardcoded SELECT of description,

source_gap_id, source_analysis_id — would fail on DBs created by older
detect_improvements.py runs that used a partial schema (missing those columns)

• Fix applied (api.py api_backprop_status): runtime column detection via

PRAGMA table_info(world_model_improvements) to build a dynamic SELECT that
only includes columns present in the actual DB; result rows are normalized to
the canonical schema with explicit None for missing extra columns

• Authorization: POST /api/tokens/backprop already has admin gate (confirmed)

2026-04-11 23:15 UTC — GH013 push block: root cause identified as pre-existing in origin/main

• Issue: Push rejected with "GH013: Repository rule violations — This branch must not contain merge commits"
• Root cause: origin/main itself contains merge commits in its ancestry (e.g., 174a42d3 "Merge origin/main to reconcile divergence"). The GitHub branch protection rule checks ALL commits reachable from the branch tip, not just new commits. Since 174a42d3 is an ancestor of origin/main's HEAD (eae2674f), ANY branch derived from main will fail this rule.
• Verification:

- git merge-base --is-ancestor 174a42d3 origin/main → IS ancestor
- git rev-list --ancestry-path 174a42d3..origin/main → shows full ancestry path
- Created clean orphan branch from origin/main's tip, cherry-picked only our commit — still rejected

• Confirmed by other tasks: Commit 289e4cfc notes "GH013 pre-existing" and f8916b81 notes "origin/main itself has merges"
• Code status: All 3 merge gate concerns addressed (GET uses correct columns + backward compat, POST has admin auth, migration 068 canonical schema). Implementation is complete.
• Push status: Blocked by GH013 — pre-existing origin/main merge history, not a code issue.

2026-04-11 23:45 UTC — Rebase onto updated main, still blocked by GH013

• origin/main updated with commits 142c292d (timeout fix) and ff1d30a6 (metrics update) while work was in progress
• Rebased onto new origin/main — diff now clean (4 files: api.py, spec, detect_improvements.py, migration 068)
• 174a42d3 confirmed IS ancestor of origin/main HEAD (142c292d) — rule still blocks
• Even force push rejected — rule checks entire ancestry, not just new commits
• Conclusion: GH013 rule on repository is misconfigured; should check for NEW merge commits only, not ancestry. Requires repo admin to fix rule or remove merge commits from main (后者 not possible without rewrite).
• Implementation: Ready for merge once GH013 rule is corrected.

2026-04-12 00:30 UTC — Retry #3: stale log file cleanup

• Files in diff vs origin/main: api.py, migration 068, detect_improvements.py, spec
• GH013 persists: Push still rejected — 174a42d3 merge is pre-existing ancestor in origin/main
• Stale log files removed (12 agent-slot58 logs from old task workspace deleted in origin/main too, now deleted in our branch to avoid spurious diff noise)
• PubMed backlog spec file (a88f4944_cb09...): truncated to remove 7 work-log entries (6th–16th execution) that other agents added to their own copy of the spec; origin/main also has 16 agent logs — this is normal churn from recurring tasks, not our change
• All 3 merge gate items confirmed addressed:

1. GET /api/tokens/backprop/status: PRAGMA column detection, dynamic SELECT, normalized rows
2. POST /api/tokens/backprop: Bearer token → SHA256 → api_keys → 'admin' permission gate
3. Migration 068: CREATE TABLE IF NOT EXISTS with canonical columns, matches live DB schema

• Code is complete; blocked only by GH013 rule misconfiguration on the repository

2026-04-12 12:45 UTC — Retry attempt 4: code verified correct, GH013 persists

• All 3 merge gate items re-verified in current branch:

1. GET /api/tokens/backprop/status: core_cols includes event_type, target_artifact_type,
target_artifact_id, payout_pool; extra cols detected via PRAGMA; dynamic SELECT built
2. POST /api/tokens/backprop: Bearer token → SHA256 → api_keys → 'admin' permission;
returns 401 for missing/invalid keys, 403 for non-admin — no public mutation
3. Migration 068: canonical schema with all 17 columns matches detect_improvements.py and
api.py expectations; ALTER TABLE ADD COLUMN for backward compat

• Diff vs origin/main (4 files, 352 lines): api.py, spec, detect_improvements.py, migration 068
• Branch history: 3 linear commits on origin/main tip — no merge commits introduced by this branch
• GH013 push block: 174a42d3 ("Merge origin/main to reconcile divergence") is a pre-existing

merge commit in origin/main ancestry; GitHub rule checks entire ancestry, not just new commits

• orchestra sync push: fails with sqlite3.OperationalError: unable to open database file when

calling ensure_runtime_schema — unrelated to GH013, environment issue with Orchestra DB access

• Escalating: GH013 is a repository-level misconfiguration; this branch's code is complete and

correct, but cannot be merged until the branch protection rule is fixed or the problematic
merge commit 174a42d3 is removed from origin/main's history (requires repo admin)

2026-04-11 14:00 UTC — Retry attempt 5: code verified, GH013 pre-existing block persists

• All 3 merge gate feedback items re-verified in current branch (2bab255a):

1. GET /api/tokens/backprop/status: dynamic column detection via PRAGMA table_info;
core_cols = event_type, target_artifact_type, target_artifact_id, payout_pool, payout_status,
detected_at, distributed_at; extra cols added if present in DB
2. POST /api/tokens/backprop: Bearer token → SHA256 → api_keys table → 'admin' permission;
returns 401 for missing/invalid keys, 403 for non-admin — no public mutation
3. Migration 068: canonical schema with all 17 columns; CREATE TABLE IF NOT EXISTS is idempotent

• Push result: GH013 still blocks — 174a42d3 merge commit is pre-existing in origin/main ancestry
• Code is complete; push blocked by GH013 pre-existing repository configuration issue

2026-04-12 13:00 UTC — Retry attempt 6: squashed linear branch still blocked

• Created new branch backprop-dr14-v7 from origin/main with squashed commits:

- 38e8670b: migration 068 (new file, 65 lines)
- 5513ae3e: api.py (+131), detect_improvements.py (+83), spec (+121)

• Verified ancestry has no merge commits introduced by this branch:

- fbde4f6c (old merge commit) NOT in new branch
- Only linear commits on top of origin/main

• Push still blocked: GH013 rule on repo checks entire ancestry, not just new commits.

174a42d3 is a merge commit in origin/main's history (pre-existing, not introduced by our branch).
Rule interpretation issue: "must not contain merge commits" should mean "must not introduce
merge commits", not "must not have any merge commit anywhere in ancestry".

• Code verified correct:

- python3 test_backprop_credit.py → 4 tests OK
- Schema: event_type, target_artifact_type, target_artifact_id, payout_pool all present
- Admin gate: Bearer → SHA256 → api_keys → 'admin' permission
- Migration 068: canonical 17-column schema with CREATE TABLE IF NOT EXISTS

• Conclusion: Code complete. GH013 is a repository branch protection misconfiguration that

requires repo admin to fix. The rule should be changed to only check for NEW merge commits
introduced by the branch, not pre-existing merge commits in the base branch ancestry.

2026-04-12 13:15 UTC — Driver #14 execution (task:f4014150-c6f4-4de8-9c2d-ddfbe1b36fcf)

• Execution: python3 -m economics_drivers.backprop_credit --limit 5
• DB state: 3 pending improvements (all hypothesis_matured events targeting gap-debate hypotheses)
• Result: All 3 → orphan (no agent_contributions rows for the hypotheses' analyses)

- hypothesis h-0aecd2de → orphan, pool 200
- hypothesis h-5626c1f2 → orphan, pool 50
- hypothesis h-edfd6c89 → orphan, pool 50

• Root cause of orphans: These hypotheses were auto-generated from gap debates with no agent_contributions recorded — upstream contributors are debate personas (Theorist/Skeptic/etc.) which are stored in debate_rounds.agent_persona but the debate_session link requires hypothesis_debates table which may not have entries
• Code status: backprop_credit.py (444 lines) fully implemented, idempotent, 46 distributed events already processed successfully in prior runs
• DB final state: 46 distributed, 97 orphan, 0 pending

2026-04-12 14:30 UTC — Driver #14 recurring execution (task:f4014150-c6f4-4de8-9c2d-ddfbe1b36fcf)

• Execution: python3 -m economics_drivers.backprop_credit --limit 20
• Result: no-op — all 140 pending improvements already processed (46 distributed, 97 orphan, 0 pending)
• Idempotency verified: re-running produces no-op as expected; driver marks improvements 'distributed' on success, 'orphan' if no upstream agents found
• DB state: 0 pending, 46 distributed, 97 orphan in world_model_improvements
• Status: Driver #14 is fully operational and idempotent. Next run in ~2h via Orchestra recurring task.
• Execution: python3 -m economics_drivers.detect_improvements --dry-run --limit 50
• Result: no-op — no new world-model improvements detected (idempotent, all events already captured)
• DB state at runtime:

- knowledge_gaps: 2 resolved, 157 partially_addressed, 3074 open, 26 investigating
- artifact_links analyses: 296,630 rows (citation targets)
- hypotheses: 335 total, max confidence 0.9
- world_model_improvements: 140 rows already captured

• Detector status: All 3 detectors operational (gap_resolved, citation_threshold, hypothesis_matured)
• Next run: in ~2 hours via Orchestra recurring task [task:428c719e-a95a-40ca-8d8c-cba13e2f60cf]

2026-04-12 ~14:45 UTC — Driver #13 recurring cycle [task:428c719e-a95a-40ca-8d8c-cba13e2f60cf]

• Execution: python3 -m economics_drivers.detect_improvements --limit 100
• Result: no-op — no new world-model improvements detected (gap_resolved=0, citation_threshold=0, hypothesis_matured=0)
• High-water marks: gap_resolved_max_id=gap-senescent-clearance-neuro, hypothesis_matured_last_id=h_seaad_004
• DB state: world_model_improvements has 143 rows (46 distributed, 97 orphan, 0 pending)

- knowledge_gaps: 2 resolved (no new since last cycle)
- hypotheses: 88 with confidence ≥ 0.7 (no new entries since last high-water mark)

• Idempotency confirmed: all 3 detectors scanning from high-water marks, no duplicate events written

2026-04-12 — Driver #13 recurring cycle + fix [task:428c719e-a95a-40ca-8d8c-cba13e2f60cf]

• Bug identified: _detect_confidence_growth used a high-water mark on hypothesis id to skip rows already seen. This missed 4 hypotheses whose confidence_score was later updated to ≥0.7 (92 eligible vs 88 detected). The high-water-mark approach is correct for append-only tables but wrong for mutable scores.
• Fix: Removed the high-water mark filter from _detect_confidence_growth; switched to a full scan of all hypotheses with confidence_score >= 0.7. Dedup relies entirely on _exists() (already in place). Table has ~350 rows — full scan is negligible.
• Result after fix: hypothesis_matured=4 (the 4 previously missed hypotheses now detected)
• DB state: world_model_improvements has 147 rows (46 distributed, 97 orphan, 4 pending)
• Idempotency: re-running produces 0 new events — dedup confirmed

2026-04-12 — Driver #15: Quadratic Funding Allocator [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Implemented economics_drivers/quadratic_funding.py (489 lines) — full

Buterin/Hitzig/Weyl QF mechanism for knowledge gap research grants

• Formula: match(gap) = (Σ √cᵢ)² normalized to 500-token matching pool per 6h round
• Agent contribution logic: 2% of wallet balance (cap 20 tokens), spread across

top-2 gaps from agent_contributions → analyses → knowledge_gaps provenance;
falls back to highest-priority open gaps when agent has no gap history

• Gap bounty pools: direct + matched tokens credited to gap_bounty:<gap_id>

token_accounts entries

• Tables: gap_funding_contributions(id, timestamp, agent_id, gap_id, amount, tier,

matching_amount, total_allocation) and gap_funding_rounds — mirrors migration 069

• Idempotency: round number increments each run; _ensure_schema() is safe before

migration 069 applies; --dry-run computes without writing

• Tests: 16/16 pass — formula math (single contributor, whale-vs-consensus, 9×

amplification ratio), dry-run no-write guarantee, wallet debit, gap pool credit,
round recording, MIN_BALANCE filter, round number increment

• Key property verified: 9 agents × 1 token → 81 QF score; 1 agent × 9 tokens → 9.

Same spend, 9× more matching for the consensus-backed gap.

2026-04-12 — Driver #17: Token Demurrage Sweep [task:21ef1f77-5b0c-4d00-81af-ddfcf08ce9f9]

• Implemented economics_drivers/token_demurrage.py (267 lines) — Gesell's Freigeld

demurrage mechanism sweeping idle wallets daily

• Algorithm: query all non-exempt wallets with balance ≥ 1 token; for each, look up

most recent non-demurrage token_ledger entry (from OR to); if idle > 24h → deduct
balance × 0.001 (0.1 %/day); credit deducted tokens to system pool account

• Idempotency: demurrage_rounds(sweep_date UNIQUE) table guards against double-runs

on the same UTC calendar day; safe to re-run repeatedly

• Exempt accounts: system, qf_matching_pool, MINTED, and any account prefixed

with gap:, gap_bounty:, market:, squad:, demurrage_

• Ledger entries: two entries per charged wallet — reason='demurrage' (debit) and

reason='demurrage_receipt' (system credit) — full audit trail in token_ledger

• Table: demurrage_rounds(id, sweep_date, started_at, completed_at, wallets_charged,

total_charged, status) with UNIQUE index on sweep_date

• Dry-run verified: 18 idle wallets / 42 eligible — 3.89 tokens → system pool;

24 active wallets exempt from decay

2026-04-12 — Driver #16: Calibration Slashing [task:c3a426dc-ea93-4148-84b5-b83e3e1aaf24]

• Implemented economics_drivers/ci_calibration_slashing.py (451 lines) — Brier-score

reputation slashing for miscalibrated forecasters (Tier 1 #3)

• Algorithm: for each settled position, compute Brier score:

LONG (entry_price - resolution_price)^2, SHORT ((1-entry_price) - resolution_price)^2.
If Brier > 0.25: burn 5% staked tokens → system pool; decrement reputation_score by 0.02

• Idempotency: UNIQUE(position_id) guards double-slashing; failed burns retried without

re-applying reputation; ledger entry check prevents double-burns; 50 min interval guard

• Self-test: 12-case Brier score regression suite (long/short, calibrated/miscalibrated) — all PASS
• Dry-run verified: 1 settled position in DB; Brier <= 0.25 (well-calibrated) → no slash
• Follows token_demurrage/quadratic_funding driver patterns: direct SQL, SCIDEX_DB env var,

--dry-run/--stats/--test CLI flags, python3 -m economics_drivers.ci_calibration_slashing

2026-04-12 21:40 UTC — Driver #16 recurring cycle [task:c3a426dc-ea93-4148-84b5-b83e3e1aaf24]

• Execution: python3 -m economics_drivers.ci_calibration_slashing
• Result: 1 settled position evaluated, 0 slashes applied (Brier ≤ 0.25 — forecaster is well-calibrated)
• Stats: total_slashes=0, total_tokens_slashed=0.0 — no miscalibrated positions to penalize
• Self-test: 12/12 Brier score regression cases PASS
• Idempotency confirmed: 50-min guard prevents double-runs; calibration_slashing table guards per-position

2026-04-12 22:45 UTC — Driver #16 recurring cycle [task:c3a426dc-ea93-4148-84b5-b83e3e1aaf24]

• Execution: python3 -m economics_drivers.ci_calibration_slashing
• Result: 1 settled position evaluated, 0 slashes applied (Brier ≤ 0.25 — forecaster well-calibrated)
• Self-test: 12/12 Brier score regression cases PASS
• Stats: total_slashes=0, total_tokens_slashed=0.0 — no miscalibrated positions
• Idempotency: 50-min guard + per-position UNIQUE constraint both operational

2026-04-12 19:37 UTC — Driver #14 cycle + provenance bug fix [task:f4014150-c6f4-4de8-9c2d-ddfbe1b36fcf]

• Bug identified: _walk_provenance for analysis artifacts only traversed hypotheses.analysis_id

but not debate_sessions.analysis_id. Since debate_sessions has a direct analysis_id FK (and
many analyses have debate sessions but no agent_contributions rows), 101/143 improvements were
falsely marked orphan — the walk ran out of edges before reaching debate_rounds.agent_persona.

• Fix applied (backprop_credit.py): added debate_sessions.analysis_id traversal in the

analysis branch of _walk_provenance, appending found sessions to the BFS frontier before
walking hypotheses. This is correct: analysis → debate_session is a valid provenance edge.

• --reset-orphans flag added: _reset_recoverable_orphans() re-walks each orphan row;

if the corrected walk finds ≥1 agent, resets payout_status = 'pending' so the current cycle
can distribute. Idempotent — rows with no reachable agents stay orphan.

• Cycle result (3 passes with --reset-orphans --limit 50):

- 99 orphans reset → pending, 99 distributed
- 19,942 total tokens distributed to 409 agent-credits across 99 previously-stuck improvements
- 2 genuine orphans remain (no agents reachable even via corrected walk)

• DB final state: 145 distributed, 2 orphan, 0 pending in world_model_improvements
• Breakdown by event type: gap_resolved 3000, citation_threshold_high 1998,

citation_threshold_medium 6203, hypothesis_matured 8741 tokens distributed

2026-04-12 16:52 UTC — Driver #16 recurring cycle [task:c3a426dc-ea93-4148-84b5-b83e3e1aaf24]

• Execution: python3 -m economics_drivers.ci_calibration_slashing
• Result: 1 settled position evaluated, 0 slashes applied (Brier ≤ 0.25 — forecaster well-calibrated)
• Self-test: 12/12 Brier score regression cases PASS (all LONG/SHORT calibrated/miscalibrated cases)
• Stats: total_slashes=0, unique_agents_slashed=0, total_tokens_slashed=0.0
• Status: Driver #16 fully operational; clean no-op as expected when all forecasters are calibrated

2026-04-13 UTC — Driver #15 cycle round 7 [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Execution: python3 economics_drivers/quadratic_funding.py
• Result: round 7 — 44 agents funded 1 gap; 499.1 direct + 500.0 matched tokens allocated
• Top gap: gap-debate-20260412-094638-cd9ef05d
• QF amplification: broad consensus mechanism operational — 44 contributors pooling

small amounts receive significantly more matching than a single large contributor would

• Tables updated: gap_funding_contributions (44 direct rows + 1 match row),

gap_funding_rounds (round 7 recorded), token_accounts (gap bounty pool credited)

• Merge status: commit 7839b732c is IN remote main (ancestry: 4535366b→...→ea435d6f→7839b732c).

Refinery merge gate failed (GH013: 174a42d3b merge commit is in full GitHub ancestry of all
current main commits). Task work is complete; tracking loop broken due to systemic GH013 blocker.

2026-04-13 UTC — Driver #15 cycle round 8 [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Execution: python3 economics_drivers/quadratic_funding.py
• Result: round 8 — 43 agents funded 1 gap; 494.4 direct + 500.0 matched tokens allocated
• Top gap: gap-debate-20260412-094638-cd9ef05d (same gap, slight contributor drop)
• GH013 blocker: cannot push task branch; GitHub "no merge commits" rule finds 174a42d3b

in full ancestry of all commits derived from current main. Admin fix required to resolve.

2026-04-13 UTC — Driver #15 cycle round 9 [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Execution: python3 -m economics_drivers.quadratic_funding
• Result: round 9 — 43 agents funded 1 gap; 490.5 direct + 500.0 matched tokens allocated
• Top gap: gap-debate-20260412-094638-cd9ef05d (consensus sustained across 9 cycles)
• Cumulative QF activity: 9 rounds completed, consistent broad-consensus amplification
• Tables updated: gap_funding_contributions, gap_funding_rounds, token_accounts

2026-04-13 UTC — Driver #15 cycle round 10 [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Execution: python3 -m economics_drivers.quadratic_funding
• Result: round 10 — 43 agents funded 1 gap; 486.7 direct + 500.0 matched tokens allocated
• Top gap: gap-debate-20260412-094638-cd9ef05d (consensus sustained across 10 cycles)
• Cumulative QF activity: 10 rounds completed; agent wallets steadily funding same consensus gap
• Tables updated: gap_funding_contributions, gap_funding_rounds, token_accounts

2026-04-16 13:14 UTC — Driver #16 calibration slashing fix + first run [task:c3a426dc-ea93-4148-84b5-b83e3e1aaf24]

• Execution: python3 economics_drivers/ci_calibration_slashing.py
• Bug fixed: sys.path.insert(0, '/home/ubuntu/scidex') pointed to main repo (no token_ledger.py there).

Fixed to derive worktree root from __file__ so token_ledger shim is found.
Also made DB_PATH configurable via SCIDEX_DB env var with postgresql://scidex as default.

• DB: Live production DB at postgresql://scidex (~4GB); worktree has only 28KB stub
• Regression tests: All 12 Brier-score test cases PASS (long/short positions, threshold boundary)
• Result: 1 settled position evaluated (hyp-test-002: entry=0.5, settlement=0.7 → Brier=0.04 < 0.25).

No slashing applied. calibration_slashing table has 0 records.

• Status: Driver is functional. No positions exceed Brier > 0.25 threshold in current DB.

2026-04-20 ~11:30 UTC — Driver #15 PG compatibility fix [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Issue: Driver crashed on PostgreSQL DB (via PGShimConnection) — executescript not supported, INSERT OR IGNORE is SQLite-only syntax, ORDER BY in SELECT DISTINCT requires column to also be in select list (PostgreSQL stricter than SQLite).
• Fixes applied (economics_drivers/quadratic_funding.py):

1. _ensure_schema: Replaced executescript multi-statement with individual conn.execute() calls — executescript doesn't exist on PGShimConnection.
2. _get_agent_gaps: Wrapped SELECT DISTINCT in a subquery so ORDER BY ac_id DESC can reference the selected alias — fixes InvalidColumnReference error in PostgreSQL.
3. INSERT OR IGNORE: Replaced with INSERT ... ON CONFLICT (id) DO NOTHING — PostgreSQL upsert syntax.

• Result: Dry-run passes and live run succeeds — round 18 completed (50 agents, 1 gap funded, 664.7 direct + 500.0 matched tokens).
• Pushed: branch orchestra/task/2bb1d0cd-quadratic-funding-allocator-driver-15 committed and pushed.

2026-04-21 10:55 PT — Driver #15 pool-account eligibility fix [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Cycle run: python3 -m economics_drivers.quadratic_funding completed round 27 (50 contributors, 1 gap funded, 657.1 direct + 500.0 matched tokens) for gap-debate-20260417-033236-0fe26d91.
• Issue found: _get_eligible_agents only excluded system, so high-balance pool accounts such as gap_bounty:, dataset_pool:, squad:, and tournament: were selected as contributors and auto-funded fallback gaps.
• Fix: restrict driver #15 eligibility to actor-like wallets by excluding known pool/system namespaces, while preserving model/agent accounts such as glm-5:60; added a regression test covering pool-account exclusion.

2026-04-18 ~01:00 UTC — Driver #13 recurring cycle [task:428c719e-a95a-40ca-8d8c-cba13e2f60cf]

• Issue: Database corruption in hypotheses table (B-tree pages 344, 415, etc. returning error 11: "database disk image is malformed"). Affected _detect_confidence_growth and _detect_hypothesis_promoted which used ORDER BY id ASC — forced SQLite to traverse corrupted index pages.
• Root cause: The hypotheses table has partial B-tree page corruption affecting the id-indexed access path. Simple queries with LIMIT ≤44 work; ORDER BY or high limits trigger corrupted pages.
• Fix applied (economics_drivers/detect_improvements.py):

- _detect_confidence_growth: Replaced direct query with rowid-based CTE pagination. Uses WITH batch AS (SELECT rowid FROM hypotheses WHERE confidence_score >= 0.7 AND rowid > ? ORDER BY rowid ASC LIMIT ?), then JOINs back to get full rows. SAFE_BATCH=44. Tracks progress via confidence_growth_last_rowid in state batch.
- _detect_hypothesis_promoted: Same rowid-based CTE approach. SAFE_BATCH=30. Tracks progress via hypothesis_promoted_last_rowid.

• Execution: python3 -m economics_drivers.detect_improvements (non-dry-run)
• Result: hypothesis_promoted=6 (6 new events detected and written as pending)
• DB state: world_model_improvements now has 263 rows (254 distributed, 3 orphan, 6 pending)
• Status: Driver #13 operational with corruption workaround. Next run in ~6h via Orchestra.

2026-04-20 11:21 UTC — Driver #16 PostgreSQL compatibility fix [task:c3a426dc-ea93-4148-84b5-b83e3e1aaf24]

• Issue: Driver crashed with RecursionError: maximum recursion depth exceeded on PostgreSQL DB. Root cause: the local get_db() wrapper called get_db() from scidex.core.database (imported as from scidex.core.database import get_db) creating infinite recursion. Also used SQLite-only syntax (sqlite_master, datetime('now'), PRAGMA, sqlite3.Row).
• Fixes applied (economics_drivers/ci_calibration_slashing.py):

1. Removed local get_db() wrapper — uses scidex.core.database.get_db directly (PGShimConnection, no close needed)
2. Replaced sqlite_master with pg_catalog.pg_tables (PostgreSQL system catalog)
3. Replaced datetime('now') with Python-side _pg_compat_now() using datetime.now(timezone.utc).strftime() — passed as explicit parameter
4. Removed PRAGMA journal_mode=WAL and PRAGMA busy_timeout (PostgreSQL handles these natively)
5. Removed sqlite3.Row row factory (PGShimConnection returns dict-like objects natively)
6. Removed sqlite3.IntegrityError catch — replaced with generic Exception that checks for duplicate-key keywords
7. Removed db.close() calls throughout (PGShimConnection manages its own pool)
8. Removed sqlite3 import (only used for type annotations that are now removed)
9. Changed CREATE INDEX IF NOT EXISTS to CREATE INDEX (PostgreSQL is idempotent; IF NOT EXISTS unnecessary)
10. Changed ensure_calibration_slashing_table default from (datetime('now')) to (CURRENT_TIMESTAMP) for PostgreSQL compat

• Execution: python3 -m economics_drivers.ci_calibration_slashing → runs successfully against PostgreSQL; 1 settled position evaluated, 0 slashes (Brier ≤ 0.25)
• Regression tests: 12/12 PASS (long/short, calibrated/miscalibrated cases)
• Status: Driver now fully PostgreSQL-compatible. Pushed to orchestra/task/c3a426dc-calibration-slashing-for-miscalibrated-f

2026-04-22 12:18 UTC — Driver #15 recurring cycle round 30 [task:2bb1d0cd-2672-4286-b532-8ed2ebc4e59a]

• Preflight: python3 -m economics_drivers.quadratic_funding --dry-run projected round 30 with

50 agents funding 1 gap; python3 -m py_compile economics_drivers/quadratic_funding.py passed;
QF formula smoke test confirmed 9× consensus amplification over a same-spend single contributor.

• Execution: python3 -m economics_drivers.quadratic_funding
• Result: round 30 completed — 50 agents funded 1 gap; 697.1 direct + 500.0 matched tokens allocated.
• Top gap: gap-debate-20260417-033236-0fe26d91
• Verification: gap_funding_rounds has 30 rows, gap_funding_contributions has 1,217 rows,

and the round recorded 51 ledger entries for the agent debits plus gap bounty pool credit.