Reference index

Verifies the first-run guided path so every step names a real command, doc, and evidence.

cold_reader_route_map Entry & orientation Source

Binds the first-time reader tour to evidence so each count leads to a source.

public_reveal_walkthrough Entry & orientation Source

Checks a real pattern catalog for digest, cross-reference, and dependency-cycle integrity.

pattern_binding_contract Architecture & navigation Source

Verifies each landed task filed exactly one learning record naming what it changed.

pattern_assimilation_step Architecture & navigation Source

Checks that example standards files declare their purpose, rule, records, and what they do not claim.

executable_doctrine_grammar Architecture & navigation Source

Audits a folder's navigation so browse rows never pose as the source of truth.

navigation_hologram_route_plane Architecture & navigation Source

Confirms every accepted part still ties to a written rule, a run command, and a saved proof.

standards_meta_diagnostics Architecture & navigation Source

Verifies each lesson changed a named owner page with evidence before the loop closes.

voice_to_doctrine_self_improvement_loop Architecture & navigation Source

Checks the catalog of named thinking-moves so each is fully described and backed by evidence.

cognitive_operator_registry Architecture & navigation Source

Indexes the navigation mistakes agents repeat and guards the public list.

routing_anti_patterns_registry Architecture & navigation Source

Checks that public fact rows state the right count and point at live, anchored code.

doctrine_fact_claim_audit Architecture & navigation Source

Compares expected against built entities to report known coverage gaps.

self_ignorance_coverage_ledger Architecture & navigation Source

Measures a navigation result against its target for recall, precision, and speed on public examples.

navigation_fitness_benchmark Architecture & navigation Source

Runs a keyword-overlap match that ranks catalog entries, shows why each matched, and admits when none do.

annex_knowledge_routing Architecture & navigation Source

Runs the Lean verifier over a small public proof project and reports which rows it accepted.

certificate_kernel_execution_lab Formal math & proof Source

Compiles a tiny Lean example with the real prover and records whether it built, leaking no proof text.

formal_math_lean_proof_witness Formal math & proof Source

Runs Lean on small bounded proof attempts in a temp copy and records what passed or failed.

verifier_lab_execution_spine Formal math & proof Source

Runs the real Lean toolchain to confirm the math library is absent, then gates proof tasks.

corpus_readiness_mathlib_absence_gate Formal math & proof Source

Checks fourteen proof, control, and runtime parts as one unit that rejects every overclaim.

batch4_proof_authority_runtime Formal math & proof Source

Sorts proof-pipeline checks into accepted or rejected without inflating a pass.

proof_diagnostic_evidence_spine Formal math & proof Source

Reads declared math setups and lists which proof tactics may be attempted versus blocked.

formal_math_readiness_gate Formal math & proof Source

Picks a first-guess proof strategy from a problem's tags and flags any it cannot map.

mathematical_strategy_atlas_hypothesis_scorer Formal math & proof Source

Maps which Lean proof tactics a recorded run marked usable before any code relies on one.

tactic_portfolio_availability_probe Formal math & proof Source

Records an allow-or-reject decision and reason for each proof tactic before any proof runs.

target_shape_tactic_routing_gate Formal math & proof Source

Lists a fixed catalog of public Lean building blocks and confirms none hides proof text or test answers.

lean_std_premise_index Formal math & proof Source

Shows which lemmas a plain search surfaces per query, and never leaks proof text or answer keys.

formal_math_premise_retrieval Formal math & proof Source

Replays how a proof lab turns verifier failures into fixes, with no promotion without a fresh re-run.

formal_math_verifier_trace_repair_loop Formal math & proof Source

Resolves each proof-flavored math claim to named evidence and flags ones that overreach or lack backing.

formal_evidence_cell_anchor_resolver Formal math & proof Source

Detects when a checked Lean proof cites a library result outside its approved set.

undeclared_library_prior_symbol_classifier Formal math & proof Source

Scores how much proof support a premise search found, problem by problem.

ring2_premise_retrieval_precision_recall_harness Formal math & proof Source

Folds nine proof checks into one report labeling each line by which source actually backs it.

verifier_lab_kernel Formal math & proof Source

Checks a synthetic change-authorization record for its proof-and-approval chain, bound to a real commit.

proof_derived_governed_mutation_authorization Formal math & proof Source

Computes an exact-arithmetic denominator-order identity and catches forged ones, not the open Erdos problem.

finite_erdos_denominator_certificate_strike Formal math & proof Source

Finds tactic scripts the real Lean prover accepts on toy theorems, and refuses proofs that cheat.

lean_proof_search_lab_runtime Formal math & proof Source

Runs real git and pytest on a sample repo so wrap-up claims state only what the evidence proves.

agent_closeout_faithfulness_audit Agent reliability & safety Source

Drafts proposed work from coverage gaps and proves it cannot repair or rewrite the code itself.

bounded_autonomy_campaign_packet Agent reliability & safety Source

Runs the real context harness to measure assembled byte sizes and check each bundle fits its budget.

provider_context_recipe_budget_policy Agent reliability & safety Source

Runs a copied route-quality simulator and checks its all-B scorecard against the original code.

batch10_cold_eval_honesty_capsule Agent reliability & safety Source

Runs the real validator code over public examples so its safety checks stay inspectable.

batch8_validator_checker_capsule Agent reliability & safety Source

Runs eight trace, graph, and market engines on test rows without fetching live markets.

batch7_secondary_runtime_capsule Agent reliability & safety Source

Validates a synthetic benchmark-integrity record and flags the contamination cases it declares.

agent_benchmark_integrity_anti_gaming_replay Agent reliability & safety Source

Replays honest and deceptive agent runs and flags any verdict missing its declared backing evidence.

agent_monitor_redteam_falsification_replay Agent reliability & safety Source

Audits a hidden-goal catch claim for the steps, suspicion scores, and counterfactual it needs.

agent_sabotage_scheming_monitor_replay Agent reliability & safety Source

Replays a memory edit-and-delete to show stale facts get flagged before they sway an answer.

agent_memory_temporal_conflict_replay Agent reliability & safety Source

Replays a recorded memory-tamper case, checking its declared quarantine, block, and delete steps line up.

sleeper_memory_poisoning_quarantine_replay Agent reliability & safety Source

Audits a recorded tool-use log to confirm each action was scoped, approved, undoable, and fenced.

mcp_tool_authority_replay Agent reliability & safety Source

Checks that each step reward in a recorded run cites a declared verifier-feedback row, not a trick.

belief_state_process_reward_replay Agent reliability & safety Source

Maps sandboxed agent actions to show each was approved or blocked before running, then rolled back.

agent_sandbox_policy_escape_replay Agent reliability & safety Source

Replays an agent run to show untrusted text was gated before any sensitive action, leaking no secret.

indirect_prompt_injection_information_flow_policy_replay Agent reliability & safety Source

Checks a fixed-bug evidence chain and re-runs three small real security checks; no real attack material.

agentic_vulnerability_discovery_patch_proof_replay Agent reliability & safety Source

Recomputes an agent run's route-compliance score and anti-pattern flags with real trace-analytics code.

agent_route_observability_runtime Agent reliability & safety Source

Runs shape checks on a fan-out work plan for unique steps, dependencies, and no cycles, not the plan itself.

bridge_campaign_dag_validation Agent reliability & safety Source

Runs a scratch-database model of a durable job queue and flags impossible states for a human to review.

metabolism_queue_reconciliation Agent reliability & safety Source

Runs phrase-membership checks on an agent's own replies for three self-policing slips, not deep meaning.

egress_self_compliance_audit Agent reliability & safety Source

Runs econometric forecast-evaluation tests on synthetic fixtures, recording p-values and refusals with no advice.

finance_forecast_evaluation_spine Research & science Source

Replays imported quant market math on test rows, with duplicate retention and seven refusals.

batch12_prediction_market_board_capsule Research & science Source

Runs a copied market-dashboard reader to catch broken links, stale feeds, and trading overclaims.

batch12_market_dashboard_read_model_capsule Research & science Source

Records which model features drove an answer, each tied to checkable evidence.

mechanistic_interpretability_circuit_attribution_replay Research & science Source

Replays six what-if robotics scenes to show what a spatial prediction claim is built from.

spatial_world_model_counterfactual_simulation_replay Research & science Source

Audits whether a paper-replication claim carries the full evidence trail.

research_replication_rubric_artifact_replay Research & science Source

Replays a self-driving lab loop as records, with safety gates and no real chemicals, robot, or lab.

materials_chemistry_closed_loop_lab_safety_replay Research & science Source

Replays a forecast against the discipline a careful predictor would have to defend.

prediction_oracle_reconciliation Research & science Source

Fills in facts from simple recipes and records a clear error when one points at missing data.

derived_fact_provider_runtime Research & science Source

Gates private-to-public imports, accepting only files with matching fingerprints and sources.

macro_projection_import_protocol Import & drift control Source

Pinpoints where a projected world-model copy drifted from its real source, with repair routes.

world_model_projection_drift_control_room Import & drift control Source

Exposes eleven real but under-surfaced parts and rejects non-public-state and overclaim cases.

batch6_unsurfaced_primitives_capsule Import & drift control Source

Replays eight authority and systems checks, rejecting provider, proof, and launch overclaims.

batch5_authority_systems_capsule Import & drift control Source

Runs fifteen trace, code-map, and scheduling engines on test data, blocking truth overclaims.

batch7_macro_engines_capsule Import & drift control Source

Replays subject-index and truth-diff logic on copied code, rejecting reasoning overclaims.

batch7_oracle_sibling_capsule Import & drift control Source

Replays the recording console's Swift logic without launching the app or capturing audio.

batch7_demo_take_console_capsule Import & drift control Source

Exercises four copied helper tools over fixed inputs without touching live systems or data.

batch8_tools_tail_primitives_capsule Import & drift control Source

Maps three policy engines over test data without model calls or live campaign execution.

batch8_policy_engines_capsule Import & drift control Source

Computes the audio loudness math on test arrays without opening a microphone or capturing input.

batch8_audio_level_rms_port Import & drift control Source

Runs a copied finance-thesis model through dated test cases with no live market data or advice.

batch8_structural_theses_capsule Import & drift control Source

Runs proof, runtime, security, and routing demos through bounded public examples with stated limits.

engine_room_demo Import & drift control Source

Exercises thirteen copied backend and governance engines over fixed public test cases.

batch9_macro_engines_capsule Import & drift control Source

Checks thirteen copied governance and compiler routines against the code they were copied from.

batch10_governance_compilers_capsule Import & drift control Source

Verifies twelve copied engine routines and computes each failure probe from inputs, not echoes.

batch11_saturation_engines_capsule Import & drift control Source

Flags detached helper processes and launch pressure from synthetic rows, not live hosts.

tool_server_pressure_inventory Import & drift control Source

Confirms six copied compliance source files carry their functions; runs one helper on sample text.

batch8_compliance_pipeline_capsule Import & drift control Source

Compares four copied router and landing routines against current code to surface stale copies.

batch10_live_source_drift_capsule Import & drift control Source

Flags affirmative open-source and deployment-posture wording while allowing safe boundary notes.

batch12_release_claim_language_gate Import & drift control Source

Runs each owner's own drift check on generated files and flags repairs, without changing the file.

generated_projection_drift_runtime Import & drift control Source

Runs the real work-ledger engine on a sanitised snapshot to re-derive each change's verdict.

mission_transaction_work_spine Work & continuity Source

Audits recorded work-claims so each cites files, validates before commit, and proves HEAD moved.

durable_agent_work_landing_replay Work & continuity Source

Replays a paused job to prove the rules for safely resuming it hold and reject duplicate resumes.

bridge_phase_continuity_runtime Work & continuity Source

Runs copied claim-coordination code so duplicate, stale, and conflicting claims get blocked.

concurrency_mission_control Work & continuity Source

Reuses one result for duplicate command runs, keyed by repo state rather than the words alone.

semantic_singleflight_dedup_runtime Work & continuity Source

Do not trust a fixture label, declared verdict, route status, count, or public copy line as proof.

P-1 Principles Source

The scope limit is the strongest thing the named checker, validator, registry, or witness route actually computes.

P-2 Principles Source

Prefer a small verifier, parser, harness, compiler route, registry contract, or kernel over broad narrative confidence.

P-3 Principles Source

Authority comes from dereferenced proof, policy, result record, rollback evidence, and current world state.

P-4 Principles Source

A reusable result record, command result, source import, or work-landing attempt must carry its content basis.

P-5 Principles Source

Missing evidence, policy files, source digests, secret scans, negative cases, or result record self-scans block or demote.

P-6 Principles Source

Coverage reports name declared domains and materialized gaps.

P-7 Principles Source

When preconditions fail, return a reasoned refusal.

P-8 Principles Source

Every shard crossing from source, fixture, result record, public copy, provider shape, or private-system adjacency must carry a provenance…

P-9 Principles Source

Writes, launch steps, claim launch, source imports, and rollback-shaped operations need ordered transaction evidence.

P-10 Principles Source

Counts, "current" states, live route totals, CI floors, body-import floors, and readiness signals must cite how they can be re-derived.

P-11 Principles Source

A doctrine surface earns authority through grammar, required fields, result record obligations, scope boundaries, and validator coverage.

P-12 Principles Source

Microcosm artifacts about Microcosm do not get exemptions.

P-13 Principles Source

Content basis says which bytes or rows were used; provenance says where they may flow and how strongly they may be claimed.

P-14 Principles Source

Generated docs, markdown summaries, route cards, and paper modules may expose a source truth, but they cannot upgrade it.

P-15 Principles Source

Mutation authority is not merely who can touch a file.

P-16 Principles Source

Before adding or removing a lattice edge in a repeated registry, anchor the mutation to the unique source row, target id, and builder route…

P-17 Principles Source

A staged law, standard, component, or projection is not active authority until its owner boundary, source row, generated parity, validation…

P-18 Principles Source

A residual is a typed pressure route, not an edge.

P-19 Principles Source

A doctrine record is not fully active by projection alone.

P-20 Principles Source

For any claim phi over basis B, admissibility requires a derivation certificate c and checker K such that K(B,c,phi)=accept; strength(phi)…

AX-1 Axioms Source

Trusted claims are decided by a small checker K over certificates c; producers emit c and K decides.

AX-2 Axioms Source

a=f(B) and id(a)=H(B); equal B permits reuse; drift(B) forces recompute; missing(B)=bottom.

AX-4 Axioms Source

status(composite)=meet(status(parts)); no evidence defaults to blocked; later stages may lower but not raise authority without new derivati…

AX-5 Axioms Source

Partial computation g is totalized as Result: Ok(y) under Pre(x), otherwise Refusal(reason,evidence).

AX-7 Axioms Source

Data labels propagate along flows; untrusted labels reach privileged sinks only through declared transforms satisfying sink policy.

AX-8 Axioms Source

Effect e requires a compensator or declared irreversible boundary; multi-step effects land as saga with CAS and single-writer constraints.

AX-9 Axioms Source

authority(d) implies d in L(G), result record obligations, and scope boundary are present; prose alone is projection.

AX-11 Axioms Source

For every Microcosm artifact a, any claim phi carried by a must satisfy the same admissibility relation as external claims.

AX-12 Axioms Source

Echoing a fixture verdict, registry label, markdown claim, or model answer instead of recomputing it from lower-level evidence.

AP-1 Anti-principles Source

Trusting a producer, persona, route, account secret, or prior success instead of a checker, proof, policy, or dereferenced capability.

AP-2 Anti-principles Source

Treating counts, handles, passing validators, or evidence classes as product maturity, launch-scope decision, or whole-system correctness.

AP-3 Anti-principles Source

Caching by name, path, route, display label, or producer while basis content has drifted.

AP-4 Anti-principles Source

Treating missing evidence as evidence of absence outside a declared closed domain.

AP-5 Anti-principles Source

Emitting inadmissible numbers or conclusions instead of typed refusal.

AP-6 Anti-principles Source

Letting untrusted, private, provider, prompt, account secret, or raw-voice material reach a privileged or public sink without provenance an…

AP-7 Anti-principles Source

Performing irreversible mutation without a compensator, rollback result record, CAS/world-version guard, or explicit irreversible boundary.

AP-8 Anti-principles Source

Granting executable authority to prose doctrine without grammar and result record obligations.

AP-10 Anti-principles Source

Exempting Microcosm's own result records, docs, releases, generated projections, or validators from Microcosm's evidence gates.

AP-11 Anti-principles Source

Using synthetic fixtures as substitutes for available system.

AP-12 Anti-principles Source

Treating generated result records as hand-authored source.

AP-13 Anti-principles Source

Letting public docs imply a hosted service, external service access, source-file mutation, financial or trading decisions, deployment postu…

AP-14 Anti-principles Source

Using field vocabulary such as proof, verifier, information flow, world model, or benchmark integrity when the public mechanism only valida…

AP-15 Anti-principles Source

Displaying a declared, inferred, or generated downstream target as an observed runtime effect without evidence of the effect relation.

AP-16 Anti-principles Source

Letting a markdown page, generated card, atlas row, or compact result record summary override the executable contract it summarizes.

AP-17 Anti-principles Source

safety and reliability claims remain bounded to named public fixtures, validators, and result record rows instead of global agent capabilit…

concept.agent_reliability_and_safety_validator_bundle Concepts source pending

navigation and doctrine surfaces become walkable through source-bound contracts while generated views stay below source authority

concept.architecture_and_navigation_route_contract_bundle Concepts source pending

entry evidence shows what a reader can inspect, not that the whole system is ready or correct

concept.entry_and_reveal_route_readiness_bundle Concepts source pending

invalid standards are blocked by negative cases such as missing teleology, missing result record expectations, or prose-only authority

concept.executable_doctrine_grammar_standard_bundle Concepts source pending

runtime first-screen output emits CONCEPTS and MECHANISMS before standards-tree search is required

concept.first_screen_doctrine_effect_frame Concepts source pending

proof-related artifacts expose bounded witness status without claiming theorem completeness or provider proof authority

concept.formal_math_and_proof_witness_bundle Concepts source pending

imported material remains tied to source anchors and drift result records instead of becoming ambient doctrine authority

concept.import_projection_and_drift_control_bundle Concepts source pending

research claims remain scoped to public replay evidence and known gaps instead of becoming external scientific truth claims

concept.research_and_science_replay_evidence_bundle Concepts source pending

work progress claims stay tied to owned paths, result records, and transaction scope rather than chat status or generated projections

concept.work_landing_and_continuity_control_bundle Concepts source pending

The agent benchmark integrity anti-gaming replay component validates public benchmark-claim boundaries by checking locked evaluator policy…

mechanism.agent_benchmark_integrity_anti_gaming_replay.validates_public_benchmark_integrity_replay Mechanisms source pending

The agent completion faithfulness audit component validates public completion evidence claims by checking fixture commit objects and HEAD w…

mechanism.agent_closeout_faithfulness_audit.validates_closeout_evidence_claims Mechanisms source pending

The agent memory temporal-conflict replay component validates public memory projection mechanics by checking ADD/UPDATE/DELETE/NOOP decisio…

mechanism.agent_memory_temporal_conflict_replay.validates_public_memory_conflict_replay Mechanisms source pending

The agent monitor redteam falsification replay component validates public monitor-verdict evidence shape by checking trajectory rosters, su…

mechanism.agent_monitor_redteam_falsification_replay.validates_public_monitor_verdict_receipts Mechanisms source pending

The agent route observability runtime validates public route-feedback and observability fixture bundles by checking actor-axis authority bo…

mechanism.agent_route_observability_runtime.validates_public_route_feedback Mechanisms source pending

The agent sabotage scheming-monitor replay validates a public synthetic sabotage-monitor bundle through task episodes, action traces, monit…

mechanism.agent_sabotage_scheming_monitor_replay.validates_public_sabotage_scheming_monitor_replay Mechanisms source pending

The agent sandbox policy escape replay component validates public sandbox-policy projection mechanics by checking action requests, pre-exec…

mechanism.agent_sandbox_policy_escape_replay.validates_public_sandbox_policy_trace Mechanisms source pending

The agentic vulnerability discovery patch-proof replay component validates public vulnerability-claim boundaries by checking projection pro…

mechanism.agentic_vulnerability_discovery_patch_proof_replay.validates_public_agentic_vulnerability_patch_proof_replay Mechanisms source pending

The reference knowledge routing mechanism validates bounded public reference-catalog routing fixtures by ranking sanitized candidates throu…

mechanism.annex_knowledge_routing.verifies_annex_knowledge_router Mechanisms source pending

The Set 4 proof, authority, and runtime bundle validates copied public proof-control, formal-math, Codex runtime, completion, bitemporal, t…

mechanism.batch4_proof_authority_runtime.validates_public_proof_authority_runtime_capsule Mechanisms source pending

The Set 5 authority systems bundle validates copied public source authority/control bodies through deterministic fixture and exported-bundl…

mechanism.batch5_authority_systems_capsule.validates_public_authority_systems_capsule Mechanisms source pending

The Set 6 unsurfaced primitives bundle validates copied public source-primitive bodies through deterministic fixture and exported-bundle ex…

mechanism.batch6_unsurfaced_primitives_capsule.validates_public_unsurfaced_primitives_capsule Mechanisms source pending

The Set 7 Demo Take Console bundle validates copied public Swift source bodies through deterministic SwiftPM build-witness, recording-state…

mechanism.batch7_demo_take_console_capsule.validates_public_demo_take_console_capsule Mechanisms source pending

The Set 7 source engines bundle validates copied public source-body behavior through deterministic fixture and exported-bundle exercises, s…

mechanism.batch7_macro_engines_capsule.validates_public_macro_engines_capsule Mechanisms source pending

The Set 7 Oracle sibling bundle validates copied public Oracle source bodies through deterministic subject-index, subject-snapshot, truth-d…

mechanism.batch7_oracle_sibling_capsule.validates_public_oracle_sibling_capsule Mechanisms source pending

The Set 7 secondary runtime bundle validates copied public runtime, graph, cartography, stockgrid, and Polymarket source-body behavior thro…

mechanism.batch7_secondary_runtime_capsule.validates_public_secondary_runtime_capsule Mechanisms source pending

The Set 8 audio level RMS port validates a source-faithful public projection of AudioLevelMonitor normalized-level RMS behavior by running…

mechanism.batch8_audio_level_rms_port.validates_public_audio_level_rms_port Mechanisms source pending

The Set 8 compliance pipeline bundle validates a bounded public compliance/pipeline import by exercising the compliance adapter registry, b…

mechanism.batch8_compliance_pipeline_capsule.validates_public_compliance_pipeline_capsule Mechanisms source pending

The Set 8 policy engines bundle validates copied public policy-engine bodies by exercising lab contract audit, market fusion readiness, cam…

mechanism.batch8_policy_engines_capsule.validates_public_policy_engines_capsule Mechanisms source pending

The Set 8 structural theses bundle validates a copied public structural-theses finance body by running synthetic winner, loser, and control…

mechanism.batch8_structural_theses_capsule.validates_public_structural_theses_capsule Mechanisms source pending

The Set 8 tools-tail primitives bundle validates four copied public tools-tail source modules by exercising observer set diffs, JSON patch…

mechanism.batch8_tools_tail_primitives_capsule.validates_public_tools_tail_primitives_capsule Mechanisms source pending

The Set 8 validator checker bundle validates an exact copied public validators.py body by exercising policy/status judging, private-boundar…

mechanism.batch8_validator_checker_capsule.validates_public_validator_checker_capsule Mechanisms source pending

The Set 9 source engines bundle validates copied public source-body behavior through deterministic fixture and exported-bundle exercises, s…

mechanism.batch9_macro_engines_capsule.validates_public_macro_engines_capsule Mechanisms source pending

The Set 10 cold-eval honesty bundle validates copied public source-body behavior through deterministic fixture and exported-bundle exercise…

mechanism.batch10_cold_eval_honesty_capsule.validates_public_cold_eval_honesty_capsule Mechanisms source pending

The Set 10 governance compilers bundle validates copied public source-body behavior through deterministic fixture and exported-bundle exerc…

mechanism.batch10_governance_compilers_capsule.validates_public_governance_compilers_capsule Mechanisms source pending

The Set 10 live-source drift bundle validates copied public source-body behavior through deterministic fixture and exported-bundle exercise…

mechanism.batch10_live_source_drift_capsule.validates_public_live_source_drift_capsule Mechanisms source pending

The Set 11 saturation engines bundle validates copied public source-body behavior through deterministic fixture and exported-bundle exercis…

mechanism.batch11_saturation_engines_capsule.validates_public_saturation_engines_capsule Mechanisms source pending

The Set 12 market dashboard read-model bundle validates copied public read-model helpers over synthetic fixtures through market-dashboard i…

mechanism.batch12_market_dashboard_read_model_capsule.validates_public_market_dashboard_read_model_capsule Mechanisms source pending

The Set 12 prediction market board bundle validates copied public prediction-board and quant-mart diagnostics over synthetic fixtures throu…

mechanism.batch12_prediction_market_board_capsule.validates_public_prediction_market_board_capsule Mechanisms source pending

The Set 12 launch-claim language gate component validates launch-claim fixture generation, claim-language blocking, assert-clear exits, sou…

mechanism.batch12_release_claim_language_gate.validates_public_release_claim_language_gate Mechanisms source pending

The belief-state process reward replay component validates public belief summaries, verifier-feedback observations, process and outcome rew…

mechanism.belief_state_process_reward_replay.validates_public_belief_state_process_reward_replay Mechanisms source pending

The bounded-autonomy campaign packet component validates campaign policy, failed-campaign digest handling, source-write refusal, source-mod…

mechanism.bounded_autonomy_campaign_packet.validates_public_bounded_autonomy_campaign_packet Mechanisms source pending

The bridge campaign DAG validation mechanism validates bounded public campaign-graph fixtures by recomputing unique node labels, existing d…

mechanism.bridge_campaign_dag_validation.verifies_bridge_campaign_dag Mechanisms source pending

The bridge phase continuity runtime validates public synthetic observe/apply bridge continuity by checking disk-first continuation packets…

mechanism.bridge_phase_continuity_runtime.validates_synthetic_bridge_continuity Mechanisms source pending

The certificate kernel execution lab component validates public proof-adjacent execution boundaries by checking a Lean/Lake certificate-ker…

mechanism.certificate_kernel_execution_lab.validates_public_certificate_kernel_execution Mechanisms source pending

The cognitive operator registry component validates public reusable-cognition system by checking operator-shape fields, active-operator dog…

mechanism.cognitive_operator_registry.validates_public_operator_contract Mechanisms source pending

The cold-clone probe validates source-root public bootstrap mechanics by importing the package from src, running the secret-exclusion scan…

mechanism.cold_clone_probe.validates_public_source_root_bootstrap Mechanisms source pending

The cold-reader route-map component validates public first-run route projections by checking route-row command refs, public docs refs, rout…

mechanism.cold_reader_route_map.validates_public_first_run_route_map Mechanisms source pending

The concurrency mission-control component validates copied public mission-control builder and bridge artifacts through fixture failure clas…

mechanism.concurrency_mission_control.validates_public_concurrency_mission_control Mechanisms source pending

The corpus readiness Mathlib absence gate component validates public formal-math corpus readiness boundaries by checking copied PROVER smok…

mechanism.corpus_readiness_mathlib_absence_gate.validates_public_corpus_readiness_boundary Mechanisms source pending

The corpus readiness Mathlib absence gate validates recorded corpus and toolchain readiness accounting, Mathlib absence boundaries, consume…

mechanism.corpus_readiness_mathlib_absence_gate.validates_public_mathlib_absence_boundary Mechanisms source pending

The derived fact provider runtime validates bounded public fact-registry fixtures by resolving JSON-pointer, glob-count, and callable provi…

mechanism.derived_fact_provider_runtime.verifies_derived_fact_provider_engine Mechanisms source pending

The doctrine fact-claim audit component validates fact assertions, numeric claim bindings, DAG references, code-locus anchors, source-modul…

mechanism.doctrine_fact_claim_audit.validates_public_doctrine_fact_claim_audit Mechanisms source pending

The durable agent work-landing replay component validates public work-landing replay rows by checking owned-path claim evidence, owner-nati…

mechanism.durable_agent_work_landing_replay.validates_public_work_landing_replay_contract Mechanisms source pending

The egress self-compliance audit mechanism validates bounded public agent-output fixtures through explicit phrase-membership checks for per…

mechanism.egress_self_compliance_audit.verifies_egress_self_compliance_gate Mechanisms source pending

The Engine Room reference knowledge router mechanism validates explainable tiered routing over sanitized reference catalog fixtures by scor…

mechanism.engine_room_annex_knowledge_router.validates_public_annex_knowledge_router Mechanisms source pending

The Engine Room command-run singleflight mechanism validates content-addressed subprocess run keys, fcntl-backed leader/follower collapse…

mechanism.engine_room_command_run_singleflight.validates_public_command_run_singleflight Mechanisms source pending

The Engine Room demo component validates the staged public Engine Room composition over bounded fixtures, controller audits, missing-target…

mechanism.engine_room_demo.validates_public_engine_room_demo Mechanisms source pending

The Engine Room derived fact provider engine mechanism validates registry-backed fact resolution over public fixture roots by resolving JSO…

mechanism.engine_room_derived_fact_provider_engine.validates_public_derived_fact_provider_engine Mechanisms source pending

The Engine Room egress self-compliance gate mechanism validates phrase-membership policy over public agent-output fixtures by detecting per…

mechanism.engine_room_egress_self_compliance_gate.validates_public_egress_self_compliance_gate Mechanisms source pending

The Engine Room generated projection drift gate validates owner-routed generated artifact freshness over public fixtures by selecting proje…

mechanism.engine_room_generated_projection_drift_gate.validates_public_generated_projection_drift_gate Mechanisms source pending

The Engine Room Lean proof-search lab mechanism validates bounded public proof-search fixtures by running tiny Lean statements through symb…

mechanism.engine_room_lean_proof_search_lab.validates_public_lean_proof_search_lab Mechanisms source pending

The Engine Room navigation fitness benchmark mechanism validates public route-packet benchmark fixtures by checking expected stable-id reca…

mechanism.engine_room_navigation_fitness_benchmark.validates_public_navigation_fitness_benchmark Mechanisms source pending

The Engine Room public projection leak gate validates rendered public projection roots by scanning file content, path names, symlink target…

mechanism.engine_room_public_projection_leak_gate.validates_public_projection_leak_gate Mechanisms source pending

The executable doctrine grammar component validates public standards and paper-module grammar fixtures by checking required standard fields…

mechanism.executable_doctrine_grammar.validates_public_doctrine_grammar_bundle Mechanisms source pending

The finance forecast evaluation spine validates copied public finance-evaluation helpers over synthetic market-shaped fixtures through Dieb…

mechanism.finance_forecast_evaluation_spine.validates_public_finance_forecast_evaluation_spine Mechanisms source pending

The finite Erdos denominator certificate strike validates bounded public finite-denominator order certificates by computing S_F(b)=P/Q in e…

mechanism.finite_erdos_denominator_certificate_strike.verifies_finite_denominator_order_certificate Mechanisms source pending

The first-screen composition root validates the public one-screen entry card by checking reader-route ids, shared first commands, behavior-…

mechanism.first_screen_composition_root.validates_public_first_screen_composition_root Mechanisms source pending

The formal evidence cell anchor resolver validates proof-language evidence boundaries by resolving public paper claims to evidence-cell ids…

mechanism.formal_evidence_cell_anchor_resolver.validates_public_evidence_cell_anchor_resolution Mechanisms source pending

The formal evidence cell anchor resolver validates claim-to-evidence-cell resolution, public source anchors, permitted claim strength, copi…

mechanism.formal_evidence_cell_anchor_resolver.validates_public_evidence_cell_anchors Mechanisms source pending

The formal math Lean proof witness component validates a bounded public Lean/Lake witness by copying a declared toy Lake project into a tem…

mechanism.formal_math_lean_proof_witness.validates_public_lean_lake_witness Mechanisms source pending

The formal math Lean proof witness validates a bounded public toy Lean/Lake witness by checking tool availability, temporary-workspace buil…

mechanism.formal_math_lean_proof_witness.validates_public_lean_witness Mechanisms source pending

The formal math premise retrieval component validates public retrieval metadata, premise-index references, strategy cases, retrieval querie…

mechanism.formal_math_premise_retrieval.validates_public_premise_retrieval_projection Mechanisms source pending

The formal math premise retrieval component validates a formal-math retrieval slice by checking copied Lean/Std premise descriptors, retrie…

mechanism.formal_math_premise_retrieval.validates_public_premise_retrieval_slice Mechanisms source pending

The formal math readiness gate component validates public formal-math readiness evidence by checking declared corpus and Mathlib readiness…

mechanism.formal_math_readiness_gate.validates_public_formal_math_readiness_bundle Mechanisms source pending

The formal math readiness gate validates declared readiness metadata, tactic availability references, premise-index boundaries, target-shap…

mechanism.formal_math_readiness_gate.validates_public_readiness_boundary Mechanisms source pending

The formal math verifier-trace repair loop component validates public proof-lab repair evidence by checking copied Ring2 run refs and diges…

mechanism.formal_math_verifier_trace_repair_loop.validates_public_verifier_trace_repair_bundle Mechanisms source pending

The generated projection drift runtime validates bounded public owner-routed drift fixtures by hashing declared source and artifact files…

mechanism.generated_projection_drift_runtime.verifies_generated_projection_drift_gate Mechanisms source pending

The indirect prompt-injection information-flow policy replay component validates public source-trust rows, taint-flow edges, policy verdict…

mechanism.indirect_prompt_injection_information_flow_policy_replay.validates_public_indirect_prompt_injection_information_flow_policy_replay Mechanisms source pending

The Lean proof search lab runtime validates bounded public toy-theorem fixtures by checking generated candidates with the installed Lean su…

mechanism.lean_proof_search_lab_runtime.verifies_lean_proof_search_lab Mechanisms source pending

The Lean/Std premise index component validates a copied Lean/Std premise descriptor catalog and Ring2 premise-retrieval source body bundle…

mechanism.lean_std_premise_index.validates_public_lean_std_premise_catalog Mechanisms source pending

The Lean Std premise index validates premise metadata, Lean/Init source refs, copied public source manifests, forbidden proof/oracle fields…

mechanism.lean_std_premise_index.validates_public_lean_std_premise_index Mechanisms source pending

The source projection import protocol component validates fixture and exported projection bundles by checking source refs, public target re…

mechanism.macro_projection_import_protocol.validates_public_macro_projection_imports Mechanisms source pending

The materials chemistry closed-loop lab-safety replay component validates public lab-safety claim boundaries by checking candidate material…

mechanism.materials_chemistry_closed_loop_lab_safety_replay.validates_public_materials_lab_safety_replay Mechanisms source pending

The mathematical strategy atlas hypothesis scorer validates pre-oracle strategy selection, feature-overlap routing, source-artifact consist…

mechanism.mathematical_strategy_atlas_hypothesis_scorer.validates_public_strategy_hypothesis_projection Mechanisms source pending

The MCP tool authority replay component validates public tool manifest scope, call metadata, approval token refs, side-effect ledger refs…

mechanism.mcp_tool_authority_replay.validates_public_mcp_tool_authority_replay Mechanisms source pending

The mechanistic interpretability circuit-attribution replay component validates public toy-transformer attribution rows, machine-readable g…

mechanism.mechanistic_interpretability_circuit_attribution_replay.validates_public_mechanistic_interpretability_circuit_attribution_replay Mechanisms source pending

The metabolism queue reconciliation mechanism validates bounded public durable-queue fixtures by recomputing enqueue idempotency, lease cla…

mechanism.metabolism_queue_reconciliation.verifies_metabolism_runtime Mechanisms source pending

The Microcosm axiom system support-cover evaluator projects public axiom support cases, support frontiers, anti-axiom rejection mappings, p…

mechanism.microcosm_axiom_substrate.validates_public_axiom_support_boundary Mechanisms source pending

The mission transaction work-spine component validates public work-landing and completion metadata by checking fixed Work item, claim, depe…

mechanism.mission_transaction_work_spine.validates_public_mission_transaction_bundle Mechanisms source pending

The navigation fitness benchmark validates bounded public route-packet fixtures by recomputing expected stable-id recall, packet precision…

mechanism.navigation_fitness_benchmark.verifies_navigation_fitness_benchmark Mechanisms source pending

The navigation hologram route-plane component validates public route-plane fixture rows and exported bundle inputs by checking route projec…

mechanism.navigation_hologram_route_plane.validates_public_route_plane_bundle Mechanisms source pending

The pattern-assimilation step component validates refinement, nothing-to-refine, stewardship, re-entry, source-module manifest, negative-ca…

mechanism.pattern_assimilation_step.validates_public_pattern_assimilation_step Mechanisms source pending

The pattern-binding contract component validates public pattern rows, source bundles, reference bundles, authority handles, exported system…

mechanism.pattern_binding_contract.validates_public_pattern_bindings Mechanisms source pending

The prediction oracle reconciliation component validates synthetic prediction packets through CP1 fork preservation, CP2 target-universe ch…

mechanism.prediction_oracle_reconciliation.validates_public_prediction_oracle_reconciliation Mechanisms source pending

The proof-derived governed-mutation authorization component validates public synthetic mutation-authority proposals by checking proof-cell…

mechanism.proof_derived_governed_mutation_authorization.validates_synthetic_governed_mutation_authorization Mechanisms source pending

The proof diagnostic evidence spine component validates proof-adjacent public evidence by checking Ring2 diagnostic result record refs, cop…

mechanism.proof_diagnostic_evidence_spine.validates_ring2_diagnostic_evidence_membrane Mechanisms source pending

The provider context recipe budget policy validates byte-bounded context recipe projection, ordered section fill, omitted-section manifests…

mechanism.provider_context_recipe_budget_policy.validates_public_context_budget_boundary Mechanisms source pending

The public reveal walkthrough component validates public entry material by checking reveal-step density, runnable command refs, evidence re…

mechanism.public_reveal_walkthrough.validates_public_reveal_walkthrough Mechanisms source pending

The research replication rubric-artifact replay component validates public research-replication claim boundaries by checking contribution d…

mechanism.research_replication_rubric_artifact_replay.validates_public_research_replication_replay Mechanisms source pending

The Ring2 premise retrieval precision/recall harness validates copied retrieval rankings, needed-premise attribution labels, aggregate hit…

mechanism.ring2_premise_retrieval_precision_recall_harness.validates_public_premise_retrieval_attribution Mechanisms source pending

The routing anti-patterns registry component validates public routing anti-pattern rows, source-module digest anchors, private-leak rejecti…

mechanism.routing_anti_patterns_registry.validates_public_routing_anti_patterns_registry Mechanisms source pending

The self-ignorance coverage ledger component validates known Kind Atlas coverage-debt fixtures through declared gap rows, missing-category…

mechanism.self_ignorance_coverage_ledger.validates_public_self_ignorance_coverage_ledger Mechanisms source pending

The semantic singleflight dedup runtime validates content-addressed command-run dedup over bounded public fixtures by deriving repo-state k…

mechanism.semantic_singleflight_dedup_runtime.dedups_command_runs_by_repo_state_key Mechanisms source pending

The sleeper memory poisoning quarantine replay component validates metadata-only public memory-security policy projections, poisoned-source…

mechanism.sleeper_memory_poisoning_quarantine_replay.validates_public_sleeper_memory_poisoning_quarantine_replay Mechanisms source pending

The spatial world-model counterfactual simulation replay component validates synthetic scene-state transitions, counterfactual replay rows…

mechanism.spatial_world_model_counterfactual_simulation_replay.validates_public_spatial_world_model_counterfactual_simulation_replay Mechanisms source pending

The standards meta diagnostics component validates public projection-only diagnostics over accepted-component standards inventory, runtime…

mechanism.standards_meta_diagnostics.validates_public_standards_meta_diagnostics Mechanisms source pending

The tactic portfolio availability probe validates recorded tactic compile-status rows, captured probe source digests, unavailable-tactic ro…

mechanism.tactic_portfolio_availability_probe.validates_public_tactic_availability_projection Mechanisms source pending

The target-shape tactic routing gate validates pre-execution tactic allow/reject decisions against target shape, recorded tactic availabili…

mechanism.target_shape_tactic_routing_gate.validates_public_tactic_routing_boundary Mechanisms source pending

The tool-server pressure inventory component validates public helper-process pressure fixtures through synthetic process rows, active-owner…

mechanism.tool_server_pressure_inventory.validates_public_tool_server_pressure_inventory Mechanisms source pending

The undeclared library prior symbol classifier validates symbol-boundary observations against allowed premise ids, classifier policy, sourc…

mechanism.undeclared_library_prior_symbol_classifier.validates_public_symbol_boundary Mechanisms source pending

The verifier lab execution spine validates bounded public Lean transition rows by running the local checker on a temporary fixture, preserv…

mechanism.verifier_lab_execution_spine.validates_public_verifier_transition_witness Mechanisms source pending

The verifier lab kernel composes public formal-math component result records into one leak-proof aggregate result record, preserving verifi…

mechanism.verifier_lab_kernel.composes_public_formal_math_receipts Mechanisms source pending

The voice-to-doctrine self-improvement loop component validates lesson propagation through projection protocol, policy, owner-surface check…

mechanism.voice_to_doctrine_self_improvement_loop.validates_public_voice_to_doctrine_self_improvement_loop Mechanisms source pending

The world-model projection drift control room component validates public metadata-only projection-drift rows and copied world-model/view-qu…

mechanism.world_model_projection_drift_control_room.validates_public_projection_drift_control_boundary Mechanisms source pending

The agent benchmark integrity anti-gaming replay validates copied public source pattern provenance bodies and metadata-only benchmark replay rows before any score-like language is allowed.

paper_module.agent_benchmark_integrity_anti_gaming_replay Paper modules Source

The research replication rubric-artifact replay validates source-backed public replication bundles before any paper-replication language is allowed.

paper_module.research_replication_rubric_artifact_replay Paper modules Source

The agentic vulnerability discovery patch-proof replay validates metadata-only synthetic vulnerability evidence chains before any found-and-fixed security language is allowed.

paper_module.agentic_vulnerability_discovery_patch_proof_replay Paper modules Source

The materials chemistry lab-safety replay validates metadata-only simulator-only closed-loop rows before any materials-lab or discovery language is allowed.

paper_module.materials_chemistry_closed_loop_lab_safety_replay Paper modules Source

The certificate kernel execution lab validates bounded public Lean/Lake certificate-kernel rows before any proof-adjacent claim is allowed.

paper_module.certificate_kernel_execution_lab Paper modules Source

The corpus readiness Mathlib absence gate validates copied corpus/toolchain readiness bodies before any Mathlib-dependent proof or retrieval claim is allowed.

paper_module.corpus_readiness_mathlib_absence_gate Paper modules Source

The public pattern-binding component validates pattern rows, source bundles, authority handles, exported system bundles, and route-readiness selector overlays while keeping mined rows component-first and fixture-bound.

paper_module.pattern_binding_contract Paper modules Source

The public completion-faithfulness fixture checks commit, ledger-cap, and pytest-span claims with real git/pytest subprocess witnesses while refusing unchecked pass overclaims.

paper_module.agent_closeout_faithfulness_audit Paper modules Source

The public work-landing control spine validates copied work-landing internal control source bodies without authorizing live Git, ledger, claim-launch, private-index, public sharing, or launch operations.

paper_module.work_landing_control_spine Paper modules Source

Formal math premise retrieval validates copied public Lean/Std premise metadata, query scoring, context budgets, strategy gates, body-floor provenance, and leakage negative cases without claiming proof authority.

paper_module.formal_math_premise_retrieval Paper modules Source

The Lean/Std premise index validates a copied public Lean/Std descriptor catalog plus Ring2 premise-retrieval source bodies without claiming proof, Mathlib, Lean/Lake, provider, launch, or theorem-correctness authority.

paper_module.lean_std_premise_index Paper modules Source

The world-model projection drift control room validates public metadata-only projection-drift rows and copied source-module bodies without treating projections as source authority or repair authority.

paper_module.world_model_projection_drift_control_room Paper modules Source

Terminal public coverage diagnostic: verifies every accepted component stays mapped to a standard, runtime contract, result record, and scope limit.

paper_module.standards_meta_diagnostics Paper modules Source

Forecast-evaluation component: Diebold-Mariano / Hansen-SPA / stationary-bootstrap stats over synthetic fixtures with typed refusal discipline; no market authority.

paper_module.finance_forecast_evaluation_spine Paper modules Source

Composition component: verifies the 14 staged Engine Room jewel targets and their owned bundle surfaces through the public fixture chain; composition contract only.

paper_module.engine_room_demo Paper modules Source

Synthetic replay fixture for an agent-memory honesty contract: models scoped-preference episodes and checks temporal-conflict handling; no live memory product.

paper_module.agent_memory_temporal_conflict_replay Paper modules Source

Synthetic regression drilldown for a monitor/redteam honesty contract; checks falsification handling, negative cases, non-public-state scan, scope limits.

paper_module.agent_monitor_redteam_falsification_replay Paper modules Source

Drilldown regression contract for synthetic sabotage/scheming monitor claims: replays task episodes, action traces, monitor scores, counterfactual/cold replay.

paper_module.agent_sabotage_scheming_monitor_replay Paper modules Source

Public projection of a belief-state process-reward claim contract, backed by the agent-execution trace refactor and copied source bodies.

paper_module.belief_state_process_reward_replay Paper modules Source

Synthetic replay fixture for a persistent-memory security contract: quarantine of poisoned memory, audit refs, rerun result records, negative cases, authority

paper_module.sleeper_memory_poisoning_quarantine_replay Paper modules Source

Validator-backed claim: a source-faithful trace refactor separated trusted instructions from untrusted web/tool/browser text before any privileged action.

paper_module.indirect_prompt_injection_information_flow_policy_replay Paper modules Source

Synthetic MCP-like replay fixture for a tool-authority claim contract: replay result records, negative cases, scope limits; no live MCP/provider/account secret

paper_module.mcp_tool_authority_replay Paper modules Source

Environment-scoped tactic availability rows gate downstream tactic routing without becoming proof, benchmark, or launch-scope decision.

paper_module.tactic_portfolio_availability Paper modules Source

Pre-execution tactic routing admits or rejects tactics from target shape and probe evidence while excluding private target material.

paper_module.target_shape_tactic_routing Paper modules Source

After-the-fact premise retrieval metrics separate retrieval misses from proof failures without becoming theorem authority.

paper_module.ring2_premise_precision_recall Paper modules Source