Add SmallCode constrained agent execution gate documentation

2026-07-31 03:05:21 +00:00 · 2026-05-18 11:42:44 -05:00 · 2026-05-18 11:42:44 -05:00 · 390116d2f4
commit 390116d2f4
parent 04c2796cd3
1 changed files with 315 additions and 0 deletions
--- a/6-Documentation/famm/SMALLCODE_CONSTRAINED_AGENT_EXECUTION_GATE.md
+++ b/6-Documentation/famm/SMALLCODE_CONSTRAINED_AGENT_EXECUTION_GATE.md
@ -0,0 +1,315 @@
+# SmallCode Constrained Agent Execution Gate
+
+## Purpose
+
+Add SmallCode as a constrained-agent execution gate for the project.
+
+SmallCode is a terminal-native coding agent optimized for small local LLMs, especially models in the 7B-20B range. Its project value is that it does not assume frontier-model context, reliable tool calling, or perfect one-shot planning. Instead, it shrinks the active execution field with context budgeting, TODO decomposition, patch-first edits, working memory, forgiving tool parsing, verifier/governor logic, and optional escalation.
+
+Project shape:
+
+```text
+small local model
+→ budgeted context
+→ category-level tool routing
+→ TODO decomposition
+→ patch-first mutation
+→ verifier / governor receipt
+→ Warden escalation only on hard fail
+```
+
+## Source
+
+```text
+Repository: https://github.com/Doorman11991/smallcode
+README branch: master
+Integrated: 2026-05-18
+```
+
+The README describes SmallCode as an AI coding agent optimized for small LLMs under or around 20B parameters. It emphasizes budget-managed context, multi-format/flexible tool parsing, TODO-file decomposed planning, patch-first editing, persistent working memory, early-stop detection, model profiles, and optional cloud escalation after retry/decompose hard failure.
+
+## Project name
+
+```text
+SMALLCODE_CONSTRAINED_AGENT_EXECUTION_GATE
+```
+
+Alternative names:
+
+```text
+LOCAL_MODEL_WARDEN_EXECUTION_GATE
+BUDGETED_AGENT_FIELD_SHRINKER
+SMALL_LLM_LOGOGRAM_EXECUTION_GATE
+```
+
+## Why this fits
+
+SmallCode is an operational example of field shrinking:
+
+```text
+raw coding task
+→ summarized context
+→ reduced tool schema exposure
+→ atomic TODO plan
+→ patch-level edit
+→ compile/lint/check receipt
+```
+
+It is not merely a coding tool. In this stack, it becomes a practical execution model for Semantic Mass routing and logogram-kernel compression under constrained local compute.
+
+## Mapping to project primitives
+
+| SmallCode concept | Project mapping |
+|---|---|
+| small local LLM | constrained strand / low-capacity agent |
+| context budget engine | Semantic Mass field budget |
+| TODO-driven planning | Builder decomposition ledger |
+| patch-first editing | residual-minimizing mutation |
+| forgiving tool parser | Warden-tolerant interface layer |
+| working memory | NUVMAP / Delta-DAG local memory |
+| early-stop detection | loop scar / coarsening trigger |
+| model escalation | Judge/Warden escalation gate |
+| BoneScript | logogram/code-kernel compression |
+| verifier / governor | Judge/Warden execution receipt |
+
+## BoneScript as code-logogram kernel
+
+SmallCode's README says BoneScript can reduce many backend-generation tool calls into one or two higher-level operations. Project translation:
+
+```text
+many low-level tool calls
+→ one high-level semantic code kernel
+→ deterministic expansion
+→ fewer active transitions
+→ smaller computational field
+```
+
+So a `.bone` file becomes a code logogram:
+
+```math
+\Gamma_{\mathrm{bone}}
+=
+(
+\mathrm{schema},
+\mathrm{routes},
+\mathrm{auth},
+\mathrm{db},
+\mathrm{events},
+\mathrm{sdk},
+\epsilon,
+\rho
+)
+```
+
+Expansion path:
+
+```text
+.bone packet
+→ generated backend project
+→ compile/check receipt
+→ residual repair if needed
+```
+
+## Universal Shortcut Center packet
+
+```math
+\Gamma_{\mathrm{SmallCode}}
+=
+(
+X_{\mathrm{task}},
+\pi_{\mathrm{summary}},
+W_{\mathrm{todo}},
+R_{\mathrm{patch}},
+I_{\mathrm{compile}},
+G_{\mathrm{local}},
+K,
+\epsilon
+)
+```
+
+| Packet term | Meaning |
+|---|---|
+| `X_task` | full software task / repository state |
+| `pi_summary` | context-budget projection into signatures/summaries |
+| `W_todo` | TODO-file working witness |
+| `R_patch` | search-and-replace reconstruction route |
+| `I_compile` | compile/lint/test invariant |
+| `G_local` | local model/tooling guard |
+| `K` | token/tool/compute cost |
+| `epsilon` | residual errors after patch/check |
+
+## Semantic radix / logogram connection
+
+SmallCode is a real software analog of the Semantic Radix Field:
+
+```math
+b_\star(x)
+=
+\operatorname*{argmin}_{b,\mathcal G}
+[
+K_{\mathrm{symbols}}
+
+K_{\mathrm{decoder}}
+
+K_{\mathrm{routing}}
+
+K_{\mathrm{residual}}
+
+K_{\mathrm{receipt}}
+]
+```
+
+In SmallCode terms:
+
+```text
+reduce K_context     via summaries/signatures
+reduce K_routing     via 2-stage tool routing
+reduce K_mutation    via patch-first edits
+reduce K_planning    via TODO decomposition
+reduce K_failure     via verifier/governor loops
+```
+
+## GCCL / imaginary phase codec placement
+
+SmallCode can be treated as an execution-side consumer of GCCL phase packets:
+
+```text
+real/survivor packet         → apply patch / compile
+imaginary/witness packet     → inspect / summarize / record memory
+negative/cancellation packet → revert / remove bad route
+negative-imaginary packet    → adversarial test / Warden probe
+```
+
+This gives a practical action mapping for imaginary GCCL routing.
+
+## FAMM object
+
+```math
+\mathfrak C_{\mathrm{SmallCodeGate}}
+=
+A_{16}(u_{\mathrm{smallcode}})
+\otimes
+[
+\Sigma_{\mathrm{task}}
+
+\Sigma_{\mathrm{context}}
+
+\Sigma_{\mathrm{todo}}
+
+\Sigma_{\mathrm{patch}}
+
+\Sigma_{\mathrm{toolRoute}}
+
+\Sigma_{\mathrm{memory}}
+
+\Sigma_{\mathrm{verifier}}
+
+\Sigma_{\mathrm{escalation}}
+
+\Sigma_{\epsilon}
+
+\Sigma_{\mathrm{receipt}}
+]
+```
+
+## BraidStorm use
+
+Each local coding agent becomes a constrained strand:
+
+```math
+s_i=(M_i,C_i,T_i,P_i,V_i,\epsilon_i,\Omega_i,\rho_i)
+```
+
+where:
+
+| Term | Meaning |
+|---|---|
+| `M_i` | local model profile |
+| `C_i` | context budget state |
+| `T_i` | TODO plan state |
+| `P_i` | patch proposal |
+| `V_i` | verifier result |
+| `epsilon_i` | residual after verification |
+| `Omega_i` | scar / loop / failure pressure |
+| `rho_i` | receipt confidence |
+
+Braid crossing:
+
+```text
+agent strand proposes patch
+→ verifier checks invariant
+→ Warden scars loop/failure
+→ escalation only if local route hard-fails
+```
+
+## Anti-FAMM / Anti-BraidStorm checks
+
+Anti-FAMM asks:
+
+```text
+Did the summary hide a relevant code path?
+Did patch-first editing preserve local syntax but break global invariant?
+Did the verifier miss a semantic failure?
+```
+
+Anti-BraidStorm asks:
+
+```text
+Did multiple agents converge on the same wrong patch?
+Did tool-call parsing repair a malformed command into the wrong action?
+Did TODO decomposition create false local success with global failure?
+```
+
+## Warden boundaries
+
+Allowed claim:
+
+```text
+SmallCode gives the project a concrete constrained-agent execution model for small local LLMs, using context budgeting, TODO decomposition, patch-first mutation, verifier/governor checks, and escalation gates to shrink the active coding field.
+```
+
+Disallowed claim:
+
+```text
+SmallCode guarantees small models can perform all frontier-model coding tasks without error or verification.
+```
+
+Warden requirements:
+
+```text
+patches must be checked
+summaries must be treated as lossy
+escalation must be bounded
+local model failures must become scars/coarsening agents
+compile/lint/test receipts must dominate model confidence
+```
+
+## Stack placement
+
+```text
+SMALLCODE_CONSTRAINED_AGENT_EXECUTION_GATE
+→ Semantic Radix / Logogram Kernel layer
+→ GCCL Complex Phase Codec action mapping
+→ Autonomous Speedrun Harness Gate
+→ FAMM Scar Ledger
+→ Anti-FAMM / Anti-BraidStorm adversarial checks
+→ NUVMAP Delta-DAG execution receipt
+→ Builder-Judge-Warden promotion or rejection
+```
+
+## Project sentence
+
+SmallCode is a constrained-agent execution gate: instead of assuming frontier-model context and perfect tool calling, it shrinks the computational field through budgeted context, TODO decomposition, patch-first edits, working memory, verifier/governor checks, and optional escalation, making it a practical analog of Semantic Mass routing and logogram-kernel execution for small local models.
+
+## Citation
+
+```bibtex
+@online{doorman11991_smallcode,
+  title        = {SmallCode},
+  author       = {{Doorman11991}},
+  organization = {GitHub},
+  url          = {https://github.com/Doorman11991/smallcode},
+  urldate      = {2026-05-18},
+  note         = {Terminal-native coding agent optimized for small local LLMs; README branch master.}
+}
+```