diff --git a/6-Documentation/famm/POSSIBLE_CONSTRAINED_AGENT_APPROACHES.md b/6-Documentation/famm/POSSIBLE_CONSTRAINED_AGENT_APPROACHES.md
new file mode 100644
index 00000000..8258dcf4
--- /dev/null
+++ b/6-Documentation/famm/POSSIBLE_CONSTRAINED_AGENT_APPROACHES.md
@@ -0,0 +1,504 @@
+# Possible Constrained-Agent Approaches
+
+## Purpose
+
+Consolidate the project's prior SmallCode-like approaches and add GLIA as a persistent-memory substrate.
+
+This document is intentionally named **possible approaches**. It is a routing map, not a final architecture claim. Each approach is a candidate route for shrinking the active computational field while preserving receipts, memory, verification, and Warden boundaries.
+
+```text
+small/local model or constrained agent
+→ memory recall
+→ context-budget projection
+→ TODO/plan decomposition
+→ patch/logogram mutation
+→ verifier/governor check
+→ adversarial dual tests
+→ FAMM scar/coarsening or promotion
+→ memory update receipt
+```
+
+## External anchors
+
+### SmallCode
+
+```text
+Repository: https://github.com/Doorman11991/smallcode
+Role: constrained local coding agent / execution field shrinker
+```
+
+SmallCode is a terminal-native coding agent optimized for small local LLMs, especially 7B-20B models. It uses budget-managed context, TODO-file decomposition, patch-first editing, forgiving tool parsing, working memory, verifier/governor logic, early-stop detection, and optional escalation.
+
+### GLIA
+
+```text
+Repository: https://github.com/Eshaan-Nair/Glia-AI
+Role: local-first cross-tool persistent memory / recall substrate
+```
+
+GLIA describes itself as a local-first memory layer that captures AI conversations, builds a searchable knowledge graph, and injects relevant context into new prompts. It has two shared-memory interfaces: a browser extension for chat websites and an MCP server for coding tools. Both read/write the same backend memory store.
+
+GLIA features especially relevant to this stack:
+
+```text
+browser extension + MCP server
+shared local memory store
+hybrid retrieval: sentence vectors + chunk vectors + FTS5
+knowledge graph extraction
+HyDE retrieval
+small-to-big retrieval
+surgical sentence trimming
+background indexing
+project isolation
+prune_memory for outdated facts
+SQLite/WAL local mode
+```
+
+## Consolidated approach map
+
+| Approach | Role | Existing project analogue | External analogue |
+|---|---|---|---|
+| Hermes field-operator bridge | controlled workflow operator | Hermes / Warden receipts | GLIA MCP + SmallCode skills |
+| FastPatchCheck | fast viability check | local patch smoke test | SmallCode verifier |
+| StructuralAdmissibilityCheck | invariant legitimacy check | Judge structural gate | SmallCode governor |
+| BridgeModel_GlobalGate | hard execution choke point | guarded transition | SmallCode tool routing / GLIA injection guard |
+| BridgeModel_Linter | architecture safety scanner | Warden pre-runtime alert | SmallCode parser repair / GLIA sanitization |
+| GCL Combined Coding Surface | typed coding substrate | encode/mutate/repair/gate/receipt | coding tools + MCP surfaces |
+| Logogram Chirality Route Gate | semantic kernel routing | glyph/code kernel phase | BoneScript / semantic code packets |
+| TraceInvariant direction | session continuity / drift prevention | trace budget + failure ledger | GLIA memory + SmallCode TODO/session state |
+| Anti-FAMM | witness blind-spot adversary | projection-nullspace attack | memory/summary hidden-failure tests |
+| Anti-BraidStorm | hostile crossing adversary | false survivor detection | multi-agent patch convergence tests |
+
+## Approach A — Memory-first agent substrate
+
+Use GLIA as the memory substrate.
+
+```text
+conversation / coding session
+→ store_memory / Save Chat
+→ embeddings + knowledge graph triples
+→ recall_context / auto-injection
+→ project-scoped memory packet
+```
+
+Project mapping:
+
+```math
+\Gamma_{\mathrm{GliaMemory}}
+=
+(
+X_{\mathrm{history}},
+\pi_{\mathrm{chunk}},
+W_{\mathrm{recall}},
+R_{\mathrm{inject}},
+I_{\mathrm{decision}},
+G_{\mathrm{project}},
+K,
+\epsilon
+)
+```
+
+| Packet term | Meaning |
+|---|---|
+| `X_history` | full conversation / project history |
+| `pi_chunk` | chunking, embedding, graph extraction |
+| `W_recall` | retrieved context / graph facts |
+| `R_inject` | prompt or MCP context injection |
+| `I_decision` | remembered project decisions and constraints |
+| `G_project` | project/session isolation guard |
+| `K` | retrieval, storage, and prompt budget cost |
+| `epsilon` | stale, irrelevant, or missing memory residual |
+
+Warden checks:
+
+```text
+stale memory
+wrong project memory
+cross-project leakage
+prompt injection in retrieved chunks
+PII leakage
+over-injection / context noise
+memory facts treated as proof
+```
+
+## Approach B — Execution-first constrained coding agent
+
+Use SmallCode-like architecture as the execution substrate.
+
+```text
+raw coding request
+→ budgeted context summary
+→ TODO decomposition
+→ patch-first edit
+→ compile/lint/test verifier
+→ Warden decision
+→ escalation only on hard fail
+```
+
+Project mapping:
+
+```math
+\Gamma_{\mathrm{SmallCode}}
+=
+(
+X_{\mathrm{task}},
+\pi_{\mathrm{summary}},
+W_{\mathrm{todo}},
+R_{\mathrm{patch}},
+I_{\mathrm{compile}},
+G_{\mathrm{local}},
+K,
+\epsilon
+)
+```
+
+Useful when:
+
+```text
+local models are weaker than frontier models
+context is limited
+whole-file rewrites are risky
+patches can be locally verified
+session state must survive across turns
+```
+
+Warden checks:
+
+```text
+patch compiles but violates global invariant
+summary hid relevant code path
+tool parser repaired into wrong command
+TODO plan says done while tests fail
+local loop / repetition detected
+unbounded cloud escalation
+```
+
+## Approach C — GLIA + SmallCode combined route
+
+This is the strongest practical integration.
+
+```text
+GLIA recalls durable project memory
+→ SmallCode executes constrained patch plan
+→ verifier emits receipt
+→ GLIA stores final decision and scars
+```
+
+Pipeline:
+
+```text
+1. identify_active_project / project selection
+2. recall_context for relevant prior decisions
+3. SmallCode builds TODO plan
+4. execute patch-first edit
+5. run verifier / tests / lint
+6. Anti-FAMM checks summary/memory blind spots
+7. Anti-BraidStorm checks false convergence across candidate patches
+8. store_memory with final decision, failure, or scar
+9. NUVMAP Delta-DAG records the route
+```
+
+This route turns memory and execution into a closed loop:
+
+```text
+memory informs action
+action emits receipt
+receipt updates memory
+future recall sees the scar or promotion
+```
+
+## Approach D — Hermes-style authority bridge
+
+Hermes remains the authority/workflow bridge.
+
+```text
+tool or agent may execute/suggest/schedule
+but may not promote without receipts
+```
+
+Use Hermes when the route needs explicit permissioning:
+
+```text
+skill execution
+scheduled audit
+automation
+cross-tool workflow
+write authority
+promotion-state changes
+```
+
+Project mapping:
+
+```text
+Hermes = authority substrate
+GLIA = memory substrate
+SmallCode = execution substrate
+FAMM = scar/residual substrate
+BJW = decision substrate
+NUVMAP = route-memory substrate
+```
+
+## Approach E — FastPatch + StructuralAdmissibility route
+
+This is the local-to-global verifier route.
+
+```text
+FastPatchCheck
+→ local viability
+→ StructuralAdmissibilityCheck
+→ invariant legitimacy
+→ escalationNeeded or promotion
+```
+
+Use it as the default verification stack for coding agents:
+
+```text
+patch is syntactically valid
+patch compiles/tests locally
+patch preserves architectural invariant
+patch has no hidden route leak
+patch emits receipt
+```
+
+## Approach F — Logogram/code-kernel route
+
+Use semantic/logogram kernels to reduce active tool calls.
+
+```text
+many low-level tool calls
+→ one high-level semantic kernel
+→ deterministic expansion
+→ compile/check receipt
+```
+
+External analogue:
+
+```text
+BoneScript in SmallCode
+```
+
+Project analogue:
+
+```text
+LOGOGRAM_RADIX_FIELD
+GCCL_COMPLEX_PHASE_CODEC
+CODE_LOGOGRAM_KERNEL
+```
+
+Rule:
+
+```text
+internal bases may be weird;
+external recovery must be boring.
+```
+
+So every code-logogram must expand back to ordinary files, tests, bytes, or standard source code with receipts.
+
+## Approach G — GCCL complex phase action routing
+
+Use GCCL complex phase routing to classify agent actions:
+
+```text
+phase  1   → survivor action / apply patch
+phase  i   → witness action / inspect, recall, summarize
+phase -1   → cancellation action / revert, remove, undo
+phase -i   → adversarial action / probe, fuzz, Warden test
+```
+
+With omnidirectional GCCL:
+
+```math
+\theta=e^{i\phi}
+```
+
+becomes a continuous routing field rather than a four-state switch.
+
+Use this when actions need to carry:
+
+```text
+chirality
+witness direction
+cancellation pressure
+scar burden
+receipt confidence
+adversarial pressure
+```
+
+## Approach H — Adversarial duals as mandatory hardening
+
+Before promotion, run:
+
+```text
+Anti-FAMM
+→ searches for invisible residuals and false scars
+
+Anti-BraidStorm
+→ searches for false convergence, aliasing, wrong-handed recombination, receipt drift
+```
+
+For memory-agent systems, this becomes:
+
+```text
+Anti-FAMM memory test:
+  Does retrieved context omit a fact that changes the decision?
+
+Anti-BraidStorm patch test:
+  Do several agents converge on the same wrong edit because they share a poisoned memory or false summary?
+```
+
+## Approach I — NUVMAP Delta-DAG execution receipts
+
+Every memory/action/check route becomes a Delta-DAG edge:
+
+```text
+state_t
+→ recalled context
+→ patch proposal
+→ verifier result
+→ adversarial result
+→ state_t+1
+```
+
+Receipt packet:
+
+```text
+memory_hash
+context_hash
+patch_hash
+test_hash
+scar_hash
+promotion_state
+```
+
+This gives the project replay, provenance, and failure reuse.
+
+## Recommended practical architecture
+
+```text
+GLIA persistent memory
+→ SmallCode constrained execution
+→ FastPatchCheck / StructuralAdmissibilityCheck
+→ Anti-FAMM / Anti-BraidStorm adversarial probes
+→ FAMM scar/coarsening ledger
+→ NUVMAP Delta-DAG route receipt
+→ GLIA store_memory / project summary update
+```
+
+Short form:
+
+```text
+GLIA remembers.
+SmallCode acts.
+FAMM scars.
+BJW decides.
+NUVMAP receipts.
+Hermes governs.
+```
+
+## Possible implementation tiers
+
+### Tier 0 — Manual doctrine
+
+Use the document as workflow guidance only.
+
+```text
+recall manually
+patch manually
+verify manually
+store decision manually
+```
+
+### Tier 1 — Local memory + constrained execution
+
+Use GLIA for memory and SmallCode for coding.
+
+```text
+GLIA recall_context
+→ SmallCode plan/patch
+→ tests
+→ GLIA store_memory
+```
+
+### Tier 2 — Receipt-bearing workflow
+
+Add FAMM-style receipts.
+
+```text
+memory hash
+patch hash
+test hash
+scar class
+promotion decision
+```
+
+### Tier 3 — Adversarial hardening
+
+Add Anti-FAMM and Anti-BraidStorm.
+
+```text
+memory blind-spot probes
+summary-loss checks
+false-convergence checks
+patch alias checks
+```
+
+### Tier 4 — GCCL phase-routed agents
+
+Use complex phase routing to classify actions and automate Warden behavior.
+
+```text
+apply / witness / cancel / adversarial probe
+```
+
+## Warden boundaries
+
+Allowed claim:
+
+```text
+These approaches give the project several concrete routes for constrained local-agent execution, persistent memory, patch-first coding, logogram-code kernels, and adversarial verification.
+```
+
+Disallowed claim:
+
+```text
+SmallCode, GLIA, or any local-agent stack guarantees correctness without tests, receipts, project isolation, and Warden checks.
+```
+
+Hard rules:
+
+```text
+memory is evidence, not proof
+summaries are lossy
+retrieval can be stale
+patches must be verified
+agent convergence can be false
+cloud escalation must be bounded
+project isolation must be checked
+receipts dominate model confidence
+```
+
+## Project sentence
+
+The possible constrained-agent approach is to pair GLIA-style durable memory with SmallCode-style constrained execution: recall the right project context, decompose into atomic TODOs, mutate by patch/logogram kernels, verify through fast and structural gates, attack with Anti-FAMM and Anti-BraidStorm, then store the resulting receipt, scar, or promotion back into the memory graph for the next run.
+
+## Citations
+
+```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.}
+}
+
+@online{nair_glia_ai,
+  title        = {GLIA — Persistent Memory for AI Coding Tools},
+  author       = {Nair, Eshaan},
+  organization = {GitHub},
+  url          = {https://github.com/Eshaan-Nair/Glia-AI},
+  urldate      = {2026-05-18},
+  note         = {Local-first memory layer with browser extension and MCP server sharing one memory store.}
+}
+```