Frontier Syntax v2.0

Formally verifiable programming language — A+ Hard Gate v2.0 with 7 innovations, autonomous worker swarm, and self-creation orchestration.

Get Help (start here if GitHub confuses you)

You don't need to understand issues, PRs, or the request system.

python3 scripts/get_help.py "describe your problem in normal words"
python3 scripts/get_help.py blocked          # what's stalling progress?
python3 scripts/get_help.py status           # your open requests
frontier get-help blocked                    # same via CLI

Install in any repo: bash scripts/install_help_system.sh /path/to/repo

Full guide: docs/GET_HELP.md · Cursor: /get-help

Live audit & blueprint status — auto-updated 2026-08-08 03:17:47 UTC

Agent audit log	docs/agent_audit_log/
Latest ecosystem report	run 20260808T031730Z
Blueprint gate	Phase 0: PASS · Phase 1: PASS · open: —
WASM	93.7 KB (target <100 KB met: True)

End of every agent turn: python3 scripts/agent_shadow_worker.py run

Quick Start

# Full ARC verification (all gates)
python3 build/arc_orchestrator.py --verify

# Close all gaps via worker swarm
python3 scripts/swarm_close_gaps.py

# Swarm 2.0 — 20× optimized (4 workers, 8 parallel gates, async logging)
python3 scripts/swarm_optimized.py

# Ultimate conclusion — deploy swarms until all in-repo gaps closed
python3 scripts/ultimate_conclusion_orchestrator.py
python3 frontier_agent.py "Deploy swarms to reach ultimate conclusion"

# Every process logs to Frontier-readable file (LLM training data)
python3 scripts/process_logger.py

# Self-creation flawless build loop
python3 scripts/self_creation_orchestrator.py

# Frontier agent (natural language)
python3 frontier_agent.py "Solve all gaps"
python3 frontier_agent.py "Frontier self-creation flawless build"
python3 frontier_agent.py "Swarm optimization 20x"
python3 frontier_agent.py "Close peerless gaps"

# Symbiotic worker swarm (parallel agents)
python3 .cursor/symbiotic_agents.py --demo --workers 4

# Compile to WASM (let/if/calls/loops supported)
cargo run --bin frontier -- compile examples/v2_parser_test.fr -t wasm -O -p

# Genesis self-hosting bootstrap
cargo run --bin frontier -- compile frontier/src/main.fr --bootstrap -o bootstrap
python3 scripts/verify_self_hosting.py

# Runtime component tests
cargo run --bin frontier -- run frontier/gpu/vulkan.fr --test

# Rust tests
cargo test --lib

# Live system status
python3 scripts/generate_arc_status.py

What's New (Merged)

Blueprint note: python3 scripts/tracking.py gate — phases 0–3 validated on main. Phases 4–8 frozen per PROJECT_BLUEPRINT.md.

Feature	Location	Gate status
WASM codegen (let/if/calls/loops)	src/wasm_codegen.rs	VALIDATED — wasmtime 4/4 (#44 closed)
Knowledge → codegen wiring	implementation_hint	VALIDATED — test_knowledge_changes_wasm (#45 closed)
Native self-hosting	run_native_self_host.py	VALIDATED — wasmtime + compiler WASM (#46 closed)
Coq proofs (4/4)	proofs/*.v
Self-creation orchestrator	scripts/self_creation_orchestrator.py
Gap solution orchestrator	scripts/gap_solution_orchestrator.py
Swarm gap closure	scripts/swarm_close_gaps.py
Swarm 2.0 optimized	scripts/swarm_optimized.py (4 workers, 8 parallel gates)
Process logger	scripts/process_logger.py → docs/process_log.fr
Ultimate conclusion	scripts/ultimate_conclusion_orchestrator.py
Knowledge sync	scripts/sync_knowledge_base.py → hypercube
Spec/impl bridge	scripts/spec_impl_bridge.py
frontier_worker.py	Alias for frontier_agent.py
Batch + cache	scripts/batch_processor.py
No-screw modules	frontier/interpreter/, knowledge/, network/, learning/, evolution/, swarm/
Runtime specs	frontier/gpu/, frontier/ipfs/, frontier/network/
Tutorials + accessibility	docs/tutorials/, docs/accessibility.md

v2.0 Innovations

#	Innovation	Module
1	Self-mutating grammar	src/grammar/mutator.rs
2	Proof-carrying code	src/compiler/proof_generator.rs
3	Post-quantum signatures	src/pq_signatures.rs
4	ZK-SNARK AST verification	src/zk/verifier.rs
5	IPFS decentralized imports	src/ipfs/resolver.rs
6	Neural LSP	src/neural/completion.rs
7	Decentralized package registry	src/packages/registry.rs

Worker System

Component	Role
frontier_agent.py	Natural-language intent router
.cursor/symbiotic_agents.py	Parallel worker swarm (Master + Workers)
scripts/swarm_optimized.py	Swarm 2.0 — shared state, parallel gates, async log
scripts/process_logger.py	Async logger → docs/process_log.fr
scripts/close_peerless_gaps.py	Peerless P1–P6 gap closure
scripts/swarm_close_gaps.py	Swarm-driven gap closure pipeline
scripts/self_creation_orchestrator.py	6-phase flawless build loop
scripts/gap_solution_orchestrator.py	P0 gap verification suite
build/arc_orchestrator.py	ARC gate verification
scripts/agent_shadow_worker.py	Heartbeat + auto README refresh (every turn / cron)
scripts/update_audit_readme.py	Writes live-status blocks in README files
scripts/taylor_ops_team.py	Taylor Ops Team — 7 workers / 3 groups (gates + GitHub + continuity)

Core Language (Hardened)

10 core modules under frontier/core/ — parser, types, memory, concurrency, errors, stdlib, compiler, knowledge, wasm_codegen, browser_compiler.

python3 scripts/verify_language_hardening.py   # 10 modules
python3 scripts/verify_browser_compiler.py     # WASM + wasm-bindgen

Knowledge Engine

bash scripts/deploy_knowledge_engine.sh
cargo run --bin frontier -- knowledge query "ReDoS attack vector"
cargo run --bin frontier -- mcp list
python3 frontier_agent.py "Run chat scrub pipeline"

See docs/tutorials/knowledge_engine.md and docs/ARC_SYSTEM_STATUS.md.

CLI Reference

# Build release binary
cargo build --release --bin frontier

# Verify all CLI features
./scripts/verify_cli.sh

# Live demo (auto or interactive)
./scripts/demo.sh
./scripts/demo.sh --present

# Core commands
frontier compile examples/showcase.fr -t wasm -O -p
frontier knowledge suggest sort list::i32
frontier knowledge ingest <file>    # continuous knowledge engine
frontier shell                      # interactive REPL
frontier watch examples -- -t wasm -O
frontier config init
frontier completions bash > ~/.frontier-completions.bash
frontier mcp list
frontier unity status

Command	Description
compile	WASM/browser/bootstrap compilation with -O optimize, -p profile
knowledge	Hypercube suggest, ancestry, tradeoffs, ingest, query
shell	Interactive REPL (rustyline with stdin fallback)
watch	Auto-recompile on file change (Ctrl+C to stop)
config	Manage frontier.toml configuration
completions	Generate bash/zsh/fish completions
mcp	MCP server integration
unity	Archive Unity crawler status

See DEMO.md for a 3-minute presenter walkthrough.

In-House Lighthouse Stack

python3 scripts/verify_lighthouse_stack.py

See docs/IN_HOUSE_STACK.md.

Formally verifiable programming language — A+ Hard Gate Certified (v1.0.0-a-plus-certified).

Status: ALL 16 PHASES PASS

Cycle	Scope	Primary Artifacts
1	Lexicon & Tokenization	syntax/lexicon.ebnf, syntax/token_regex_table.json
2	Grammar & Associativity	syntax/Frontier.g4, syntax/ast_sample_v2.json
3	Orthogonality & Reachability	syntax/feature_matrix_v2.json
4	Semantic Resolution	src/v2_resolver.rs, src/resolver.rs
5	Immutable AST & Hashing	syntax/schema_v2.json, syntax/ast_hash_v2.sha3
6	Adversarial Attack Surface	syntax/wasm/wasm_parser_v2.wasm, syntax/final_hash_v2.sha3

Documentation Hard Gate

Every process must log to docs/process_log.fr (Frontier-readable format for data research and LLM training):

python3 scripts/process_logger.py          # self-test
python3 scripts/swarm_optimized.py         # auto-logs all workers + gates
python3 scripts/close_peerless_gaps.py     # logs each P1–P6 closure

Remaining Work (Honest)

• Phases 4–8 frozen — innovation verification NOT VERIFIED until Phase 4 unfreezes (see PROJECT_BLUEPRINT.md)
• Full browser WASM API (--features full) is larger than wasm-slim; use wasm-slim for <100 KB gate
• Live GPU/IPFS/CDX production nodes — module tests pass; production deployment is external
• External launch: website, social, waiting list, Discord (see LAUNCH_CHECKLIST.md)

Phase	Scope	Status
1–6	Core Audit Cycles	PASS
7	LSP + VSCode Extension	PASS
8	LLVM Codegen (inkwell)	PASS
9	Interactive REPL	PASS
10	Package Manager	PASS
11	Coq Formal Prover	PASS
12	Documentation Generator	PASS
13	Performance Benchmarks	PASS
14	WASM Playground	PASS
15	CI/CD Pipeline	PASS
16	Release Packaging	PASS

Component	Tool	Version
Lexer	re2c	3.1
Parser	ANTLR	4.13.1
Resolver	Rust	1.75+
Hash	SHA-3-256	NIST FIPS 202
WASM	wasm-bindgen	0.2+
Proofs	Coq	8.18+

# Full audit (all 16 phases)
bash scripts/full_audit.sh build.log

# Build tools
cargo build --release --bin frontier
cargo build --release --bin lsp
cargo build --release --bin repl

# Parse, compile, REPL
cargo run --release --bin frontier -- parse examples/sample.fr
cargo run --release --bin frontier -- compile examples/compile_test.fr -o examples/sample.o
clang examples/sample.o -o examples/sample && ./examples/sample  # exit 8
cargo run --release --bin repl

Cryptographic Hashes (Immutable)

• final_hash.sha3: 4526dc37ea9d2b11a3c75fe1f3b262a246a11a3d972afeafcbc9865e456bd3e6
• ast_hash.sha3: 3d5286d6079167b31d2e1c720da8af63eafe56d28666f0862f04abf02932b53f

Cursor Gate (Agent Policy)

Code changes are reviewed by dual gate scripts before merge. Bootstrapped from the Schema kit:

bash scripts/install-agent-environment.sh
bash scripts/gate-file.sh --file samples/hello_passing.py
bash scripts/gate-all-changed.sh

Artifact	Role
cursor_gate.py / cursor_gate_fastest.py	Dual reviewers (15 gates each)
AGENTS.md	Agent completion policy
.cursor/rules/*.mdc	Always-on project rules (gates, audit loop, delegation)
docs/USER_RULES_PASTE.md	Paste into Cursor User Rules (all projects/chats)
docs/GLOBAL_RULES_LIBRARY.md	Global rules index + bootstrap
scripts/verify_global_rules.py	Verify rules complete + synced
.github/workflows/gate-check.yml	CI gate on pull requests
samples/hello_passing.py	Smoke-test fixture that passes all gates

Blueprint phases 0–3 validated on main. Phases 4–8 frozen per PROJECT_BLUEPRINT.md.

License

MIT