Establish MNCS language semantic foundation and recursive refinement model

[epi13]

Summary

Establishes the MNCS Language Project as a semantics-first, verification-native general-purpose language research repository rather than prematurely selecting a surface grammar.

This PR defines the initial project boundaries, documents recursive self-debugging and refinement as a foundational requirement, and adds an executable Rust semantic model capable of validating experimental MNCS manifests.

What changed

Project foundation

• replaces the minimal README with the project vision, design principles, intended compilation model, project-family boundaries, prototype usage, and status warning;
• adds a staged roadmap from the executable semantic model through semantic identity, high-level IR, verified SSA, backend experiments, recursive refinement, self-description, and eventual syntax research;
• adds contribution and security guidance appropriate for an early verification-language project.

Architecture and specification

• documents the machine-native-but-not-machine-exclusive vision;
• records explicit non-goals, including that this is not an LLM-only language, a DSL, or an immediate replacement for Rust/LLVM;
• defines the initial architecture, terminology, and trust model;
• introduces early semantic specifications for the core model, contracts/evidence, effects/capabilities, verified IR, and recursive introspection/refinement.

Recursive debugging and self-improvement

Recursive refinement is treated as part of the language architecture rather than only a Forge or RAVEL orchestration feature.

The proposed bounded cycle is:

1. observe the semantic and evidence graphs;
2. derive a diagnostic obligation and minimal causal slice;
3. propose a repair in an isolated candidate state;
4. declare intended improvements, protected properties, authority, and expected invalidation;
5. run targeted independent verifiers;
6. compare semantic, effect, capability, assumption, complexity, and evidence deltas;
7. promote or reject under explicit policy;
8. record the result as input to later refinement cycles.

The model explicitly rejects unrestricted self-modification, evidence laundering, unbounded recursion, silent capability expansion, and a generator automatically certifying its own repair.

RFC foundation

• RFC 0001: semantic foundation;
• RFC 0002: contract and evidence model;
• RFC 0003: verified intermediate representation;
• RFC 0004: recursive introspection and refinement.

The first two are represented experimentally in the prototype. The verified-IR and recursive-refinement RFCs define the next architectural direction.

Executable semantic model

Adds a Rust workspace containing:

• mncs-model — semantic entities and deterministic structural validation;
• mncs-cli — a JSON manifest validator;
• accepted and intentionally rejected examples;
• tests for capability authorization, evidence binding, and missing-evidence diagnostics.

Initial validation rules include:

• supported schema version;
• non-empty and unique identities;
• unique function-local values and contract properties;
• every effect names an authorizing capability;
• every required effect capability is declared by the function;
• assumption references resolve;
• evidence references a declared property and identifies a verifier;
• contracts without evidence remain valid in the base profile but produce warnings.

The JSON form is explicitly a bootstrap transport format, not proposed surface syntax.

CI

Adds GitHub Actions checks for:

• cargo fmt;
• cargo clippy -D warnings;
• workspace tests;
• acceptance of the valid account-transfer example;
• rejection of the undeclared-network-effect example.

Why

MNCS Language should first prove that it has a distinct semantic purpose. Contracts, authority, effects, assumptions, evidence, failure behavior, diagnostics, and repair relationships should be part of program meaning rather than reconstructed from ordinary source after the fact.

The recursive model also allows the language, Forge, and RAVEL to evolve toward micro-debugging: local failed obligations and causal paths can drive bounded repair cycles instead of repeatedly feeding enormous Clang, LLVM, or Joern reports back to an agent.

Project-family boundaries

• MNCS remains applicable to existing languages and does not depend on this project.
• MNCS Language owns the semantic structures for programs, diagnostics, repair proposals, evidence deltas, and promotion decisions.
• MNCS Forge can execute micro-verifiers, localization, and candidate checks.
• RAVEL can coordinate recursive and distributed refinement across agents, machines, verifiers, and trust boundaries.

Validation status

The branch includes CI as the authoritative validation path. Local Rust execution was not available in the environment used to construct this PR, so formatting, linting, compilation, tests, and example checks should be reviewed from the GitHub Actions result before merge.

Deliberately unresolved

• final language name and source syntax;
• expression language and type system;
• ownership, regions, concurrency, and memory model;
• stable semantic identity and canonical hashing;
• executable diagnostic, repair-proposal, and promotion schemas;
• micro-verifier protocol;
• backend selection;
• self-hosting and bootstrap strategy.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, you can upgrade your account or add credits to your account and enable them for code reviews in your settings.