Set 12 Prediction Market Board Bundle

The board bundle runs one copied market projection

A copied presentation-mart source runs over synthetic prediction-market and source-feed fixtures to check the board keeps guesses labelled as guesses. This component takes a copied presentation-mart source file, runs it over synthetic prediction-market and source-feed fixtures, and checks that the board keeps guesses labelled as guesses. It does not read live markets and it does not say what any price means.

Fixture rows exercise ordering and visibility rules

The bundle stubs the private imports, loads quant_presentation_mart.py from disk, and calls seven helpers, each against a fixture built to expose one way a board misleads. The copied source is system/lib/quant_presentation_mart.py. That file has private imports the public clone cannot satisfy, so the bundle stubs those imports, loads the module from disk, and calls seven of its helper functions directly. Each call is checked against a fixture built to expose one specific way a board can mislead.

A passing board is not a live market

The output carries per-mechanism status, computed negative cases, and an scope limit as diagnostic rows, never source bodies or model-output data. The output is a result record with per-mechanism status, the named negative cases it computed, and an scope limit. It carries diagnostic rows, not source bodies and not model-output data.

Purpose

How loose aggregation fakes a fact

The shared failure mode is a row that looks like a fact but is an aggregation artifact: a doubled volume, a fabricated id, a false-healthy feed. Market and source dashboards share a failure mode: a row looks like a fact when it is really an artifact of loose aggregation. A duplicate listing doubles a volume figure. An unmatched market slug is handed a fabricated event identity. A feed returns zero rows but shows as healthy. A "change since last time" number appears with no prior run to compare against. A vintage date is displayed when the lifecycle data never carried one.

Asserting the exact conservative behaviour

The bundle runs the real helper bodies over synthetic inputs and asserts the exact conservative behaviour rather than trusting a silent default. The single question here is whether the copied presentation logic keeps those distinctions honest when run over public synthetic inputs. Loose aggregation fails silently: it defaults a missing value to a confident zero, or gives an orphan slug a synthetic id. This bundle runs the real helper bodies and asserts the exact conservative behaviour instead.

How it works

The pipeline and its two entry points

The pipeline is a fixture load, stubbed import, seven helper calls, and eight invariant checks, and both entry points forward to run_crown_jewel_organ. The pipeline is a fixture load, a stubbed source import, seven helper calls, and eight invariant checks. run and run_batch12_prediction_market_board_bundle both forward to run_crown_jewel_organ with _evaluate as the evaluator and evaluate_negative_case as the negative-case evaluator. The bundle entrypoint differs only by input mode.

Resolving and importing the copied source

_source_manifest_for_input resolves the manifest and _load_source_module reads it to find and import quant_presentation_mart.py from its file location. _source_manifest_for_input resolves the source manifest. It prefers a source_module_manifest.json sitting in the input directory, and otherwise points at the exported bundle manifest under the public root. _load_source_module reads that manifest through _source_target to find system/lib/quant_presentation_mart.py, then imports it from its file location.

Scoped stand-in modules in _quant_mart_import_stubs

Lightweight stand-in modules are injected into sys.modules so the copied source loads, then restored on exit so the stub stays scoped to the import. _quant_mart_import_stubs is the context manager that makes the copied source loadable. The source imports system.lib.market_feed_run_evidence, system.lib.market_fusion_readiness, and system.lib.finance_numeric_assurance. The bundle injects lightweight stand-in modules for those names into sys.modules, including a FEED_NODE_IDS list of global_stock_feed, global_news_feed, and global_macro_feed. On exit it restores whatever modules were there before, so the stub is scoped to the import.

Three prediction-market invariants in _evaluate

_evaluate calls _prediction_market_board and checks three invariants: the duplicate fold, the orphan with no fabricated identity, and the deduped aggregate. _evaluate runs the prediction-market half. It loads prediction_market_rows.json, polymarket_identity_artifact.json, and quant_mart_helper_cases.json, then calls the source function _prediction_market_board with the Polymarket identity artifact. The board rows are keyed by event_identity_status. The available event and the missing_from_feed_artifact orphan drive three checks: the surviving market has volume 900000.0 with a market count of 1 (the duplicate fold), the orphan has a null event_id and an aggregate max_liquidity of 0.0 (no fabricated identity), and the deduped aggregate reports market_count 1 and max_volume 900000.0.

Five source-feed invariants across four helpers

Four source helpers check drift flags kept separate from FRED flags, missingness states, an unavailable delta with no baseline, and vintage bound to the structured source record. _evaluate_quant_mart_helpers runs the source-feed half against four more source functions. _provider_drift_monitor produces per-feed drift flags: the stock feed must carry provider_fallback_used, html_response_seen, and fetch_failures, the news feed must stay empty, and the source feed must carry the FRED-specific fred_invalid_series and fred_network_warning. Keeping the generic transport flags separate from the FRED flags means a source data-source fault is not laundered into a generic warning. _missingness_board lists only feeds that are not both populated and ok: the healthy feed is absent, the empty feed reads zero_rows, the degraded feed reads quality_degraded. _delta_since_previous_green returns status: unavailable with an empty row_deltas_by_lane when no prior green run exists. _macro_regime_board, fed by _macro_lifecycle_by_slug, binds each bucket's vintage_status to whether the lifecycle structured source record carries it: the inflation bucket reads available with observation date 2026-05-01, and the growth bucket, whose lifecycle row is absent, reads missing_from_feed_artifact.

Findings, negative-case scoring, and the card

A failed check becomes a finding that flips the status to blocked, evaluate_negative_case scores each case, and result_card projects a metadata-only card. Any check that does not hold becomes a structured finding through finding, and the result status flips from pass to blocked. evaluate_negative_case re-runs _evaluate, pulls the matching case row with _computed_case_row, and returns a blocked result with the expected stable error codes when the invariant held, a pass when it did not, or an error record if the run raised. result_card projects the result into a public card carrying mechanism_count, computed_negative_case_count, and an authority floor read from AUTHORITY_CEILING, with body_in_receipt false throughout.

flowchart TD Input["Fixture inputs rows, identity, helper cases"] --> Manifest["_source_manifest_for_input"] Manifest --> Load["_load_source_module via _quant_mart_import_stubs"] Load --> Eval["_evaluate"] Eval --> Board["_prediction_market_board dedup + orphan + aggregate"] Eval --> Helpers["_evaluate_quant_mart_helpers"] Helpers --> Drift["_provider_drift_monitor generic vs FRED flags"] Helpers --> Miss["_missingness_board zero_rows vs quality_degraded"] Helpers --> Delta["_delta_since_previous_green unavailable with no baseline"] Helpers --> Source["_macro_regime_board vintage bound to structured source record"] Board --> Card["result_card status, negative cases, ceiling"] Drift --> Card Miss --> Card Delta --> Card Source --> Card

Negative cases

Eight named cases as required rejections

EXPECTED_NEGATIVE_CASES binds three prediction-market and five source-feed cases to stable error codes, each a rejection the board must make or fail loudly. EXPECTED_NEGATIVE_CASES declares eight named cases, each bound to a stable error code. The three prediction-market cases are duplicate_lower_volume_retained_higher, orphan_slug_no_identity_fabrication, and aggregate_count_and_max_volume_deduped. The five source-feed cases are provider_drift_multisignal_flags, provider_drift_fred_diagnostics_flags, missingness_zero_row_lane_flagged, delta_no_previous_green_unavailable, and macro_lifecycle_vintage_status_bound. A case is a rejection the board must make: keep the higher-volume duplicate, refuse to invent an event id, flag the empty feed, withhold the delta with no baseline, and show a vintage date only when it is real. When an invariant does not hold, the run emits BATCH12_PREDICTION_CASE_NOT_OBSERVED or BATCH12_QUANT_MART_HELPER_CASE_NOT_OBSERVED rather than reporting a silent pass.

Prior Art Grounding

Information-aggregation and provider-join shape

The board borrows the information-aggregation and provider-join shape from prediction-market practice but stays explicitly diagnostic, treating no price as truth. The component borrows the information-aggregation and provider-join shape from prediction-market and public market-data practice, then keeps the board explicitly diagnostic. Relevant anchors include Robin Hanson's information markets framing, where markets aggregate dispersed information about uncertain events; the CFTC's prediction markets explainer, which frames event contracts, market prices, and consumer cautions; and the Polymarket API documentation as a concrete public API family for market, event, and series data. This bundle uses the join and identity-matching shape and nothing else: no price is treated as truth.

Validation Result record Path

Reader-verifiable commands, run from the microcosm-substrate/ public root:

What the commands and test verify

The fixture and bundle commands and the focused test validate the manifest, seven helper calls, and eight cases, and a pass means conservative diagnostics held. The fixture command writes the board result and sign-off record. The bundle command validates the copied source manifest, the seven helper calls, and metadata-only posture. The focused test checks fixture validation, bundle validation, and the eight named cases. A pass means the copied logic produced the expected conservative diagnostics over the synthetic fixtures. Validation result records for this module are the records those commands write.