Unit 6b: include, computed defconstant, and defun-inline

[EvanWinget]

What changed

The three unit 6b language surfaces, tooling only, nothing in spec/ or python/bitlisp/ touched:

• include: (include "file") splices one declaration file, resolved through the repeatable -I search path of bitlisp-compile and the REPL, first match winning, no implicit current directory. One parenthesized declaration list per file, nested includes resolved, repeat includes skipped by resolved file, cycles a compile error naming the chain.
• Computed defconstant: the value is now an expression, compiled against the declarations above it and run on the reference VM at declaration time under the default budget. A deliberate, pinned break with unit 4's verbatim-data semantics.
• defun-inline: call-by-name inline functions. Arguments compile once and splice at each parameter reference, so an argument used twice evaluates twice and an unused argument never evaluates. Nothing enters the function tree or symbol table.

Authorizing decisions: docs/execution-plan.md unit 6b (scope expanded and resequenced 2026-08-16 on the two-corpus census of tibetswap and chia-gaming) and the approved unit plan of the same day. This unit is the recorded decision against the self-containment rule, now amended in docs/lang/language.md: compiling uses nothing outside the form and the include files it names, resolved through the same search path everywhere.

Every divergence from classic Chialisp was established by executing the frozen clvm_tools stage 2 reference, and each is stated in the language doc's deviations section: classic reads only an include file's first form, dies on double include (tibetswap's tibet_utils.clib hand-copies code around exactly that), recurses unboundedly on cycles, quotes defconstant values verbatim, and its defun-inline drops extra arguments, substitutes into quoted data and operator position, shadows built-ins, and hangs on self-recursion.

Read the commits in this order

1. docs: state include, computed defconstant, and defun-inline — the language surface and the amended self-containment rule
2. compiler+tools: the include declaration
3. compiler: defconstant computes its value at compile time
4. compiler+tools: defun-inline, call-by-name inline functions
5. vectors: pin the unit 6b compiled representatives
6. docs: flip unit 6b to landed, ignore generated symbol files

Verify independently

.venv/bin/pytest python/tests                      # 750 tests
.venv/bin/python tools/run_vectors.py              # 1006 cases
.venv/bin/python tools/diff_clvm.py --count 10000 --seed 20260816   # VM untouched
PATH=.venv/bin:$PATH ci/lint/lint.sh

# Paste identity: the include build and the pasted build agree byte for byte
mkdir -p /tmp/blib && printf '((defconstant FEE 400) (defun pay (AMT) (- AMT FEE)))' > /tmp/blib/pay.blib
.venv/bin/bitlisp-compile '(program (X) (include "pay.blib") (pay X))' -I /tmp/blib
.venv/bin/bitlisp-compile '(program (X) (defconstant FEE 400) (defun pay (AMT) (- AMT FEE)) (pay X))'

# The classic behaviors each divergence responds to, reproduced from the frozen reference
# (references/clvm_tools, tools/fetch-references.sh): double include dies, defconstant
# quotes verbatim, inline drops extra arguments. See the commit messages for the probes.

[EvanWinget]

Adversarial review ran before requesting merge: three Fable finder agents over the branch diff (include machinery, compile-time semantics, surfaces/docs/tests/vectors), every claim probe-verified by execution. Ten findings survived verification, three major:

1. Include names could escape the search path (absolute names and leading ..), contradicting the documented resolution rule.
2. REPL include lines had no session load-once scope, so the diamond pattern the docs bless failed at the prompt, and a failed include left a half-spliced session.
3. Inline expansion size was unbounded: a 227-character chain of doubling inlines squared its tree per declaration and hung the compiler with the depth cap never firing.

All ten are fixed in the final commit (review fold-ins: confine includes, atomic REPL splices, inline size cap), each with a pinning test. The finders also cleared a long list of suspicions, notably: every example in the language and REPL docs replays byte for byte, the four new vector cases rederive from their sources, the debugger rename path survives the node-valued bindings change, and the depth cap boundary is exact at 100.

After fold-ins: 764 tests, 1006 vector cases, lint clean, diff harness clean at seed 20260816 (10000 compared, 0 failures).