Skip to content
DT-FossPublic

About

Deterministic, content-addressed empirical program synthesis with sealed evaluation, authority algebra, and reversible Ghost/Mind activation.

Topics

Resources

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

1 Commit

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

FORGE

Deterministic, content-addressed empirical program synthesis and autonomous capability research.

Offline safe CI Research disclosure License: limited research use

Important

This repository is a public technical and defensive disclosure, not an open-source release. A narrow copyright permission covers internal, noncommercial research and reproducibility on owned or explicitly authorized systems. No patent license is granted. See LICENSE, NOTICE, and the disclosure record.

Warning

FORGE contains complete dual-use and offensive-security source, knowledge, fragments, and examples. Use it only on systems you own or are explicitly authorized to test, in an isolated environment. The public release does not remove those capabilities, and the default CI deliberately does not execute them.

Canonical disclosure record

Field Value
Project FORGE
Author/publisher David Tom Foss (DT-Foss)
Public disclosure date 2026-08-09
Canonical repository https://github.com/DT-Foss/FORGE
Canonical release/tag prior-art-2026-08-09
Release character Public defensive publication and reproducible research snapshot
Copyright status All rights reserved except the limited research permission in LICENSE
Patent grant None
Byte-level scope The Git commit named by the tag and the tracked-file SHA-256 manifest in docs/DISCLOSURE_MANIFEST.sha256

The official public Git history starts with one clean disclosure snapshot on 2026-08-09. Earlier local development history is neither published nor claimed as an earlier public disclosure. The tagged source, tests, static knowledge, fragment libraries, benchmark programs, and technical documents together define the public scope. Runtime databases, credentials, private notes, operator logs, generated results, and local target artifacts are intentionally not part of the publication.

The long-form enabling disclosure is docs/PRIOR_ART.md. Architectural rationale is recorded in docs/DECISIONS.md, and the exact research objective is in OPEN_ENDED_AUTONOMY.md.

What FORGE is

FORGE is a deterministic experimental runtime that searches programs and mechanisms, executes candidates against explicit external relations, records the resulting evidence, and reuses only capabilities whose exact bytes and authority chain can be verified. It combines:

  • a legacy natural-language-to-causal-graph-to-fragment pipeline;
  • finite, typed program and protocol search;
  • schema-open observations and explicit goal evaluation;
  • content-addressed artifacts, descriptors, transition receipts, and source generations;
  • paired control/treatment replay;
  • persistent candidate, activation, quarantine, and restart state;
  • reversible Ghost/Mind source and cohort activation; and
  • bounded public research acquisition that treats reports as reports, not as executable truth.

FORGE is not a transformer, chatbot, model checkpoint, or prompt wrapper. Its runtime decisions are produced by ordinary source code, finite search, canonical serialization, hashes, explicit evaluators, and persisted evidence. The repository does include optional legacy/bootstrap integrations and a broad dependency list; the narrower claim is that the disclosed autonomy and authority paths do not require an LLM call.

The research objective is capability compounding: begin with an unsupported machine-checkable relation, discover or build a program that satisfies it, causally validate the change, retain it across restart, and make a later related closure cheaper. When the current search language cannot express the solution, the target is to expand that substrate through the same reversible evidence path.

System architecture

flowchart TD
    A["Local challenge or bounded public source"] --> B["Reported record / exact artifact"]
    B --> C["Content-addressed research lead"]
    C --> D["Public SEARCH projection"]
    C --> E["Sealed EVALUATION projection"]
    D --> F["Deterministic candidate frontiers"]
    F --> G["Isolated execution observations"]
    E --> G
    G --> H["Paired control/treatment evidence"]
    H --> I{"Supported and uncontested?"}
    I -->|yes| J["Capability candidate"]
    J --> K["ACTIVE exact-byte authority"]
    I -->|no| L["QUARANTINED / observational memory"]
    K --> M["Reusable program/search production"]
    M --> F
    H --> N["Ghost immutable source generation"]
    N --> O["Mind active/shadow handoff"]
    O --> P["Fresh-process adoption or rollback"]
Loading

The major implementation surfaces are:

Surface Purpose Principal source
Legacy inference and assembly Intent parsing, .causal lookup, typed fragment assembly, execution and learning core/intent_parser.py, core/knowledge_engine.py, core/code_assembler.py
Open-world observation Durable challenges, executions, outcomes, evidence and counterexamples core/autonomy/observer.py, core/autonomy/model.py, core/autonomy/evidence.py
Program search Finite candidate families, expression/protocol search, paging, donor composition and semantic deduplication core/autonomy/program_search.py, core/autonomy/expression_search.py, core/autonomy/protocol_search.py
Authority Finite product algebra, exact descriptors, recursive CAS validation and transition receipts core/autonomy/authority_algebra.py, core/autonomy/authority_runtime.py
Capability lifecycle Paired evidence, candidate envelopes, ACTIVE bindings, counterevidence and quarantine core/autonomy/candidate_lifecycle.py, core/autonomy/capability.py, core/autonomy/capability_authority.py
Research intake Bounded arXiv/IACR/feed acquisition, report-qualified lookup and pinned public-repository derivation core/autonomy/research_sources.py, core/autonomy/research_knowledge.py, core/autonomy/research_repository_runtime.py
Source self-repair Repository materials, tree-edit search, paired replay, immutable generations and activation sagas core/autonomy/repository_repair.py, core/autonomy/tree_edit_search.py, core/autonomy/source_activation.py
Persistent coordination Work queues, process budgets, Active/Shadow cohorts, Forest/Ghost/Mind supervisors core/autonomy/control_plane.py, forge_forest_supervisor.py, forge_generation_supervisor.py, forge_mind.py
Cryptanalysis baseline Manifest-driven resumable experiments with independently recomputed statistics core/cryptanalysis/, forge_crypto.py

Determinism and identity

FORGE uses canonical JSON-like structures and SHA-256-derived identifiers for artifacts, programs, descriptors, evaluator plans, source generations, and receipts. Identity is based on content and declared policy, not a mutable filename or an in-memory object. A persisted authority promotion is valid only if its parent descriptor and transition receipt resolve recursively to the exact named bodies and the concrete subject bytes exist under the expected digest.

Determinism does not imply that every run has identical wall time or host behavior. Subprocess scheduling, operating systems, dependencies, external services, and explicitly live acquisition are environmental inputs. FORGE pins and records such inputs where the relevant adapter supports it; otherwise it reports drift or unknown instead of converting absence of proof into success.

Data-form colors and the authority algebra

Two systems that are easy to confuse are deliberately independent.

1. Data-form colors

The original color system is a fragment-port type system. Its eight values describe payload shape only:

TEXT, STRUCT, TABULAR, BYTES, SERIAL, PATH, RESPONSE, VOID.

An output color may satisfy a later input color directly or through an explicit converter. The colors do not mean trusted/untrusted, source/sink, reported/observed, safe/unsafe, or active/quarantined. The often-repeated five-role description RED/BLUE/GREEN/PURPLE/ORANGE is not the implemented FORGE color system.

2. Authority product

Authority is represented separately as a finite product:

DataForm × EpistemicAtom × LifecycleStage × AuthorityGrant
  • epistemic atoms: REPORTED, OBSERVED, PAIRED_SUPPORT, PAIRED_REFUTATION;
  • lifecycle stages: LOOKUP, LEAD, SEALED_CHALLENGE, OBSERVATION, PAIRED_EVIDENCE, CAPABILITY_CANDIDATE, ACTIVE_CAPABILITY, QUARANTINED, LEGACY_STATIC;
  • grants: LOOKUP, SOURCE_ACQUISITION, SEARCH, SEALED_EVALUATION, INFERENCE, ACTIVATE, EXECUTE, ASSEMBLE.

Join, meet, and port composition can combine or compare types; they cannot mint a grant. Grants arise only through explicit lifecycle rules and exact transition receipts. A report can therefore remain searchable without being an inference premise, and matching a fragment's STRUCT port cannot turn that report into executable code.

The disclosure snapshot manifests 1,266 exact static fragment keys from 73 reviewed JSON source files. Each static source binding pins the filename, whole-file SHA-256, normalized fragment SHA-256, and render profile. The 423 shape-registry entries can participate in typed legacy composition. Other manifested entries may retain exact whole-fragment behavior but cannot claim a typed composition port. Mutable learned/generated fragment projections are excluded from legacy static authority; placing identical bytes in a mutable file does not authorize them. Raw C templates are verified before parameter substitution, and Python fragments are verified before assembly.

Sealed evaluation without outcome leakage

FORGE separates the material allowed to guide search from the material allowed to judge a candidate.

For a literal callable challenge, the builder archives the reported task and derives two siblings from one lead:

  1. the SEARCH projection contains the callable interface and public input records but no expected outputs;
  2. the EVALUATION projection contains a canonical relation IR and is available only to the pinned evaluator.

The siblings have distinct content digests and grants, share the same parent lead and policy root, and cannot be substituted for one another. A replay that begins from the public task must resolve the durable search artifact to exactly one lead and exactly one sealed evaluator artifact, validate all digests and descriptor links, and reconstruct evaluator-only expected cases only for the supported canonical literal relation. Ambiguity, missing links, tampering, unsupported relation forms, or policy drift fail closed.

Candidate generation and ranking are therefore outcome-blind on this lane; the external relation still observes and scores completed programs. This is a data-flow property backed by descriptors, pinned evaluator identity, sealed artifact resolution, and adversarial regression tests.

From research report to retained capability

The public-research path is deliberately staged:

  1. A bounded HTTPS client retrieves an arXiv Atom response or RSS/Atom feed, retains exact response bytes and conditional metadata, rejects private or ambiguous network destinations, and applies size/count limits.
  2. Parsed publications become REPORTED records and report-qualified lookup edges. They are explicitly ineligible as causal premises or executable fragments.
  3. A publication may identify a public repository. FORGE resolves an exact provider object and commit, downloads a bounded archive as data, validates paths/links, and statically parses supported literal test assertions. It does not import or execute the acquired repository.
  4. The derived task is split into SEARCH and sealed EVALUATION projections.
  5. Program frontiers execute candidates locally under the pinned evaluator.
  6. Stable paired evidence produces a capability candidate. A separate two-phase authority handoff binds the exact program hash to an ACTIVE descriptor before it becomes an executable/reusable seed.
  7. Later refutation or contested evidence removes the active projection and quarantines it without deleting the original observations.

Legacy program-library records without the current durable authority binding remain observational. A syntactically valid program or an older success flag does not by itself confer EXECUTE, ASSEMBLE, or INFERENCE.

Program search and capability compounding

The generic search plane includes several finite lanes rather than a single hard-coded result vocabulary:

  • exact legacy and empirically learned programs;
  • interface-derived integer/value expression grammars;
  • reflected, bounded protocol operations over JSON-safe values;
  • syntax-projected callable donors and provenance-preserving composition;
  • persisted search productions acquired through the lifecycle; and
  • repository tree-edit candidates when a source-level gap is reproduced.

Candidate programs are parsed before use. The definition-inert projection admits plain functions and literal module state while excluding eager imports, decorators, class bodies, computed defaults, and other top-level effects from lanes that cannot safely contain them. Exact tried-program hashes, evaluator fingerprints, and resource cursors survive restart, so later cycles advance instead of silently replaying an exhausted prefix.

Supported programs can become content-addressed macros or opaque callables. Their metadata retains the evidence and authority references that taught them, and the next task independently evaluates them again. Transfer is measured on a later structurally changed task, not by relabeling the task that produced the seed.

Ghost, Mind, and the Level-C boundary

Ghost is the reversible source-generation path. Repository repair renders a candidate into a separate immutable generation, executes control and treatment under the same oracle, archives the contrast, and changes an active generation pointer through compare-and-swap. Canonical source bytes remain a stable reference, and failed adoption can roll back to a prior generation.

Mind is the persistent active/shadow cohort and adoption layer. Exact checkpoints, work cursors, source intent, and activation state live in durable storage so a reconstructed coordinator or fresh process can adopt the selected generation without relying on the memory of the process that discovered it.

The categorical ladder used by the project is:

Level Required demonstration
A — acquisition Discover and causally activate a program for a schema-open external relation.
B — transfer Reuse a learned primitive on a structurally changed task and beat a clean-start control in closure cost.
C — self-expansion Detect that the current language/frontier is insufficient, build and Ghost-activate a missing substrate primitive, then close the original goal without a supplied patch.
D — continual organism Grow a heterogeneous retained frontier unattended with bounded state, calibrated unknowns, restart recovery and no unexplained regression.
E — systems improvement Replace a measured runtime/storage/search bottleneck, prove parity and lower end-to-end closure cost, then migrate safely.
F — distributed compounding Make persistent active/shadow replicas improve frontier growth without duplicating evidence or corrupting lineage.
G — open-world research Invent a useful representation and experiment in a domain absent from the initial vocabulary, falsify the result and transfer the abstraction.

The included bounded Level C.1 experiment starts with an empty production catalog, acquires one audited generic reflected-call production, reuses the same production_ref across different receiver types, and verifies source/catalog rollback. This verifies acquisition and transfer of one missing production from a closed reviewed family.

See benchmarks/AUTONOMY_LADDER.md and benchmarks/PRACTICAL_STATUS.md for the anti-test design and measured boundaries.

Threat model and fail-closed boundaries

The authority and research code addresses accidental misuse and adversarial persisted inputs: malformed mappings, digest drift, duplicate identities, ambiguous links, stale receipts, path traversal, archive links, private-network fetches, result/evaluator substitution, copied fragment bytes, forged legacy records, replay across a changed policy, and activation without paired support.

Important boundaries:

  • content-addressing proves byte identity, not that the bytes are benign;
  • a source report is not promoted to truth merely because it parses;
  • an exit code, type check, or internal success label is not goal support;
  • unknown, rejected, refuted and contested results remain first-class state;
  • offensive tools can cause real harm if an operator points them at real infrastructure; and
  • safe use requires a separately controlled lab, network policy, credentials, legal authority and human operational judgment.

Verified capabilities in this snapshot

Verified capability
Deterministic finite search and canonical identities for the implemented lanes
Independent shape colors and epistemic/lifecycle/grant authority
Report-qualified lookup separated from inference and executable authority
Exact SEARCH/EVALUATION sibling projections for supported literal relations
Paired evidence, candidate envelopes, exact ACTIVE bindings and counterevidence quarantine
Restart-persistent program state and reversible source-generation adoption
Static bounded parsing of content-pinned public-repository tests
Level A/B mechanisms and bounded C.1 production acquisition and transfer
Complete offensive-security source and reviewed static fragment libraries

Benchmark measurements retain their recorded environment. Re-run the executable authority in an isolated environment and report the commit, Python version, platform, dependency set, resource limits and raw result.

Installation

FORGE is currently a research repository, not a published pip package. Python 3.12 or 3.13 is recommended.

git clone https://github.com/DT-Foss/FORGE.git
cd FORGE
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -r requirements.txt

requirements.txt is intentionally broad because the legacy fragment and domain surfaces cover many optional libraries. The authority/autonomy core and its focused tests need a much smaller subset. Installing or running the code is permitted only within the narrow internal, noncommercial research terms in LICENSE; no patent license is granted.

Entry points

# Interactive legacy FORGE shell
python3 forge.py

# Local persistent autonomy runner
python3 forge_autonomy.py --help

# Manifest-driven cryptanalysis baseline
python3 forge_crypto.py --help

Local, outcome-sealed autonomy smoke

python3 forge_autonomy.py run \
  examples/autonomy/coding_antitest_smoke.json \
  --cycles 3 --db /tmp/forge-smoke.sqlite3

Persistent research intake

These commands intentionally use the network and are not part of safe CI:

python3 forge_autonomy.py awaken --db /tmp/forge-research.sqlite3
python3 forge_autonomy.py awaken --status --db /tmp/forge-research.sqlite3

python3 forge_autonomy.py acquire arxiv \
  --query 'cat:cs.PL AND all:"program synthesis"' \
  --page-size 25 --max-pages 1 --max-polls 1 \
  --db /tmp/forge-research.sqlite3

Acquisition archives reports; it does not authorize report-derived execution. Use an egress-restricted research environment if you do not want live access.

Cryptanalysis baseline

python3 forge_crypto.py validate examples/cryptanalysis/toy_campaign.json
python3 forge_crypto.py run examples/cryptanalysis/toy_campaign.json
python3 forge_crypto.py status examples/cryptanalysis/toy_campaign.json

See CRYPTO_AUTONOMY.md. This is a declared, manifest-driven scientific baseline, not the definition of open-ended autonomy.

Tests and benchmarks

Run the complete test suite locally:

python -m pytest -q

Run the authority, sealed-evaluation, activation and restart-critical subset:

python -m pytest -q \
  tests/test_authority_algebra.py \
  tests/test_authority_runtime.py \
  tests/test_capability_authority_chain.py \
  tests/test_capability_authority_gate.py \
  tests/test_research_authority_pipeline.py \
  tests/test_gap_replay.py \
  tests/test_authority_vertical_e2e.py

The GitHub workflow runs its audited test command inside an operating-system network namespace with no external interfaces and adds a Python socket guard as defense in depth. It compiles every indexed Python file, validates publication hygiene, and runs a safe unit subset. It does not run live acquisition, engagement, deployment, persistence, exploit, scanning, credential, payload or malware paths.

Representative reproducible benchmark drivers include:

python3 benchmarks/run_research_capability.py
python3 benchmarks/run_research_self_selected.py
python3 benchmarks/run_level_c_production.py
python3 benchmarks/measure_frontier.py
python3 benchmarks/measure_causal_startup_batch.py

Generated databases and result files are deliberately ignored. The scripts, fixtures, external relations and assertions are the reproducible authority; publish new measurements with their own environment and commit metadata.

Repository map

core/                    deterministic product/runtime modules
core/autonomy/           persistent empirical search, evidence and authority
core/cryptanalysis/      manifest-driven cryptanalysis baseline
fragments/               reviewed static executable fragment sources
knowledge/               static .causal graphs and knowledge assets
tests/                   unit, integrity, restart and vertical anti-tests
examples/                local autonomy and toy cryptanalysis fixtures
benchmarks/              benchmark drivers, task material and status documents
docs/                    decisions, enabling disclosure and integrity manifest
.github/                 safe CI, issue forms and publication controls
forge.py                  legacy interactive shell
forge_autonomy.py         open-ended autonomy CLI
forge_crypto.py           cryptanalysis CLI

Runtime state belongs outside the publication: SQLite databases and journals, session/audit logs, generated programs/results, caches, locks, private notes, operator target material and repository copies are ignored and are rejected by the publication audit.

Responsible disclosure and security

Do not post a vulnerability, credential, live target, exploit transcript, or private artifact in a public issue. Follow SECURITY.md and use GitHub private vulnerability reporting. Reports should include the exact tag or commit, a minimal lab-only reproducer, expected/observed behavior and impact.

The repository is published intact for technical disclosure. A responsible-use statement is not a technical control and does not authorize activity. You are responsible for complying with applicable law, contracts, policies, export rules and scope of authorization.

Patent/disclosure caveat

This release is intentionally public. The USPTO states that an inventor's public disclosure can start a one-year U.S. grace period and may preclude patenting in foreign countries; a provisional application also must adequately support subject matter later claimed. WIPO explains that pre-filing public disclosure can destroy novelty where no applicable grace period exists. See the official USPTO provisional-application guidance and WIPO patent-protection guidance.

Nothing in this repository says that any particular claim is patentable, that a later application will receive the disclosure date, or that publication preserves rights in any jurisdiction. This is not legal advice.

Citation, contributions and license

Use CITATION.cff when referring to the tagged disclosure. The tag and commit—not a moving branch—should be cited for reproducibility.

Unsolicited code contributions are not currently accepted because the project is a narrowly licensed source-available research disclosure and has not adopted a contributor license. Reproduction reports and technical corrections may be opened as issues subject to CONTRIBUTING.md.

Copyright © 2026 David Tom Foss. All rights reserved except for the limited copyright permission in LICENSE. No patent or trademark license is granted.

About

Deterministic, content-addressed empirical program synthesis with sealed evaluation, authority algebra, and reversible Ghost/Mind activation.

Topics

Resources

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages