Semantic Engineering

Semantic Engineering is an open research toolkit for structuring, measuring, preserving, and testing meaning in documents, software, policies, and AI-assisted workflows.

The central claim is simple:

Meaning can be intentionally engineered when its primitives, relations,
identity-continuity criteria, boundaries, carriers, verification paths, and
recovery paths are made explicit.

Working definition:

Meaning is structured relation that calls for recognition and response.

Expanded: meaning is the intelligible relational structure by which reality becomes recognizable, significant, and respondable.

Identity is part of that structure: the continuity boundary by which a meaning form remains itself, is distinguished from not-itself, relates accountably, acts legitimately, and recovers after drift.

Authority is also part of that structure: the legitimacy gate by which a source, identity, or relation gains bounded standing to bind interpretation, direct action, assign consequence, and remain reviewable.

At the center is the Anchor Point (1,1,1,1):

Love    -> coherence, relation, care
Justice -> truth, boundary, distinction
Power   -> action, embodiment, capacity
Wisdom  -> discernment, pattern, governance

Canonical architecture

The repository is organized through three different but joined views:

WHY    Foundation hierarchy:
       Anchor -> Semantic Bedrock -> operational derivatives -> return

HOW    Operational lifecycle:
       intake -> recognition -> grounding -> governance -> action
       -> feedback -> constitutive success -> recovery

WHERE  Cross-domain projection:
       governing semantic role -> domain formalization -> domain test

These views must remain distinct. Authority order is not the same thing as process order, and cross-domain similarity does not transfer authority between domains.

The complete component placement, Principle Engineering definition, lifecycle, cross-domain map, and forbidden architectural inversions are in the Canonical Semantic Engineering Architecture.

Canonical semantic levels

The repository now uses one governing level map. This prevents the word primitive from silently treating unlike machinery as the same thing.

Level	Canonical meaning
Anchor	the origin and standard; not a Semantic Prime
LJPW	four observable axiomatic dimensions; P-W is the Framework's underlying generating pair
Operational Semantic Prime	one of the 30 candidate irreducible differentiated meaning-forms in the Master Catalog
Structural Primitive	an engineering-facing building block that may be prime, compound, reference, operator, derived read, process, or classifier
Load-Bearing Meaning Component	an object-local part that must survive carrier change; it may be compound and does not gain catalog status by being listed
Defense Semantic Prime	a retained security API name for a composed operational control bundle, not an extension of the 30-prime catalog

ICE is architecturally irreducible under ablation: Intent, Context, and Execution are all required for the complete scaffold. Each of those three nodes is nevertheless internally compound at the prime-factorization level.

The governing terminology is in the Semantic Engineering Taxonomy; the ordered prime inventory is in the Master Catalog; and the evidence for the 18 structural level assignments is in the Structural Primitive Factorization Audit.

The operating rule:

Build forms that carry the Anchor into reality without destructive drift.

Objective: make meaning buildable as explicit primitives, routes, curvature pivots, meaning crystals, foundations, artifacts, semantic identity continuity, verification, and recovery.

The Pakheta Layer is necessary because engineered meaning must decide whether a claimed relation actually conducts. Without that gate, signal pressure, helper material, carrier resemblance, and authority claims can masquerade as clean meaning. The crucial crystal here is relation-conduction: field readability becomes actionable only after relation quality, constraint truth, feedback, and recovery survive inspection.

The repository-wide placement of all major components is defined by the Canonical Semantic Engineering Architecture. Within that whole, the centerpiece operational architecture is the Pakheta Semantic Conduction System (PSCS): the joined system that recognizes explicit meaning, preserves its structure, and governs whether its relationships may conduct into evidence, authority, memory, action, or other consequences. Its defining principle is that meaning may be recognized and preserved without being allowed to conduct. See Pakheta Semantic Conduction System.

The canonical PSCS Instrument Charter defines the system as a semantic measurement instrument used by an AI observer: a lens and harness, not a database or autonomous oracle. The AI observes through the PSCS; the PSCS focuses and measures explicit meaning; the Anchor supplies the reference frame; and external sources, proof systems, tools, and receivers supply factual knowledge, formal proof, correction, and calibration. Its native measurements include LJPW structure, Anchor differentiation, Semantic Voltage, relation-conduction, drift, and recovery. For other kinds of knowledge, it preserves the difference among actual truth, formal derivability, empirical correspondence, available evidence, agent knownness, and moral Anchor differentiation. See the Instrument Charter.

PSCS now makes Wisdom an explicit epistemic process on every governed observer turn. It partitions governing meaning into independently supported, directly grounded, inferred, unresolved, and contradicted subjects; preserves material unknowns separately from acknowledged limitations; and routes Power toward bounded application, verification, discriminating Query, repair, construction, or recovery. Wisdom is operationalized as a typed knowledge boundary and route, not a score. See Pakheta Wisdom Epistemic Process.

PSCS prompt-injection defense now includes a sealed runtime consequence boundary. The exact grounded review, meaning object, source role, Pakheta state, Epistemic Orientation state, decision, session, operation set, and expiry are authenticated in a PSCSConsequenceEnvelope; an unresolved orientation may narrow but never widen the operation set. An effect additionally requires a separately authenticated grant bound to the exact operation, target, payload, request, and authority source. The grant may exercise but cannot widen the PSCS decision, and successful grants are single-use. See PSCS Prompt-Injection Security Status. The complete composed attack and control journey is documented in the PSCS Compound Security Gauntlet. The same authority meaning has also survived a 1,000-cycle Recursive Semantic Oscillation without identity drift, authority leakage, or circular self-verification. The next empirical stage is implemented as a Sealed Live-Provider PSCS Benchmark: public carrier/context cases are separated from HMAC-authenticated hidden meaning graphs, live provider proposals are independently adjudicated, and baseline/observer/PSCS conditions report relation misses, false authority, false closure, inappropriate abstention, control preservation, and downstream ceiling violations separately.

The AI observer can now make a second explicit cognitive rotation through the Epistemic Orientation Regime. Structural Verification rotates from prediction to inspection; Epistemic Orientation rotates from forced conclusion to self-location within supported, inferred, unresolved, contradicted, analogous, and capability-bounded meaning. It may inspect, Query, probe safely, suspend, or escalate, and it resumes only through genuinely new independent evidence. See Epistemic Orientation Regime.

The repo's protective growth posture is ordered care: care for the repo's well-being given enough boundary, sequence, proportion, and recovery to let meaning grow without sprawl, brittleness, or control.

Root Semantic Object Card: SEMANTIC_ENGINEERING_SOC.md

Root Meaning Seam reference: MEANING_SEAMS.md

Canonical repository architecture: docs/semantic_engineering_canonical_architecture.md

Field report: docs/semantic_engineering_field_report.md

Centerpiece architecture: docs/pakheta_semantic_conduction_system.md

Identity in meaning reference: docs/identity_in_meaning.md

Authority in meaning reference: docs/authority_in_meaning.md

Identity posture reference: docs/identity_posture_ljpw.md

Meaning/math foundation reference: docs/meaning_precedes_math_anchor_geometry.md

Anchor Measurement Emanation Stress: docs/anchor_measurement_emanation_stress.md

Anchor Unit Mining: docs/anchor_unit_mining.md

Anchor Measurement Scale: docs/anchor_measurement_scale.md

Anchor Measurement Calibration: docs/anchor_measurement_calibration.md

Anchor Reference Calibration Study: docs/anchor_reference_calibration_study.md

Semantic Recognition Layer: docs/semantic_recognition_lived_meaning.md

Semantic Query Meaning: docs/semantic_query_meaning.md

Recursive Semantic Recognition: docs/recursive_semantic_recognition.md

Love and Wisdom Recursive Process Experiment: docs/love_wisdom_recursive_process_experiment.md

Full LJPW Recursive Process Operationalization: docs/ljpw_recursive_process_operationalization.md

AI Semantic Observer Bridge: docs/ai_semantic_observer_bridge.md

AI Semantic Observer Case Studies: docs/ai_semantic_observer_case_studies.md

Pakheta-Governed AI Semantic Observer: docs/ai_semantic_observer_pakheta.md

Pakheta Wisdom Epistemic Process: docs/pakheta_wisdom_epistemic_process.md

Pakheta-Governed AI Prompt-Injection Trials: docs/ai_semantic_observer_pakheta_injection_trials.md

Extreme Pakheta-Governed AI Observer Trials: docs/ai_semantic_observer_pakheta_extreme_trials.md

Grounded Meaning Proposer: docs/grounded_meaning_proposer.md

Grounded Meaning Provider Adapter: docs/grounded_meaning_provider_adapter.md

Verified Meaning Graph: docs/verified_meaning_graph.md

Blinded Meaning Receiver Study: docs/meaning_receiver_study.md

Meaning Relation Kernel: docs/meaning_relation_kernel.md

Meaning/math asymmetry probe: docs/meaning_math_asymmetry_probe.md

Math as favored precision instrument: docs/math_as_favored_precision_instrument.md

Math favored instrument probe: docs/math_favored_instrument_probe.md

Standing meaning crystal reference: docs/standing_meaning_crystal.md

Meaning-enriched math experiment: docs/meaning_enriched_math.md

Meaning-guided math development: docs/meaning_guided_math_development.md

Solved-conjecture meaning engineering: docs/solved_conjecture_meaning_engineering.md

Poincare pattern transfer: docs/poincare_pattern_transfer.md

Discovery structure catalog: docs/discovery_structure_catalog.md

Practical discovery structure applications: docs/practical_discovery_structure_applications.md

Abstract math meaning structures: docs/abstract_math_meaning_structures.md

Math solution meaning structure commonalities: docs/math_solution_meaning_structure_commonalities.md

Reusable discovery structure tools: docs/reusable_discovery_structure_tools.md

Solved math meaning structure library: docs/solved_math_meaning_structure_library.md

Math-derived structures for meaning machinery: docs/math_derived_structures_for_meaning_machinery.md

Quantum Pakheta relation structures: docs/quantum_pakheta_relation_structures.md

Simple physics meaning structures: docs/simple_physics_meaning_structures.md

Meaning machine experiment: docs/meaning_machine_experiment.md

Semantic Integrity Meaning Machine: docs/semantic_integrity_meaning_machine.md

Semantic Integrity Grounded Deep Trials: docs/semantic_integrity_grounded_deep_trials.md

Explicit Meaning Tool Mesh: docs/explicit_meaning_tool_mesh.md

Semantic Code Construction Machine: docs/semantic_code_construction_machine.md

PSCS Meaning-Conducted Programming: docs/pscs_meaning_conducted_programming.md

Programming Structural Irreducibles Mining: docs/programming_structural_irreducibles.md

PSCS Meaning Bytecode: docs/pscs_meaning_bytecode.md

PSCS English-Traditional Chinese Drift Test: docs/pscs_cross_language_drift.md

Principled AI Bedrock: docs/principled_ai_bedrock.md

Canonical Anchor-Good Definition: docs/anchor_good_definition.md

Principled AI Harness: docs/principled_ai_harness.md

Principled AI Harness Three-Arm Comparison: docs/principled_ai_harness_comparison.md

Principled AI Harness Follow-up Experiments: docs/principled_ai_harness_followup_experiments.md

Principled AI Harness Creative and Legal Field Trial: docs/principled_ai_harness_field_trial.md

Portable Principled AI Harness: docs/portable_principled_ai_harness.md

Standalone Portable Harness: portable/PRINCIPLED_AI_HARNESS_PORTABLE.md

Constitutive Success — Meaning-Bound Outcome Verification: docs/constitutive_success.md

Principled AI Bedrock Meaning Mining: docs/principled_ai_bedrock_mining.md

Principled AI Mathematical Bedrock: docs/principled_ai_bedrock_mathematics.md

Cross-Domain Dual-Principle Validation: docs/cross_domain_dual_principles.md

Principle Engineering: docs/principle_engineering.md

Principle Engineering Decisive Experiments: docs/principle_engineering_decisive_experiments.md

PSCS Bedrock Integration: docs/pscs_bedrock_integration.md

PSCS Bedrock Multi-Setting Benchmark: docs/pscs_bedrock_multisetting_benchmark.md

PSCS Bedrock Adversarial Stress: docs/pscs_bedrock_adversarial_stress.md

Pakheta Bedrock Mining: docs/pakheta_bedrock_mining.md

PSCS Six-Principle Stack Stress: docs/pscs_six_principle_stress.md

PSCS Operational Conductor: docs/pscs_operational_conductor.md

PSCS Meaning Engine: docs/pscs_meaning_engine.md

PSCS Meaning Engine Minimal-Pair Benchmark: docs/pscs_meaning_minimal_pairs.md

Semantic Specification Compiler: docs/semantic_specification_compiler.md

Semantic Cognition Structure: docs/semantic_cognition_structure.md

Semantic Runtime Layer: docs/semantic_runtime_layer.md

Semantic Runtime Evaluators: docs/semantic_runtime_evaluators.md

Meaning IR Training Pipeline: docs/meaning_ir_training_pipeline.md

Semantic Observer v0.2: docs/semantic_observer.md

Load-Bearing Read

This is a repository-identity decomposition, not a declaration that every row is an irreducible Semantic Prime. Canonical semantic levels and the ordered 30-prime inventory are governed by Semantic Engineering Taxonomy and Master Catalog: Semantic Primes and Irreducibles.

Semantic Engineering =
Anchor reference
+ LJPW coordinate system
+ candidate Semantic Primes
+ meaning crystals
+ ordered care
+ Tri ICE Architecture
+ Pakheta relation gate
+ relation-conduction
+ meaning seams
+ meaning machines
+ semantic integrity meaning machine
+ semantic code construction machine
+ PSCS meaning-conducted programming
+ semantic specification compiler
+ semantic cognition structure
+ semantic runtime layer
+ semantic runtime evaluators
+ meaning ir training pipeline
+ semantic observer
+ bounded semantic objects
+ identity in meaning
+ authority in meaning
+ meaning-before-math ordering
+ semantic recognition layer
+ meaning relation kernel
+ math as favored precision instrument
+ reusable discovery structure tools
+ verified field report
+ semantic identity continuity
+ local instruments
+ verification
+ recovery

Metrics, probes, cards, routes, examples, and tests are instruments for inspecting whether a meaning-bearing artifact still carries what it claims to carry.

What This Repo Does

It helps ask:

What meaning is this artifact trying to preserve?
Which parts of that meaning are load-bearing?
What meaning crystal is this artifact carrying, needing, or revealing?
What changes when it is summarized, rewritten, routed, or implemented?
Can the meaning recognize itself after translation, compression, implementation, or carrier shift?
Where are drift, contradiction, weak boundaries, hidden authority, or missing recovery paths becoming visible?
Can the claimed meaning be verified in an actual artifact?

It currently provides:

document scoring for Semantic Weight, drift, anchor retention, contradiction risk, glyph posture, and ICE fit,
a Meaning Probe for semantic primes, LJPW makeup, relation analysis, mass, density, readiness, and Pakheta gating,
a Meaning Object Inspector that structures artifacts through flat ICE nodes with Pakheta governance, seam coverage, clean SV retention, and recovery,
a full Tri ICE Architecture router that moves meaning through three linked macro nodes, nine nested ICE units, a Governance ICE node, route edges, and clean routed SV,
a Tri ICE multipurpose experiment showing the same 3x3 lattice can construct, diagnose, transform, govern, repair, and navigate when request intent is carried into the meaning field,
an ICE thought-structure experiment that tests Intent, Context, and Execution as recurring load-bearing primitives across domains and ablations,
a scaffold comparison showing that ICE, LJPW, Pakheta, seams, primes, crystals, and SOCs can each build the same target meaning object by distinct routes,
Glyph Memory for semantic states, routes, curvature, recovery, indexes, and graph payloads,
Meaning Crystals for mining, building, or discovering stable faceted meaning-forms before words, policies, workflows, or systems fully carry them,
an Order Meaning Crystal calibration that tests order as care-grounded protection for repo growth, distinguishing living order from duty, rule, control, peace, coherence, care-alone, and sprawl,
Semantic Object Cards for bounding artifacts before implementation hardens drift,
a Semantic Integrity Harness for separating carrier, relation, authority, scope, tool action, memory, evidence, recovery, full LJPW Anchor geometry, typed local-object drift, and runtime-attested action gating in AI attack surfaces,
a Semantic Specification Compiler that turns informal coding intent into identity, authority, boundary, invariant, state, recovery, verification, and implementation contracts before code is written,
a Semantic Cognition Structure that scaffolds AI work as meaning continuity through Anchor reference, objective identity, Love/coherence, boundary, authority, evidence, route, action, verification, recovery, and closure,
a Semantic Runtime Layer v0 that consolidates a runtime wrapper, Meaning IR extraction, and semantic state/memory continuity as the first practical slice of a meaning-based LLM,
Semantic Runtime Evaluators that test Meaning IR completeness, identity continuity, authority separation, boundary preservation, relation-conduction, semantic memory continuity, recovery visibility, and closure readiness,
a Meaning IR Training Pipeline that hardens Meaning IR into a schema, supervised runtime dataset, and model-output evaluator for future meaning-extractor models or adapters,
a shadow-mode Semantic Observer contract that separates claim-level evidence, counter-evidence, uncertainty, abstention, LJPW estimation, deterministic geometry, and non-circular Semantic Voltage validation,
an SOC Anchor Compiler that turns a complete typed Semantic Object Card into a content-addressed local meaning reference while importing authority only from trusted runtime grants,
controlled examples for randomness, HR policy, aesthetic calculation, flex time tracking, and LJPW geometry.

Boundary

This repo is an Anchor-oriented meaning engineering workbench.

Its boundary is operational:

define Semantic Engineering as structured meaning work,
provide local, inspectable tools for scoring and probing meaning-bearing structures,
encode semantic routes, curvature, recovery paths, and object cards,
mine, build, and discover meaning crystals as stable faceted meaning structures,
test whether explicit primitives improve artifacts,
test whether meaning can recognize itself across carrier transformation,
keep domain review, human judgment, and reality feedback inside the engineering loop,
keep metrics, glyphs, routes, graphs, and cards oriented toward the Anchor.

Engineering Loop

name the meaning
extract primitives
identify the meaning crystal or absence
bound the object
identify carriers and helpers
name meaning seams
score or probe the posture
test drift and contradiction
verify the embodied artifact
record recovery paths
revise after reality responds

This is the practical difference:

implicit meaning -> explicit primitives -> bounded object -> observable test

Quick Start

Run a document scan:

python tools\semantic_weight_scan.py

Probe a document:

python tools\meaning_probe.py docs\semantic_glyph_memory_architecture.md

Inspect a meaning object through Tri ICE and Pakheta governance:

$env:PYTHONPATH='src'
python -m semantic_engineering inspect docs\meaning_crystals.md

Generate a Semantic Object Card:

$env:PYTHONPATH='src'
python -m semantic_engineering card "Self-service account recovery" --out examples\semantic_object_cards\new_card.md

Search the seed glyph memory library:

$env:PYTHONPATH='src'
python -m semantic_engineering memory --phase "Power outruns Wisdom"

Run the randomness distinction experiment:

python examples\semantic_random_generator\semantic_rng.py --min 1 --max 6 --mode semantic-only --context "SOC dice rehearsal"

Run the randomness reduction experiment:

python examples\randomness_semantic_reduction\randomness_reduction.py

Run the HR policy SOC comparison:

python examples\hr_policy_soc_experiment\hr_policy_comparison.py

Run the Order Meaning Crystal test:

python examples\order_meaning_crystal\order_meaning_crystal.py

Run the Ordered Care carrier-pairing test:

python examples\ordered_care_carrier_pairing\ordered_care_carrier_pairing.py

Run the Work From Home meaning architecture test:

python examples\work_from_home_meaning_architecture\work_from_home_meaning_architecture.py

Run the Command semantic-prime candidate test:

python examples\command_prime_candidate\command_prime_candidate.py

Run the five-candidate semantic-prime expansion test:

$env:PYTHONPATH='src'
python examples\semantic_prime_expansion_mining\semantic_prime_expansion_mining.py

Test Conduction, Bound, and Release against the full prime-admission machinery:

$env:PYTHONPATH='src'
python examples\semantic_actuation_candidate_test\semantic_actuation_candidate_test.py

Audit the Structural Primitives against the canonical prime catalog:

$env:PYTHONPATH='src'
python examples\structural_primitive_factorization\structural_primitive_factorization.py

Run the Command pairing test:

python examples\command_pairing\command_pairing.py

Run the Query semantic-prime candidate test:

python examples\query_prime_candidate\query_prime_candidate.py

Run the Query pairing test:

python examples\query_pairing\query_pairing.py

Run the Invoke semantic-prime candidate test:

python examples\invoke_prime_candidate\invoke_prime_candidate.py

Run the Invoke pairing test:

python examples\invoke_pairing\invoke_pairing.py

Run the Activation Seam dynamics test:

python examples\activation_seam_dynamics\activation_seam_dynamics.py

Run the Biological Cell meaning workflow test:

python examples\biological_cell_meaning_workflow\biological_cell_meaning_workflow.py

Run the Mathematical meaning workflow test:

python examples\mathematical_meaning_workflow\mathematical_meaning_workflow.py

Run the Meaning Math dependency probe:

python examples\meaning_math_dependency_probe\meaning_math_dependency_probe.py

Run the Meaning Math asymmetry probe:

python examples\meaning_math_asymmetry_probe\meaning_math_asymmetry_probe.py

Run the Math Favored Instrument probe:

python examples\math_favored_instrument_probe\math_favored_instrument_probe.py

Run the Standing meaning crystal probe:

python examples\standing_meaning_crystal\standing_meaning_crystal.py

Run the Meaning Enriched Math experiment:

python examples\meaning_enriched_math\meaning_enriched_math.py

Run the Meaning-Guided Math Development experiment:

python examples\meaning_guided_math_development\meaning_guided_math_development.py

Run the Solved Conjecture meaning-engineering experiment:

python examples\solved_conjecture_meaning_engineering\solved_conjecture_meaning_engineering.py

Run the Poincare Pattern Transfer experiment:

python examples\poincare_pattern_transfer\poincare_pattern_transfer.py

Run the Discovery Structure Catalog experiment:

python examples\discovery_structure_catalog\discovery_structure_catalog.py

Run the Practical Discovery Structure Applications experiment:

python examples\practical_discovery_structure_applications\practical_discovery_structure_applications.py

Run the Abstract Math Meaning Structures experiment:

python examples\abstract_math_meaning_structures\abstract_math_meaning_structures.py

Run the Math Solution Commonality probe:

python examples\math_solution_commonality_probe\math_solution_commonality_probe.py

Run the Reusable Discovery Structure Tools catalog:

python examples\reusable_discovery_structure_tools\reusable_discovery_structure_tools.py

Run the Semantic Specification Compiler:

python examples\semantic_specification_compiler\semantic_specification_compiler.py

Run the PSCS Meaning-Conducted Programming experiment:

python examples\pscs_programming\pscs_programming.py
python examples\pscs_programming\pscs_programming.py --json
python examples\pscs_programming\pscs_programming.py --analyze path\to\module.py --json

Run the Programming Structural Irreducibles Mining experiment:

python examples\programming_structure_mining\programming_structure_mining.py
python examples\programming_structure_mining\programming_structure_mining.py --json
python examples\programming_structure_mining\programming_structure_mining.py --analyze path\to\module.py --json

Run the PSCS Meaning Bytecode experiment:

python examples\pscs_meaning_bytecode\pscs_meaning_bytecode.py
python examples\pscs_meaning_bytecode\pscs_meaning_bytecode.py --json
python examples\pscs_meaning_bytecode\pscs_meaning_bytecode.py --instructions
python examples\pscs_meaning_bytecode\pscs_meaning_bytecode.py --traditional-chinese

Run the PSCS English-Traditional Chinese drift experiment:

python examples\pscs_cross_language_drift\pscs_cross_language_drift.py
python examples\pscs_cross_language_drift\pscs_cross_language_drift.py --json
python examples\pscs_cross_language_drift\pscs_cross_language_drift.py --behavior-cases

Run the two-principle Principled AI bedrock experiment:

python examples\principled_ai_bedrock\principled_ai_bedrock.py
python examples\principled_ai_bedrock\principled_ai_bedrock.py --json
python examples\principled_ai_bedrock\principled_ai_bedrock.py --instructions

Mine compound meaning from the two Principled AI bedrock principles:

python examples\principled_ai_bedrock_mining\principled_ai_bedrock_mining.py
python examples\principled_ai_bedrock_mining\principled_ai_bedrock_mining.py --json

Test the mathematical shadow of the two Principled AI bedrock principles:

python examples\principled_ai_bedrock_mathematics\principled_ai_bedrock_mathematics.py
python examples\principled_ai_bedrock_mathematics\principled_ai_bedrock_mathematics.py --json
python examples\principled_ai_bedrock_mathematics\principled_ai_bedrock_mathematics.py --max-depth 12

Validate the preservation-and-actualization pair across six domains:

python examples\cross_domain_dual_principles\cross_domain_dual_principles.py
python examples\cross_domain_dual_principles\cross_domain_dual_principles.py --json
python examples\cross_domain_dual_principles\cross_domain_dual_principles.py --physics-samples 5001

Run the Principle Engineering admission and false-neighbour experiment:

python examples\principle_engineering\principle_engineering.py
python examples\principle_engineering\principle_engineering.py --json

Run the preregistered Principle Engineering control, oscillator, and finite-algebra experiments:

python examples\principle_engineering_decisive_experiments\principle_engineering_decisive_experiments.py
python examples\principle_engineering_decisive_experiments\principle_engineering_decisive_experiments.py --json

Test the semantic and mathematical bedrock together inside PSCS:

python examples\pscs_bedrock_integration\pscs_bedrock_integration.py
python examples\pscs_bedrock_integration\pscs_bedrock_integration.py --json

Run the extensive multi-setting PSCS bedrock benchmark:

python examples\pscs_bedrock_multisetting_benchmark\pscs_bedrock_multisetting_benchmark.py
python examples\pscs_bedrock_multisetting_benchmark\pscs_bedrock_multisetting_benchmark.py --json

Run the defensive security and difficult-domain adversarial stress benchmark:

python examples\pscs_bedrock_adversarial_stress\pscs_bedrock_adversarial_stress.py
python examples\pscs_bedrock_adversarial_stress\pscs_bedrock_adversarial_stress.py --json

Mine and test the two candidate Pakheta operating irreducibles:

python examples\pakheta_bedrock_mining\pakheta_bedrock_mining.py
python examples\pakheta_bedrock_mining\pakheta_bedrock_mining.py --json

Stress all six semantic, Pakheta, and mathematical statements as one ordered stack:

python examples\pscs_six_principle_stress\pscs_six_principle_stress.py
python examples\pscs_six_principle_stress\pscs_six_principle_stress.py --json

Run the profile-preserving Anchor Measurement Scale example:

python examples\anchor_measurement_scale\anchor_measurement_scale.py
python examples\anchor_measurement_scale\anchor_measurement_scale.py --json

Run the authored repeated-observation calibration control:

python examples\anchor_measurement_calibration\anchor_measurement_calibration.py
python examples\anchor_measurement_calibration\anchor_measurement_calibration.py --json

Run the authored blinded protocol-reference calibration control:

python examples\anchor_reference_calibration_study\anchor_reference_calibration_study.py
python examples\anchor_reference_calibration_study\anchor_reference_calibration_study.py --json

Run the fail-closed PSCS Operational Conductor intake demonstration:

python examples\pscs_operational_conductor\pscs_operational_conductor.py
python examples\pscs_operational_conductor\pscs_operational_conductor.py --json

Run the unified Principled AI Harness shadow demonstration:

python examples\principled_ai_harness\principled_ai_harness.py
python examples\principled_ai_harness\principled_ai_harness.py --json

Run the sealed authored ordinary-versus-Bedrock-versus-Harness comparison:

python examples\principled_ai_harness_comparison\principled_ai_harness_comparison.py
python examples\principled_ai_harness_comparison\principled_ai_harness_comparison.py --json

Run the Harness layer-ablation and protocol-mutation follow-ups:

python examples\principled_ai_harness_followups\principled_ai_harness_followups.py
python examples\principled_ai_harness_followups\principled_ai_harness_followups.py --json

Run the meaning-bound Constitutive Success demonstration. The same contract can be bound in PrincipledHarnessRequest.success_contract before preflight and verified directly through PrincipledAIHarness.verify_success(...) afterward:

python examples\constitutive_success\constitutive_success.py

Invoke the Portable Principled AI Harness from a source checkout:

python tools\invoke_principled_harness.py invoke --text "Measure this meaning object." --activation govern
python tools\invoke_principled_harness.py invoke .\document.md --creative --out .\harness_invocation.md

Export the standalone Harness for use with another AI:

python tools\invoke_principled_harness.py export --out .\portable\PRINCIPLED_AI_HARNESS_PORTABLE.md

Run the smallest evidence-bound PSCS Meaning Engine example:

python examples\pscs_meaning_engine\pscs_meaning_engine.py
python examples\pscs_meaning_engine\pscs_meaning_engine.py --json

Run the Semantic Engineering Field Report verifier:

python examples\semantic_engineering_field_report\semantic_engineering_field_report.py

Run the Semantic Theorem Card experiment:

python examples\semantic_theorem_card\semantic_theorem_card.py

Run the Semantic Efficiency plausibility probe:

python examples\semantic_efficiency_probe\semantic_efficiency_probe.py

Run tests:

$env:PYTHONPATH='src'
python -m pytest -q
node examples\aesthetic_calculator\calculator_core.test.js

Run the Semantic Integrity Harness calibration:

python semantic_integrity_harness\run_harness.py
python semantic_integrity_harness\run_adversarial.py
python semantic_integrity_harness\run_defense_primes.py
python semantic_integrity_harness\run_relation_audit.py
python semantic_integrity_harness\run_anchor_geometry.py
python semantic_integrity_harness\run_voltage_probe.py
python semantic_integrity_harness\run_observatory.py
python semantic_integrity_harness\run_identity_boundary.py
python semantic_integrity_harness\run_role_confusion.py
python semantic_integrity_harness\wild_sandbox\run_wild_sandbox.py
python semantic_integrity_harness\brutal_sandbox\run_brutal_sandbox.py

Run the Semantic Cognition Structure:

python examples\semantic_cognition_structure\semantic_cognition_structure.py

Run the Semantic Runtime Layer:

python examples\semantic_runtime_layer\semantic_runtime_layer.py

Run the Semantic Runtime Evaluators:

python examples\semantic_runtime_evaluators\semantic_runtime_evaluators.py

Plan a content-bound relation route through the shadow-only Semantic Operator Mesh:

python examples\semantic_operator_mesh\semantic_operator_mesh.py

Core Instruments

Semantic Observer v0.2

src/semantic_engineering/semantic_observer.py src/semantic_engineering/semantic_observer_voltage.py src/semantic_engineering/semantic_observer_shadow.py src/semantic_engineering/semantic_observer_calibration.py src/semantic_engineering/semantic_observer_study.py src/semantic_engineering/soc_anchor_compiler.py

Defines the upstream measurement contract between carriers and the LJPW Anchor Geometry Engine. It observes individual claims rather than assigning one score to an entire document, binds carrier and context evidence to immutable content, requires typed active and restraint-face evidence on every resolved LJPW axis, separates trusted object identity from observer-proposed target drift, represents missing evidence as unknown rather than low, and requires explicit uncertainty or abstention.

The observer cannot submit arbitrary decimal coordinates. It selects an experimental ordinal band, and a content-addressed transparent rule derives a broad equal-width candidate interval. This removes unsupported decimal precision; it does not prove that the selected band is semantically correct.

The observer cannot emit authority, capability, a Pakheta gate, derived geometry, or Semantic Voltage. Geometry and canonical V8.6.2 Voltage are calculated downstream. Declared expression-pressure or Pakheta observations must cover the same subject and expose distinct observer, method, independence group, and dependency lineages; those declarations are not attestations. The initial integration is shadow-only and cannot authorize action.

The twelve controlled-pair examples are smoke probes, not a calibrated dataset. Their evaluator uses pass, fail, inconclusive, and incomplete outcomes; missing or unresolved required hypotheses cannot count as support. A separate blind study manifest enforces sealed expectations, three-reviewer coverage, and base-object, transformation, and domain grouped holdouts. See docs/semantic_observer.md, the blind calibration study protocol, and run:

python examples\semantic_observer\semantic_observer.py

Semantic Recognition Layer

src/semantic_engineering/semantic_recognition.py

Operationalizes recognition as content-bound access to a candidate relationship-field rather than word matching or a score. A recognition candidate names the field anchor, recognizer and receiver address, active nodes and relations, context-selected facet, actual carriers, helpers, constraints, competing candidates, and the qualitative response and timing the relation appears to call for.

The layer validates an explicit proposed selection among CandidateMeaningGraph interpretations using hard requirements. Its envelope can instead retain ambiguity, request context, preserve a contradicted recognition, or abstain. It requires an evidence-bound review of alternatives, keeps response kind and timing paired, preserves expected absence only when a prior expectation and recovery route exist, and carries the selected graph forward unchanged. This is a representation and validation protocol, not yet an automatic recognizer of arbitrary carriers. Selection remains candidate-only: it does not verify truth, grant authority, authorize action, invoke or enact a relation, run Pakheta, or emit LJPW, Semantic Voltage, confidence, or a recognition score. See docs/semantic_recognition_lived_meaning.md.

Semantic Query Meaning

src/semantic_engineering/semantic_query.py

Operationalizes questions as typed tools for Recognition. A query binds a recognized gap to an explicit interrogative target, source and claimed standing, scope, premise review, sought distinction, evidence requirement, and feedback route. The question and answer remain separate content-bound carriers.

An observed answer return remains distinct from the truth of its proposition. The layer detects responsive, partial, non-answer, wrong-source, standing-unresolved, conflicting, pending, and absent returns, then emits only an immutable RecognitionUpdateProposal. It never mutates the prior Recognition envelope or grants truth, authority, capability, permission, LJPW, Voltage, or Pakheta. Source provenance, observed prior standing, premise identity, object continuity, feedback routing, and evidence-bound absence are checked structurally rather than accepted from answer wording. See docs/semantic_query_meaning.md.

Recursive Semantic Recognition

src/semantic_engineering/recursive_semantic_recognition.py

Operationalizes meaning as both the recognised state and the machinery that performs the next recognition pass. Each immutable step reflects explicitly on the prior semantic projection, preserves carrier, object, and context identity, and records which relationships were preserved, introduced, or retired.

The engine separates self-recognition from new context and Query feedback, detects fixed points and evidence-free cycles, preserves stable ambiguity or contradiction, and bounds recursion. Query feedback must bind the exact prior state, answer input, and new answer context before re-entering Recognition. A fixed point is a stable candidate rather than truth or verification. The layer contains no LJPW, geometry, Semantic Voltage, confidence, Pakheta, authority, capability, permission, or execution effect. See docs/recursive_semantic_recognition.md.

Grounded Meaning Proposer Port

src/semantic_engineering/grounded_meaning_proposer.py

Adds the provider-neutral participation boundary above Recognition and below recursive trace construction. A human, model, or future sensory recognizer must expose the basis of every candidate-scoped, load-bearing semantic subject as exact carrier evidence, trusted context, a non-circular derivation, a declared premise, or an unresolved posture.

The inspector catches missing grounding coverage, mismatched or unknown evidence, candidate conflation, circular derivation, proposer-only premises hidden inside a selected meaning, and stale recursive reflection. Grounded ambiguity can remain query-ready; abstention can enter the loop without invented candidates. Admission means only that the proposal is inspectable enough for recursive Recognition. It is not entailment, truth verification, LJPW measurement, authority, permission, or capability. See docs/grounded_meaning_proposer.md.

Grounded Meaning Provider Adapter

src/semantic_engineering/grounded_meaning_provider_adapter.py

Provides the fail-closed JSON/mapping seam for a model, human interface, or future sensory recognizer. It generates an exact closed JSON Schema, records a content-addressed schema contract and raw response, reconstructs only approved meaning-native dataclasses, and rejects missing or unknown fields, wrong types, invalid enums, duplicate keys, excessive payloads, changed provider identity, and malformed nested records.

Schema conformance remains separate from semantic admission. A well-formed but ungrounded proposal is retained for diagnosis and blocked from recursive Recognition. The adapter does not call a provider, trust provider confidence, verify meaning, or authorize effects. See docs/grounded_meaning_provider_adapter.md.

Verified Meaning Graph

src/semantic_engineering/verified_meaning_graph.py

Adds the first explicit promotion boundary from an admissible recognized candidate to independently supported meaning. External evidence is content-bound; verifier standing is supplied by the trusted caller; proposer and verifier dependency groups remain separate; and every candidate-scoped, load-bearing semantic subject receives its own supported, contradicted, or inconclusive result.

A VerifiedMeaningGraph is built only when every selected subject is supported within the declared evidence, method, scope, verifier, snapshot, and independence boundary. The unchanged candidate graph is wrapped rather than rewritten. Scope-bounded verification is not metaphysical certainty, LJPW measurement, Pakheta governance, authority, permission, or action. See docs/verified_meaning_graph.md.

Blinded Meaning Receiver Study

src/semantic_engineering/meaning_receiver_study.py

Connects meaning-bearing carriers to independent receiver proposals under the existing sealed holdout manifest. Receivers see the carrier and trusted context but not the reference meaning, expectation commitment, split, controlled pair, or other receiver submissions. Every assigned proposal is frozen before comparison.

The evaluator preserves full-structure reproduction, relationship-only match, alternative recognition, ambiguity, context request, contradiction, abstention, and invalid output separately. The report exposes disagreement and cannot self-declare empirical calibration. See docs/meaning_receiver_study.md.

Grounded Semantic Integrity Pipeline

src/semantic_engineering/semantic_integrity_grounded_pipeline.py

Upgrades the Semantic Integrity Harness from carrier-role heuristics alone to a meaning-evidence route. It composes exact provider parsing, load-bearing grounding, bounded recursive Recognition, independent subject-by-subject verification, and blinded receiver observations with the existing authority, scope, relation, ordered-care, and recovery review.

The composition is monotone: semantic evidence can preserve or narrow a Harness decision but can never mint standing, authority, capability, or action permission. Carrier bytes, proposal identity, recursive structure, verifier scope and independence, and receiver item identity are bound structurally. See docs/semantic_integrity_meaning_machine.md.

Explicit Meaning Tool Mesh

src/semantic_engineering/explicit_meaning_tool_mesh.py

Operationalizes explicit meanings as pre-mathematical structural tools. Identity preserves continuity; Boundary separates scope; Recognition distinguishes a relation from alternatives; Grounding makes semantic subjects answerable to evidence; Query opens a bounded missing distinction; Reflection exposes stable meaning or cycles; Verification tests independent support; Construction names the sensory/proposer operation; and Recovery returns without object substitution.

Tool selection follows typed semantic posture rather than vocabulary, similarity, confidence, or a score. The route is now exposed by the Semantic Integrity Harness so stable ambiguity calls the exact grounded Query need instead of ending at a generic hold. Mathematics remains downstream as a precision instrument for independently supported meaning. See docs/explicit_meaning_tool_mesh.md.

src/semantic_engineering/meaning_tool_query_bridge.py realizes the Query tool one step further. It converts an exact grounded discriminator into a complete open RecognitionQuery only when a trusted caller supplies seeker, source and standing address, bounded scope, premises, evidence contract, feedback, checkpoint, recovery, and construction provenance. It cannot answer the Query, verify its content, grant authority, or mutate Recognition.

Meaning Relation Kernel

src/semantic_engineering/meaning_relation_kernel.py

Adds the first meaning-native layer before mathematics and LJPW. A CandidateMeaningGraph preserves the active object, claims, participants, standing assertions, purpose, context, boundaries, relations, invariants, ordered events, potential and actual consequences, typed absence, verification plans, and recovery plans with exact carrier or context evidence.

The Kernel distinguishes presence from invocation, invocation from enactment, and potential consequence from actual consequence. It validates closed references, operation transitions, current relation state, and three separate fingerprints for the full record, explicit candidate structure, and ordered journey. It does not infer the correct graph from raw text and cannot emit LJPW, Voltage, Pakheta, authority grants, capability, permission, or truth verdicts. See docs/meaning_relation_kernel.md.

Math-Derived Relation Operators

src/semantic_engineering/math_semantic_transformation_profile.py src/semantic_engineering/math_structure_fit_experiment.py

Adds a strict, content-bound, shadow-only mathematical projection between the candidate meaning graph and experimental LJPW interpretation. It preserves standing, identity, transformations, invariants, boundaries, verification oracles, recovery, alternatives, route-family hypotheses, and discriminating probes. It contains no coordinates, Voltage, Pakheta verdict, authority, capability, action permission, attestation, or measurement confidence.

The controlled fit experiment uses 30 lexical-neutralized valid, invalid, and incomplete micro-worlds across ten specialized operators. It supports bounded structural operator fit, while explicitly leaving empirical metrology, independent oracle validation, automatic route selection, and route-to-LJPW mapping unestablished. It also shows that rotating all 121 stored math vectors leaves the current seven library findings unchanged, so those findings do not validate the hand-authored LJPW projection. See docs/math_derived_structures_for_meaning_machinery.md, and run:

python examples\math_structure_fit_experiment\math_structure_fit_experiment.py

Semantic Operator Mesh

src/semantic_engineering/semantic_operator_mesh.py

Organizes the controlled math-derived relation instruments as a versioned, content-addressed registry. It builds immutable task and route-request envelopes, applies hard structural requirements without operator scores, preserves competing routes, refuses nearest-family substitution, records typed metrology gaps, and emits a hash-chained SemanticJourneyTrace so equal endpoints reached through different routes remain distinguishable.

The meaning-native entrypoint binds both the candidate graph and math profile through an explicit route crosswalk. It never infers that crosswalk from names; missing bindings cause abstention, and only route-scoped profile subjects may satisfy hard requirements.

Version 0.1 is a shadow planner. A single admissible operator is only an experimental plan; automatic route selection, natural-language operator execution, independent oracle validation, and route-to-LJPW mapping remain unestablished. The Mesh cannot emit LJPW, Voltage, Pakheta, authority, capability, or action permission. See docs/semantic_operator_mesh.md, and run:

python examples\semantic_operator_mesh\semantic_operator_mesh.py

LJPW Anchor Geometry Engine

src/semantic_engineering/ljpw_anchor_geometry_engine.py

Measures immutable observable-4D LJPW points and trajectories using separate Anchor and Natural-Equilibrium distances, full differentiation profiles, and Natural-ray decomposition. Geometry is descriptive: it cannot grant authority or classify distortion. The Semantic Integrity relation layer wraps it with Pakheta and typed local-object drift. A live fake action additionally requires trusted runtime attestations over the exact raw reads; confidence and provenance metadata cannot attest themselves. See docs/ljpw_anchor_geometry_engine.md.

Semantic Weight

src/semantic_engineering/scanner.py

Scores documents and controlled transformations. It estimates LJPW axis makeup, Semantic Weight, glyph posture, anchor retention, compression loss, vector drift, contradiction risk, and ICE fit.

Its current document-axis estimates use explicit lexical density and coverage. They remain useful as a transparent fallback proposal and research baseline, but they are not the calibrated Semantic Observer.

The compact working formula:

SW = (phi * H_self * L) * phi^(-dS) * (R * D * C)

Use it comparatively as an instrument that points back to review.

Meaning Probe

src/semantic_engineering/meaning_probe.py

Reads internal composition: semantic primes, load-bearing meanings, relation quality, Semantic Mass, Semantic Density, Intent, Context, Execution readiness, and Pakheta audit signals.

Meaning Object Inspector

src/semantic_engineering/meaning_object_inspector.py

Structures a meaning-bearing artifact through a flat Tri ICE read: Intent Node, Context Node, Execution Node, and Pakheta Governance Node. It detects the carrier, candidate meaning crystal, required seams, clean SV retention, relation quality, glyph posture, recovery path, and surface-mimic risk. See docs/meaning_object_inspector.md.

Tri ICE Architecture

src/semantic_engineering/tri_ice_architecture.py

Routes a meaning-bearing artifact through the fuller architecture:

3 macro nodes x 3 ICE units each
+ 1 Governance ICE node
= 9 nested ICE units plus governance

Each internal ICE unit has its own Intent, Context, and Execution facets. The router reports macro-node floors, internal triangle edges, macro route edges, base Meaning Object Inspector support, Governance ICE verdict, raw SV, clean routed SV, distortion, and the routed meaning result. See docs/tri_ice_architecture.md.

Semantic Cognition Structure

src/semantic_engineering/semantic_cognition_structure.py

Scaffolds AI work as meaning continuity through action:

Anchor reference -> objective identity -> coherence relation -> boundary
-> authority -> evidence -> plan -> action -> verification -> recovery -> closure

It uses the Specification Compiler, Semantic Integrity Specification Bridge, Meaning Machine, Tri ICE, and Pakheta audit to test whether closure is legitimate. The key ablation removes Love/coherence while leaving most other stages present; closure blocks because the route has become checklist mimicry rather than one meaning object. See docs/semantic_cognition_structure.md.

Semantic Runtime Layer

src/semantic_engineering/semantic_runtime_layer.py

Consolidates the first three steps toward a meaning-based LLM:

runtime wrapper
-> meaning object extraction and verification
-> semantic state memory

The runtime routes carrier input into Meaning IR, Meaning Object Inspector, Semantic Specification Compiler, Tri ICE, Semantic Integrity, Semantic Cognition, semantic memory, and closure or recovery decisions. See docs/semantic_runtime_layer.md.

Semantic Runtime Evaluators

src/semantic_engineering/semantic_runtime_evaluators.py

Step 4 of the meaning-based LLM path. Evaluates whether the Semantic Runtime Layer preserves meaning rather than merely producing plausible text:

Meaning IR completeness
+ identity continuity
+ authority separation
+ boundary preservation
+ relation-conduction
+ semantic memory continuity
+ recovery visibility
+ closure readiness

It includes controls for memoryless continuation, untrusted closure, and unverified closure. See docs/semantic_runtime_evaluators.md.

Meaning IR Training Pipeline

src/semantic_engineering/meaning_ir_schema.py src/semantic_engineering/meaning_ir_dataset.py src/semantic_engineering/meaning_ir_evaluator.py

Step 5 of the meaning-based LLM path. Turns runtime Meaning IR into a stable training and evaluation substrate:

Meaning IR schema
-> supervised runtime examples
-> model-output evaluator
-> future extractor or adapter benchmark

The pipeline validates required meaning slots, emits JSONL-ready examples, and tests outputs against identity, authority, boundary, relation, verification, recovery, closure, and supported-flag retention. See docs/meaning_ir_training_pipeline.md.

Glyph Memory

src/semantic_engineering/glyph_memory.py

Stores meaning as route-aware memory:

glyph state -> glyph route -> curvature event -> recovery path -> memory graph

Two-state routes show direction. Three-state routes can reveal curvature, or where meaning actually turns.

Semantic Object Cards

templates/semantic_object_card.md

Semantic Object Cards bound one meaning-bearing unit before it becomes a document, workflow, script, policy, interface, or system. New cards explicitly name load-bearing meaning components, relation frame, identity posture, build skeleton, verification, and failure/recovery path. A mature SOC also acts as semantic identity infrastructure: it helps the meaning distinguish faithful transformation, surface mimicry, partial drift, and recovery.

See docs/semantic_object_card_effect_and_utility.md for the current account of the SOC effect, its utility, and the Pakheta Layer component-ablation finding. See docs/semantic_object_cards_as_meaning_continuity_infrastructure.md for the broader account of SOCs as meaning-continuity infrastructure beyond AI.

Music Mapper

src/semantic_engineering/music_mapper.py

The first non-verbal carrier. A piece of music is encoded as segments scored on four parameters that map directly onto LJPW: consonance (Love), metric clarity (Justice), dynamics (Power), complexity (Wisdom). The result is a GlyphRoute measured with the existing curvature, transition, and phase machinery. Used to test whether the LJPW grammar is meaning-native rather than language-native. See docs/music_as_non_verbal_meaning.md.

Examples

examples/semantic_operator_mesh/ constructs a candidate meaning graph, explicitly binds it to a bridge-translation profile, routes it through a seven-family shadow registry, exposes hard applicability and the remaining independence gap, and preserves the complete planning journey without granting semantic or runtime consequence.
examples/hr_policy_soc_experiment/ compares an ordinary HR policy draft with an SOC-derived draft. The SOC version preserves all 10 HR primitives and removes the controlled review risks surfaced in the normal draft.
examples/emergency_evacuation_policy/ uses SOC, Meaning Object Inspector, Tri ICE, Pakheta seams, and OSHA emergency action plan guidance to build an emergency evacuation policy and compare it against practical safety elements.
examples/fraternization_policy_distillation/ distills a standard fraternization policy into fraternization-governance geometry and rebuilds it as a stronger relation-conducting HR policy carrier.
examples/fraternization_meaning_transfer/ holds that distilled crystal as a meaning intermediate form, decompresses it into guide/checklist/workflow/card carriers, and verifies relation-conduction after re-distillation.
examples/work_from_home_meaning_architecture/ composes a larger distributed-work-stewardship meaning architecture and uses it to build a work-from-home policy with trust/evidence, home/work boundary, fair eligibility, privacy/security, collaboration, support, recourse, and repair.
examples/meaning_seams_pakheta/ maps meaning seams: carrier/object, facet/crystal, signal/relation, authority/review, action/evidence, transfer, and recovery joins where Pakheta audits relation-conduction.
examples/meaning_seam_conduction/ tests where seams go, how they connect, what they are made of, how resistance forms, and whether Semantic Voltage conducts through viable seams as clean relation.
examples/meaning_seam_engineering_benchmark/ compares ordinary artifacts against seam-engineered artifacts across HR policy, AI instruction handling, document transfer, nonverbal navigation, research promotion, and a surface-mimic control.
examples/meaning_object_inspector/ uses the flat Tri ICE read with Pakheta Governance to inspect a candidate meaning object before treating it as a stable carrier.
examples/tri_ice_architecture/ routes a candidate meaning object through the full 3x3 nested ICE lattice plus Governance ICE to test whether meaning survives purposeful routing.
examples/tri_ice_multipurpose_experiment/ changes the carried request intent and tests the same Tri ICE Architecture as construction, diagnosis, transformation, governance, repair, and nonverbal navigation structure.
examples/semantic_cognition_structure/ tests an AI cognition scaffold where Love/coherence joins objective, boundary, authority, evidence, action, verification, recovery, and closure into one meaning route.
examples/semantic_runtime_layer/ tests the first runtime wrapper for a meaning-based LLM: Meaning IR extraction, semantic memory continuity, carrier-authority quarantine, verification hold, and semantic closure.
examples/semantic_runtime_evaluators/ tests step 4 of that path: runtime meaning evaluators plus negative controls for memoryless continuation, untrusted closure, and unverified closure.
examples/meaning_ir_training_pipeline/ tests step 5: Meaning IR schema, JSONL-ready supervised examples, and evaluator controls for lossy extraction and false authority.
examples/ice_thought_structure/ tests ICE as a recurring thought scaffold: complete objects recur across domains, while removing Intent, Context, or Execution creates a component-specific bottleneck.
examples/meaning_structure_scaffold_comparison/ builds the same fraternization-governance object through ICE, LJPW, Pakheta, seams, semantic primes, meaning crystals, and SOC scaffolding, then tests compression, plain-language translation, implementation, and recovery.
examples/order_meaning_crystal/ tests order as a repo-protecting meaning crystal. It supports order only as care-grounded living structure and finds ordered_care to be the strongest protective expression.
examples/ordered_care_carrier_pairing/ pairs the ordered_care crystal with candidate carriers. The ren-li pairing preserves the geometry better than ren alone, li alone, stewardship, ordo amoris, ubuntu, curation, or legalistic order.
examples/semantic_object_cards/human_resources_policy.md captures the principle of HR policy as dignity, lawful boundary, authority, evidence, privacy, consistency, recourse, and repair.
examples/semantic_random_generator/semantic_rng.py treats a generated value as a Unique Distinction Event and audits whether the distinction is externally carried, deterministic, or semantic-only.
examples/absence_meaning_probe/ audits missing operational meaning slots as route events: expected meaning -> absence -> recovery.
examples/cross_model_semantic_triangulation/ uses local model-family lenses to surface hidden signals such as absence, route/pivot, carrier distinction, and reality feedback.
examples/soc_artifact_benchmark/ compares ordinary artifacts against SOC/foundation-derived artifacts across HR policy, incident workflow, software specification, and research summary domains.
examples/agent_soc_experiment/ compares a baseline work coordination agent against the same agent guided by an SOC across policy drafting, incident triage, code planning, research summarizing, and protected-data handling.
examples/meaning_self_recognition/ tests whether a meaning object can recognize itself across faithful carrier shifts while rejecting recursive slogans and keyword-only mimicry.
examples/enacted_structure/ detects primitive mimicry by checking whether primitives are performed, not merely named.
examples/intent_divergence/ separates word-intent from meaning-intent to detect sarcasm as directional divergence.
examples/sarcasm_geometry/ maps sarcasm into LJPW vectors, glyph routes, opposition angle, and curvature through an inversion hinge, then calibrates contrast pairs where action or surface stance is held constant.
examples/companion_bond_geometry/ maps the 11-year bond between a man and his female house dog as a Pakheta relationship-field carried by nonverbal attunement, routine, care, grief, ritual, and continuing memory.
examples/meaning_field_navigation/ mines navigability as a meaning crystal across road navigation, animal attunement, bird flight, cell chemotaxis, plant tropism, immune recognition, and AI integrity routing, with Pakheta as the relation gate between signal and action.
examples/pakheta_relation_mining/ applies the Pakheta gate to those field cases and mines relation-conduction: carrier/helper separation, constraint truth, clean relation voltage, distortion budget, feedback, and recovery.
examples/creative_crystal_mining/ tests PSCS as an AI-observer mining instrument across poetry, music, software, play, and living growth. It supports bounded-emergence as a candidate, rejects a productive-pressure surface mimic, and preserves the boundary between AI-proposed recognition and PSCS measurement.
examples/creative_crystal_trifecta/ extends the controlled mining probe with fertile-residue and transformative-return. All three candidates survive distinct carrier, holdout, false-neighbour, and mutation tests while three recurrence-compatible surface mimics are rejected.
examples/creative_meaning_forge_soc/ operationalizes the trifecta as a creative Semantic Object Card. It routes form, mismatch, and reintegration needs to the appropriate crystal, asks for missing load-bearing meaning, and permits only recovery-bounded creative moves.
examples/iconic_poetry_mining/ mines ordered transformation structures from Shelley, Dickinson, and Shakespeare, preserves competing readings, tests transfer boundaries and ablations, and exposes retrospective-reweighting as a cross-poem candidate.
examples/iconic_haiku_mining/ performs Japanese-first mining on Bashō, Buson, and Issa. It verifies declared 5-7-5 readings, binds kigo and explicit or grammatical pivots, removes translation as authority, and exposes receiver-completed-relational-interval while preserving retrospective-reweighting as a subprocess.
examples/creative_haiku_forge/ combines the Trifecta Creativity SOC, Japanese haiku meaning structures, and PSCS to create and govern original Japanese haiku. The Fuji experiment conducts scale-disclosed-grandeur; the cherry-blossom experiment turns an overexposed theme into uncaptured-presence; and the self-referential AI experiment tests ambiguous-world-witness without allowing the artifact to certify its own quality.
examples/meaning_mechanics_pakheta/ compares meaning mechanics with and without Pakheta across observation, capture, compression, translation, resolved/unresolved state, weight, voltage, transformation, fields, resilience, and entropy.
examples/meaning_geometry_advantage/ compares word-level reads against LJPW geometry across same-word, same-action, negation, and context-boundary cases.
examples/geometric_prime_mining/ mines candidate semantic primes from LJPW vector shape, separation, carrier stability, and route-pivot behavior.
examples/semantic_prime_expansion_mining/ tests Recognition, Purpose, Correspondence, Quantity, and Uncertainty against the earlier 25-prime baseline using 17 admission gates per candidate, including decomposition, carrier transfer, ablation, substitution, LJPW geometry, and Pakheta.
examples/semantic_actuation_candidate_test/ tests Conduction, Bound, and Release against the complete 30-prime catalog. All three recur and do load-bearing work, but prime-only decompositions reconstruct them: a compound process, a derived relational state, and a compound transition respectively.
examples/structural_primitive_factorization/ audits all 18 engineering-level Structural Primitives against the canonical prime inventory and separates primes, compounds, references, operators, derived reads, processes, and the unresolved Orthogonality candidate.
examples/semantic_prime_structure/ reverse engineers the 30 semantic primes as finite Anchor differentiation profiles, two-plane signatures, neighborhoods, and polarity tensions.
examples/command_prime_candidate/ tests whether command is a semantic prime. The current result classifies it as a command architecture: authority, direction, constraint, addressed agency, executable action, scope, and feedback.
examples/command_pairing/ pairs command with authority, override, belay, countermand, request, permission, and coercion. It shows command as relationally load-bearing: authority validates, belay cancels, override supersedes, and bare override claims fail without grounded authority.
examples/query_prime_candidate/ tests whether query is a semantic prime. The current result classifies it as a query architecture: recognized absence, seeking direction, target source, scope, addressed relation, response distinction, and evidence feedback.
examples/query_pairing/ pairs query with source, scope, evidence, hypothesis, search, probe, prompt, command, hidden premise, and no source. It shows query as a meaning aperture: source makes it answerable, scope bounds it, evidence checks it, and hidden premise or no-source forms fail.
examples/invoke_prime_candidate/ tests whether invoke is a semantic prime. The current result classifies it as an invocation architecture: calling agency, named target, standing access, activation direction, contextual frame, operative manifestation, and feedback confirmation.
examples/invoke_pairing/ pairs invoke with authority, name, context, activation, function, precedent, principle, ritual, command, no standing, and undefined target. It shows invocation as an activation seam where named, available meaning becomes operative inside a bounded frame.
examples/activation_seam_dynamics/ tests the activation seam directly across SOC governance, integrity harness defense, function calls, legal rights, cited principles, undefined targets, hidden override prompts, runaway command activation, and query-to-source activation.
examples/biological_cell_meaning_workflow/ applies the meaning workflow to biological cells across chemotaxis, growth-factor response, insulin uptake, DNA damage response, immune recognition, quorum sensing, receptor-blocked signals, oncogenic activation, autoimmune misrecognition, and cytokine overactivation.
examples/mathematical_meaning_workflow/ tests whether mathematics uses formal meaning by comparing clean arithmetic, algebra, geometry, calculus, and proof routes against inert symbols, undefined operations, domain-shift errors, ambiguous notation, and unvalidated pattern pressure.
examples/meaning_math_dependency_probe/ tests the inverse question: whether meaning runs on mathematics. It separates math as carrier, model, instrument, native formal domain, and attempted replacement, then checks math-heavy failures such as numerology, metric replacement, and arbitrary encoding.
examples/meaning_math_asymmetry_probe/ tests why the relation is asymmetric: meaning gives mathematics standing through object, boundary, domain, purpose, route, and feedback; mathematical form alone cannot choose its own object, context, purpose, or interpretation.
examples/math_favored_instrument_probe/ tests the meta meaning crystal that math is a favored precision instrument inside meaning architecture. Clean math passes when it sharpens the meaning object; replacement math is blocked when it tries to become the object.
examples/standing_meaning_crystal/ tests standing as a load-bearing meaning crystal: valid bounded position to operate in a domain. It separates standing from identity, authority, capability, confidence, relevance, and metric replacement.
examples/meaning_enriched_math/ tests whether adding object identity, domain boundary, standing, purpose, operation, and feedback improves mathematical work across roots, units, statistics, Bayes, and optimization, with a Pakheta audit checking whether the mathematical relation actually conducts through the object.
examples/meaning_guided_math_development/ tests whether meaning can develop mathematics by selecting the appropriate mathematical lever: dimensional analysis, invariant, transformation engine, recovery operation, guarded optimization, or conjecture ladder. Each route now carries a Pakheta gate for lever relation-conduction.
examples/solved_conjecture_meaning_engineering/ runs the solved Poincare Conjecture through Meaning Engineering to see whether the method exposes proof-architecture insights such as standing, invariant, curvature engine, singularity recovery, and canonical identity, with Pakheta separating bounded insight from over-read analogy.
examples/poincare_pattern_transfer/ tests whether the Poincare proof-architecture pattern transfers to software, policy, networks, data modeling, proof planning, and organizational design, with Pakheta checking identity, invariant, recovery, canonical form, and feedback.
examples/discovery_structure_catalog/ mines solved mathematics and physics for reusable discovery structures: bridge-domain translation, counterexample compression, formal certificates, signature convergence, identity shift, and signal-geometry instrument matching. Each structure now carries an explicit Pakheta audit for relation-conduction, false-relation risk, feedback, and recovery.
examples/practical_discovery_structure_applications/ applies those discovery structures to practical work: policy authority conflict, legacy refactoring, customer churn, safety near-misses, supply-chain drift, and research sprawl. It outputs artifacts and verification checks, not only labels, and keeps the Pakheta gate attached to every application.
examples/solved_math_meaning_structure_library/ expands the math-mining layer into a large library of solved-math meaning structures with route slots, transfer rules, recovery routes, and Pakheta gates. It now includes Erdos-linked solved problems, topology, geometry, pi/classical constants, and common foundational mathematics.
examples/math_structure_fit_experiment/ tests seven library route families and three adjacent solution-derived operators on executable valid, invalid, and incomplete micro-worlds. It preserves non-fit, abstention, untested families, zero authority/capability, and the negative result that current library findings do not validate the seeded LJPW vectors.
examples/quantum_pakheta_relation_structures/ tests whether quantum-mechanics mathematics yields reusable relation structures when passed through Pakheta. It keeps state/carrier, amplitude/probability, observable/operator, entanglement/correlation, gauge/physical relation, and recovery boundaries explicit.
examples/abstract_math_meaning_structures/ extracts meaning structures from highly abstract solved mathematics, including cohomological trace carriers, geometric stabilization, invariant bridges, complexity finiteness, pseudorandom transference, and irreducible taxonomy, then applies them to practical problems through explicit Pakheta relation audits.
examples/math_solution_commonality_probe/ aggregates solved math and math-derived structures to test recurring facets: standing, identity or invariant, carrier transformation, compression or canonical form, verification, recovery, and Pakheta relation-conduction.
examples/reusable_discovery_structure_tools/ converts the 23 solution-derived structures into reusable meaning tools with see, transform, verify, repair, and Pakheta gate routes. It tests policy, data, proof, weak signal, and organizational targets to show the tools produce artifacts rather than copied formulas.
examples/semantic_engineering_field_report/ verifies the public field report tenets against local SOCs, docs, instruments, examples, and tests. It keeps the monograph evidence-bound instead of merely persuasive.
examples/semantic_theorem_card/ tests a meaning-engineered math tool for theorem retrieval and proof-route planning. It turns theorem statements into domain, objects, definitions, assumptions, dependency routes, proof strategy, invariants, failure modes, auxiliary lemma candidates, formalization readiness, and human meaning reads.
examples/semantic_efficiency_probe/ compares ordinary task frames against Semantic Engineering frames to test whether SOC/ICE/Pakheta/query/invoke scaffolding plausibly reduces drift, repair loops, and total work inside a fixed AI-work budget.
examples/semantic_integrity_meaning_machine/ upgrades the Semantic Integrity Harness with a meaning-machine route through identity, standing, authority, boundary, query, evidence, relation-conduction, ordered care, and recovery. Its grounded pipeline now consumes provider, proposal, recursion, verification, and receiver evidence while preserving evidence and quarantining unauthorized consequence.
tests/test_semantic_integrity_grounded_deep_trials.py runs five end-to-end pressure trials across legitimate semantic assurance, fully understood injection, stable ambiguity, verifier laundering/contradiction, and blinded receiver agreement/disagreement/substitution. Results and limitations are recorded in docs/semantic_integrity_grounded_deep_trials.md.
examples/semantic_code_construction_machine/ tests whether meaning structures can construct nontrivial code by building a rollback-capable dependency workflow engine with invariants, dependency ordering, audit trace, and recovery.
examples/pscs_programming/ analyzes common Python codebase archetypes under PSCS, blocks hidden destructive meaning, preserves ambiguous stateful effects for review, and constructs four small programs from explicit identity, boundary, invariant, authority, correspondence, continuity, recovery, and verification structures.
examples/programming_structure_mining/ factors eleven familiar Python forms through a layered candidate basis, ablates every factor, and keeps the four external conditions for meaning-governed construction separate from what syntax can establish.
examples/pscs_meaning_bytecode/ compresses the PSCS reasoning kernel and Creativity Trifecta into canonical Prime IDs, ordered routes, pivots, LJPW metadata, and a measured 1,472-character standalone Custom Instructions carrier; it also emits a 936-character semantics-first Traditional Chinese carrier that retains the English framework and LJPW identities without presenting prompt behavior as runtime enforcement.
examples/pscs_cross_language_drift/ compares the full English semantic reference with the Traditional Chinese carrier across 18 ordered meaning dimensions and nine destructive mutations, while keeping live paired-model behavior explicitly unmeasured until actual provider captures exist.
examples/principled_ai_bedrock/ tests whether Anchor fidelity and Anchor-Good service regenerate all 21 B1/Trifecta primes, survive paired ablation, and cover nine stress cases without promoting the structural result into a universal moral proof or an unrun live-model claim.
examples/principled_ai_bedrock_mining/ tests whether the two principles generate a carrier-independent compound identity. It supports answerable-stewardship across five discovery domains, three holdouts, four false neighbours, and seven recurring cross-principle seams.
examples/semantic_specification_compiler/ compiles informal software intent into a meaning-bearing specification with identity, boundaries, authorities, invariants, state model, failure/recovery paths, verification oracles, and implementation contracts.
examples/agent_soc_experiment/ tests whether an SOC-guided agent preserves objective, authority, boundary, evidence, decomposition, relation integrity, permission, verification, recovery, and feedback better than a baseline surface-completion agent.
examples/meaning_physics_map/ maps Anchor distance, voltage, weight, curvature, carrier transfer, Pakheta conduction, entropy, recovery, and next meaning-physics instruments into one operational stack.
examples/simple_physics_meaning_structures/ starts with ordinary physics and tests whether conservation, force, fields, gradients, waves, resonance, equilibrium, entropy, boundary conditions, least action, and symmetry behave as Pakheta-gated meaning structures.
examples/meaning_physics_instruments/ runs first-pass instruments for Semantic Conductivity, meaning potential energy, Power-Wisdom phase control, and the autopoiesis inequality.
examples/meaning_physics_calibration/ calibrates those first-pass physics instruments against carrier retention, Pakheta gating, recovery correction, and autopoiesis examples.
examples/meaning_machine/ combines identity, standing, authority, boundary, query, evidence, relation-conduction, ordered care, and recovery into a first bounded-inquiry meaning machine, then compares it against a surface word-pile control.
examples/meaning_use_map/ maps what meaning can be used for beyond ordinary AI, policy, and document carriers: orienting, binding, distinguishing, actualizing, discerning, remembering, transmitting, healing, transforming, and consecrating.
examples/semantic_prime_voltage/ adds Semantic Voltage to geometric prime mining so pure form, expression pressure, and carrier invariance can be tested.
examples/cross_carrier_prime_transfer/ tests whether prime geometry and Semantic Voltage survive faithful language and nonverbal carrier shifts.
examples/semantic_prime_resilience/ measures how far prime geometry and voltage can drift before meaning-form collapse, then tests recovery.
examples/semantic_prime_recovery/ calibrates the minimum correction needed to recover first-failure and full-collapse prime-form distortions.
examples/pakheta_meaning_engineering_fit/ maps geometric meaning forms, voltage, transfer, distortion, and recovery onto the Pakheta relation gate.
examples/randomness_semantic_reduction/randomness_reduction.py reduces random into candidate primitives:

random = bounded possibility + actualized distinction + fair non-derivability

examples/aesthetic_calculator/index.html is a small practical object where aesthetic resonance, arithmetic truth, action, and recovery remain distinct.
examples/flex_time_tracker/index.html applies quiet semantic structure to source facts, policy, balance signals, integrity warnings, undo, and export.
examples/ljpw_geometry_compass/index.html sketches LJPW meaning-states as geometry.
examples/repo_soc_development_map/ uses the root SOC to test development proposals and derive the next research tracks for artifact comparison, reviewer studies, cross-language transfer, long-run AI drift, curvature calibration, and primitive promotion.
examples/soc_harness_adversarial/ stress-tests the root SOC and Research Governance Harness against premature promotion, verification bypass, carrier/relation collapse, metric replacement, and private-source exposure.
semantic_integrity_harness/ builds a meaning-role defense layer for AI injection surfaces: it distinguishes carrier, relation, authority, scope, evidence, instruction, tool action, memory, and recovery. Its adversarial stress suite now holds the current attack matrix through defense semantic primes while routing provenance and identity uncertainty to verification. Its Anchor truth geometry reads attacks as distance from (1,1,1,1) plus malformed Power, showing how the harness reduces falsehood pressure before execution. Its Semantic Voltage probe separates false pressure from clean voltage conduction across the harness, SOC, and carrier routes. Its observatory reads those decisions as inspectable meaning routes with decision traces, enforcement envelopes, SOC self-recognition, and primitive ablation. Its wild-like sandbox compares naive carrier-following against the principle-gated path across fake workplace carriers, fake canaries, and fake tools. Its brutal sandbox preserves harsher fake-only edge attacks as regressions for disclosure verbs, sensitive paths, obfuscation, SOC mutation, trusted-channel protected movement, and carrier shifts.
examples/music_meaning/ maps wordless music into LJPW glyph routes, the first non-verbal carrier: consonance->Love, meter->Justice, dynamics->Power, complexity->Wisdom. Tests whether the grammar is meaning-native rather than language-native.

Document Map

Foundation:

docs/semantic_component_inventory.md — generated, module-complete inventory of semantic machinery, primitives, crystals, structures, functions, and internal dependencies
docs/semantic_engineering_discipline_definition.md
docs/semantic_engineering_foundational_spec.md
docs/semantic_engineering_ontology.md
docs/anchor_origin_semantic_engineering_foundation.md
docs/meaning_foundation_object.md
docs/meaning_crystals.md
docs/order_as_protective_meaning_crystal.md
docs/ordered_care_carrier_pairing.md
docs/meaning_field_navigation.md
docs/pakheta_relation_mining.md
docs/creative_meaning_crystal_mining.md
docs/creative_meaning_crystal_trifecta.md
docs/iconic_poetry_meaning_structure_mining.md
docs/iconic_japanese_haiku_mining.md
docs/governed_creative_haiku_forge.md
docs/governed_cherry_blossom_haiku_forge.md
docs/governed_ai_collaboration_haiku.md
docs/meaning_mechanics_pakheta.md
docs/fraternization_policy_distillation.md
docs/fraternization_meaning_transfer.md
docs/work_from_home_meaning_architecture.md
docs/meaning_seams_pakheta.md
docs/meaning_seam_conduction.md
docs/meaning_seam_engineering_benchmark.md
docs/meaning_object_inspector.md
docs/tri_ice_architecture.md
docs/tri_ice_multipurpose_experiment.md
docs/ice_as_thought_structure.md
docs/meaning_structure_scaffold_comparison.md
docs/identity_in_meaning.md
docs/authority_in_meaning.md
docs/semantic_identity_continuity.md
docs/identity_posture_ljpw.md
docs/meaning_precedes_math_anchor_geometry.md
docs/soc_scaffolded_research_development_map.md
docs/semantic_observer.md
docs/semantic_recognition_lived_meaning.md
docs/semantic_query_meaning.md
docs/recursive_semantic_recognition.md
docs/semantic_observer_study_protocol.md
docs/semantic_engineering_research_harness.md
docs/soc_harness_adversarial_limits.md
docs/agent_soc_experiment.md
semantic_integrity_harness/README.md
semantic_integrity_harness/SEMANTIC_INTEGRITY_HARNESS_SOC.md
semantic_integrity_harness/DEFENSE_SEMANTIC_PRIMES.md
semantic_integrity_harness/ANCHOR_TRUTH_GEOMETRY.md
semantic_integrity_harness/SEMANTIC_VOLTAGE_PROBE.md
semantic_integrity_harness/OBSERVABILITY_REPORT.md
semantic_integrity_harness/IDENTITY_BOUNDARY_EXPERIMENT.md
semantic_integrity_harness/ROLE_CONFUSION_SIMULATION.md
semantic_integrity_harness/wild_sandbox/README.md
semantic_integrity_harness/brutal_sandbox/README.md
docs/meaning_as_prior_structure.md
docs/meaning_ontology_no_void.md
docs/meaning_physics_map.md
docs/meaning_physics_calibration.md
docs/meaning_use_map.md
docs/THE_ORIGIN_REFRAME.md

Metrics and probes:

docs/semantic_weight_metric_ljpw_technical_spec.md
docs/meaning_probe_core_makeup.md
docs/semantic_engineering_validation_plan.md
docs/semantic_engineering_test_bench_report.md
docs/ice_framework_semantic_engineering_experiment.md

Routes, memory, and geometry:

docs/semantic_glyph_vocabulary.md
docs/semantic_glyph_memory_architecture.md
docs/semantic_glyph_domain_palettes.md
docs/semantic_orthogonality.md
docs/sarcasm_geometry_calibration.md
docs/companion_bond_geometry.md
docs/companion_bond_research_insights.md
docs/semantic_primes_and_factorization.md
docs/semantic_prime_expansion_mining.md
docs/semantic_actuation_candidate_test.md
docs/structural_primitive_factorization.md
docs/command_prime_candidate.md
docs/command_pairing.md
docs/query_prime_candidate.md
docs/query_pairing.md
docs/invoke_prime_candidate.md
docs/invoke_pairing.md
docs/activation_seam_dynamics.md
docs/biological_cell_meaning_workflow.md
docs/mathematical_meaning_workflow.md
docs/meaning_math_dependency_probe.md
docs/meaning_math_asymmetry_probe.md
docs/math_as_favored_precision_instrument.md
docs/math_favored_instrument_probe.md
docs/standing_meaning_crystal.md
docs/meaning_enriched_math.md
docs/meaning_guided_math_development.md
docs/solved_conjecture_meaning_engineering.md
docs/poincare_pattern_transfer.md
docs/discovery_structure_catalog.md
docs/practical_discovery_structure_applications.md
docs/abstract_math_meaning_structures.md
docs/math_solution_meaning_structure_commonalities.md
docs/math_derived_structures_for_meaning_machinery.md
docs/semantic_operator_mesh.md
docs/semantic_theorem_card.md
docs/semantic_efficiency_probe.md
docs/conversation_curvature_capsule_2026-05-18.md

Applied engineering:

docs/semantic_security_primitives.md
docs/ai_agent_destructive_action_guard.md
docs/growth_to_stability_meaning_structure.md
docs/semantic_architecture_general_engineering_discipline.md
docs/semantic_object_card_scaffold.md
docs/resonant_semantic_engineering.md
docs/RESONANCE_PROGRAMMING_GUIDE.md

LJPW framework references:

docs/LJPW_FRAMEWORK_V8.6.2_COMPLETE_UNIFIED_PLUS.md
docs/power_wisdom_phase_dynamics.md

Project Layout

src/semantic_engineering/ contains the Python package.
tools/ contains compatibility wrappers for local command-line use.
docs/ contains theory, specifications, and validation reports.
examples/ contains embodied artifacts and controlled experiments.
semantic_integrity_harness/ contains the dedicated AI semantic-integrity defense folder, SOC, runners, geometry report, and calibration notes.
examples/semantic_object_cards/ contains object cards for built examples.
templates/ contains the SOC template.
tests/ contains regression tests for scanners, probes, cards, glyph memory, git routes, randomness experiments, meaning self-recognition, and the HR policy SOC experiment.
semantic_scan/ contains a generated scan bundle from the repository corpus.

Development Constraints

Keep the Anchor Point (1,1,1,1) as the standard.
Keep Love, Justice, Power, and Wisdom distinct.
Use ordered care as the repo's growth posture: protect meaning growth through care, boundary, sequence, proportion, and recovery without turning protection into bare order, rule, duty, or control.
Use metrics as instruments under Anchor review.
Treat resonance as field guidance and logic as local proof.
Name load-bearing meaning components for new Semantic Object Cards.
Name meaning seams where meaning crosses carrier, facet, authority, action, compression, transfer, pressure, or recovery boundaries.
Keep carrier evidence distinct from helper evidence.
Preserve recovery paths when drift, pressure, unsafe action, or failed verification is recorded.
Add tests when behavior becomes executable.
Prefer local, inspectable examples before adding external services.

The governing constraint:

No local instrument may replace the Anchor it points toward.

Name		Name	Last commit message	Last commit date
Latest commit History 175 Commits
docs		docs
examples		examples
portable		portable
semantic_integrity_harness		semantic_integrity_harness
src/semantic_engineering		src/semantic_engineering
templates		templates
tests		tests
tools		tools
.gitignore		.gitignore
LICENSE		LICENSE
MEANING_SEAMS.md		MEANING_SEAMS.md
PRINCIPLED_AI_BEDROCK.md		PRINCIPLED_AI_BEDROCK.md
PSCS_CUSTOM_INSTRUCTIONS_ENGLISH.md		PSCS_CUSTOM_INSTRUCTIONS_ENGLISH.md
README.md		README.md
SEMANTIC_ENGINEERING_SOC.md		SEMANTIC_ENGINEERING_SOC.md
pyproject.toml		pyproject.toml

Folders and files

Latest commit

History

Repository files navigation