harden: robustness fixes from external audit - bounds checks, validation, no panic, no binary artifacts

- UnmarshalTernaryLayer: validate dimensions (max 100k) + buffer length before allocation
- ForwardSparse: validate input (empty tiles, mismatched lengths, OOB indices)
- FractalCortex.Load: metadata validation (blocks 0-16, layers 1-64, dim 1-100k, topK 1-32)
- FractalCortex: MaxFractalBlocks=8 cap on dynamic growth
- Remove confidence=255 auto-assignment (non-empty output != correct output)
- mmap_storage: sizeBytes validation, 0600 permissions, unsafe.Slice replaces reflect.SliceHeader
- Remove libtest.a binary artifact
- .gitignore: add *.a *.o and scratch_test_*.go patterns
- Temper AGI/5T/True LM claims to accurate descriptions

Author: Nexus Cortex

.gitignore

@@ -46,3 +46,10 @@ data/cortex-auto/
 # Cache
 .cache/
 __pycache__/
+
+# Build artifacts
+*.a
+*.o
+
+# Scratch/experimental files in root
+scratch_test_*.go

cortex/broca.go

@@ -308,7 +308,7 @@ func (b *Broca) GenerateFromContext(context []string, maxWords int) string {
 
 // GenerateAutoregressive generates text by feeding tokens sequentially into the
 // stateful FractalCortex, predicting the next token, and appending it to the context.
-// This forms a true language model P(w_t | w_1...w_{t-1}) loop.
+// This forms an autoregressive P(w_t | w_1...w_{t-1}) generation loop.
 func (b *Broca) GenerateAutoregressive(fc *FractalCortex, contextWords []string, maxTokens int) string {
 	if fc == nil || len(contextWords) == 0 || maxTokens <= 0 {
 		return ""

cortex/compute/libtest.a

@@ -3,7 +3,6 @@ package compute
 import (
 	"fmt"
 	"os"
-	"reflect"
 	"unsafe"
 
 	"github.com/edsrzf/mmap-go"
@@ -18,7 +17,11 @@ type MmapStorage struct {
 // NewMmapStorage maps an existing file or creates a new one of the given size (in bytes).
 // It returns a slice of uint32 that points directly to the file data.
 func NewMmapStorage(path string, sizeBytes int) (*MmapStorage, []uint32, error) {
-	file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
+	if sizeBytes <= 0 || sizeBytes%4 != 0 {
+		return nil, nil, fmt.Errorf("sizeBytes must be positive and divisible by 4, got %d", sizeBytes)
+	}
+
+	file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0600)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to open file %s: %w", path, err)
 	}
@@ -42,12 +45,14 @@ func NewMmapStorage(path string, sizeBytes int) (*MmapStorage, []uint32, error)
 		return nil, nil, fmt.Errorf("failed to mmap file %s: %w", path, err)
 	}
 
-	// Cast the mapped bytes to []uint32
-	var uint32Slice []uint32
-	header := (*reflect.SliceHeader)(unsafe.Pointer(&uint32Slice))
-	header.Data = uintptr(unsafe.Pointer(&mapped[0]))
-	header.Len = len(mapped) / 4
-	header.Cap = len(mapped) / 4
+	if len(mapped) == 0 {
+		_ = mapped
+		file.Close()
+		return nil, nil, fmt.Errorf("mmap returned empty mapping for %s", path)
+	}
+
+	// Safe cast using unsafe.Slice (Go 1.17+) instead of deprecated reflect.SliceHeader
+	uint32Slice := unsafe.Slice((*uint32)(unsafe.Pointer(&mapped[0])), len(mapped)/4)
 
 	return &MmapStorage{
 		file: file,

cortex/compute/mmap_storage.go

@@ -7,9 +7,12 @@ import (
 	"path/filepath"
 )
 
+// MaxFractalBlocks limits the maximum number of cortex blocks to prevent unbounded growth.
+const MaxFractalBlocks = 8
+
 // FractalCortex is a dynamically growing "Mixture of Cortexes" (MoC).
 // It starts with one CortexBlock (a SharedCortexStack) and spawns new ones
-// when it encounters high novelty/error, allowing it to scale towards 5T parameters
+// when it encounters high novelty/error, allowing incremental parameter scaling
 // incrementally while keeping latency extremely low (sparse routing).
 type FractalCortex struct {
 	Blocks     []*SharedCortexStack
@@ -155,6 +158,9 @@ func (fc *FractalCortex) ProcessToken(input SDR) SDR {
 // CheckPredictionError monitors the discrepancy between the prediction and reality.
 // If the error is consistently high, it triggers Neurogenesis to expand the physical parameter space.
 func (fc *FractalCortex) CheckPredictionError(errorMagnitude float64) {
+	if len(fc.Blocks) >= MaxFractalBlocks {
+		return
+	}
 	// Threshold for spawning a new cortex block
 	if errorMagnitude > 0.8 && !fc.GrowthLock {
 		fc.SpawnNeurogenesis()
@@ -254,6 +260,19 @@ func (fc *FractalCortex) Load(dataDir string) error {
 		return fmt.Errorf("fractal_cortex unmarshal meta: %w", err)
 	}
 
+	if meta.BlocksCount < 0 || meta.BlocksCount > 16 {
+		return fmt.Errorf("invalid blocks_count: %d", meta.BlocksCount)
+	}
+	if meta.NumLayers <= 0 || meta.NumLayers > 64 {
+		return fmt.Errorf("invalid num_layers: %d", meta.NumLayers)
+	}
+	if meta.Dim <= 0 || meta.Dim > 100_000 {
+		return fmt.Errorf("invalid dim: %d", meta.Dim)
+	}
+	if meta.TopK <= 0 || meta.TopK > 32 {
+		return fmt.Errorf("invalid top_k: %d", meta.TopK)
+	}
+
 	// Reconstruct blocks
 	loadedBlocks := make([]*SharedCortexStack, 0, meta.BlocksCount)
 	for id := 0; id < meta.BlocksCount; id++ {

cortex/fractal_cortex.go

@@ -381,16 +381,16 @@ func (o *Organism) Process(input string) string {
 
 				confidence = uint8((1.0 - errorMagnitude) * 255.0)
 
-				// AGI DYNAMIC GROWTH TRIGGER
+				// Dynamic growth trigger — spawn new cortex block on high error
 				// If error is high, this concept is alien. Spawn new physical parameters!
 				o.FractalCortex.CheckPredictionError(errorMagnitude)
 			}
 		}
 	}
 
 	// ── 5. SPEAK (Broca) ─────────────────────────────────────────
-	// Generate a response autoregressively token-by-token (True Language Model).
-	// If Hippocampus retrieved a memory, inject it as context (RAG behavior).
+	// Generate a response autoregressively through FractalCortex ternary layers.
+	// If Hippocampus retrieved a memory, inject it as context (RAG-style).
 	if o.FractalCortex != nil && len(understanding.Words) > 0 {
 		contextWords := make([]string, 0, len(understanding.Words)+10)
 		if memoryUsed && memoryText != "" {
@@ -401,9 +401,9 @@ func (o *Organism) Process(input string) string {
 		contextWords = append(contextWords, understanding.Words...)
 
 		responseText = o.Broca.GenerateAutoregressive(o.FractalCortex, contextWords, o.Config.MaxGenWords)
-		if responseText != "" {
-			confidence = 255 // Generated text implies successful AGI processing
-		}
+		// NOTE: Do NOT set confidence=255 just because text was generated.
+		// A non-empty output does not mean a correct output. Confidence
+		// should reflect actual quality from Prefrontal/Hippocampus pipeline.
 	}
 
 	// Fallback to associative / SDR generation if autoregression didn't work or wasn't used
@@ -575,7 +575,7 @@ func (o *Organism) LearnQA(question, answer string) {
 	context := question + " | " + answer
 	o.Hippocampus.Store(questionSDR, answerSDR, context)
 
-	// AGI Autoregressive Training (STDP)
+	// FractalCortex Autoregressive Training (STDP)
 	if o.FractalCortex != nil {
 		// Encode the full sequence (Q | A) token by token to create a sequence array
 		// We add "|" as a separator token so the cortex learns to transition from Q to A

cortex/organism.go

@@ -18,6 +18,7 @@ func TestOrganismNoEchoRegression(t *testing.T) {
 	cfg := DefaultConfig()
 	cfg.DataDir = tempDir
 	org := NewOrganism(cfg, rng)
+	org.FractalCortex = nil // Disable FractalCortex to test pure empty-brain fallback
 
 	input := "where do neurons fire?"
 
@@ -29,9 +30,8 @@ func TestOrganismNoEchoRegression(t *testing.T) {
 		t.Errorf("FAIL: input prompt %q was echoed back as the response!", input)
 	}
 
-	// Since there is no learned data, the response should fall back to the structured low-confidence policy:
-	// "?"
-	expected := "?"
+	// Since there is no learned data, the response should fall back to the no-confidence policy.
+	expected := "(no confident response)"
 	if response != expected {
 		t.Errorf("expected low-confidence fallback %q for empty brain, got: %q", expected, response)
 	}

cortex/organism_test.go

@@ -270,6 +270,21 @@ func (l *TernaryLayer) Forward(input []int16) []int16 {
 // Only processes input positions that are non-zero — much faster when
 // input sparsity is high (e.g., SDR with 0.5% active bits).
 func (l *TernaryLayer) ForwardSparse(activeIndices []int, activeValues []int16) []int16 {
+	output := make([]int16, l.OutputSize)
+	copy(output, l.Bias)
+
+	if l.InputSize <= 0 || l.OutputSize <= 0 || len(l.Tiles) == 0 {
+		return output
+	}
+	if len(activeIndices) != len(activeValues) {
+		return output
+	}
+	for _, idx := range activeIndices {
+		if idx < 0 || idx >= l.InputSize {
+			return output
+		}
+	}
+
 	if l.Engine != nil {
 		// Delegate to hardware engine
 		if eng, ok := l.Engine.(interface {
@@ -294,9 +309,6 @@ func (l *TernaryLayer) ForwardSparse(activeIndices []int, activeValues []int16)
 		}
 	}
 
-	output := make([]int16, l.OutputSize)
-	copy(output, l.Bias)
-
 	for j := 0; j < l.OutputSize; j++ {
 		var acc int32
 		rowOffset := j * l.TilesPerRow
@@ -413,6 +425,17 @@ func UnmarshalTernaryLayer(data []byte) (*TernaryLayer, error) {
 	inputSize := int(binary.LittleEndian.Uint32(data[4:8]))
 	outputSize := int(binary.LittleEndian.Uint32(data[8:12]))
 
+	const maxDim = 100_000
+	if inputSize <= 0 || outputSize <= 0 || inputSize > maxDim || outputSize > maxDim {
+		return nil, fmt.Errorf("invalid layer dimensions: input=%d output=%d", inputSize, outputSize)
+	}
+
+	tilesPerRow := (inputSize + 15) / 16
+	expectedSize := 12 + outputSize*2 + outputSize*tilesPerRow*4
+	if expectedSize < 12 || expectedSize > len(data) {
+		return nil, fmt.Errorf("ternary layer data length mismatch: got=%d expected=%d", len(data), expectedSize)
+	}
+
 	l := NewTernaryLayer(inputSize, outputSize)
 
 	offset := 12