Function bodies 199 total

func (x *EmbedResponse) GetEmbedding() []float32 {
	if x != nil {
		return x.Embedding
	}
	return nil
}

func (x *SearchRequest) Reset() {
	*x = SearchRequest{}
	mi := &file_adaptive_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SearchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *SearchRequest) GetQueryText() string {
	if x != nil {
		return x.QueryText
	}
	return ""
}

func (x *SearchRequest) GetQueryEmbedding() []float32 {
	if x != nil {
		return x.QueryEmbedding
	}
	return nil
}

func (x *SearchRequest) GetTopK() int32 {
	if x != nil {
		return x.TopK
	}
	return 0
}

func (x *SearchRequest) GetSimilarityThreshold() float32 {
	if x != nil {
		return x.SimilarityThreshold
	}
	return 0
}

func (x *SearchResult) Reset() {
	*x = SearchResult{}
	mi := &file_adaptive_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SearchResult) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *SearchResult) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *SearchResult) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

func (x *SearchResult) GetScore() float32 {
	if x != nil {
		return x.Score
	}
	return 0
}

func (x *SearchResult) GetMetadataJson() string {
	if x != nil {
		return x.MetadataJson
	}
	return ""
}

func (x *SearchResponse) Reset() {
	*x = SearchResponse{}
	mi := &file_adaptive_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SearchResponse) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *SearchResponse) GetResults() []*SearchResult {
	if x != nil {
		return x.Results
	}
	return nil
}

func (x *StoreEvidenceRequest) Reset() {
	*x = StoreEvidenceRequest{}
	mi := &file_adaptive_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StoreEvidenceRequest) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *StoreEvidenceRequest) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

func (x *StoreEvidenceRequest) GetMetadataJson() string {
	if x != nil {
		return x.MetadataJson
	}
	return ""
}

func (x *StoreEvidenceResponse) Reset() {
	*x = StoreEvidenceResponse{}
	mi := &file_adaptive_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StoreEvidenceResponse) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *StoreEvidenceResponse) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *WebSearchRequest) Reset() {
	*x = WebSearchRequest{}
	mi := &file_adaptive_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WebSearchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *WebSearchRequest) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *WebSearchRequest) GetMaxResults() int32 {
	if x != nil {
		return x.MaxResults
	}
	return 0
}

func (x *WebSearchResult) Reset() {
	*x = WebSearchResult{}
	mi := &file_adaptive_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WebSearchResult) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *WebSearchResult) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *WebSearchResult) GetSnippet() string {
	if x != nil {
		return x.Snippet
	}
	return ""
}

func (x *WebSearchResult) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

func (x *WebSearchResponse) Reset() {
	*x = WebSearchResponse{}
	mi := &file_adaptive_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WebSearchResponse) ProtoReflect() protoreflect.Message {
	mi := &file_adaptive_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *WebSearchResponse) GetResults() []*WebSearchResult {
	if x != nil {
		return x.Results
	}
	return nil
}

func file_adaptive_proto_rawDescGZIP() []byte {
	file_adaptive_proto_rawDescOnce.Do(func() {
		file_adaptive_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_adaptive_proto_rawDesc), len(file_adaptive_proto_rawDesc)))
	})
	return file_adaptive_proto_rawDescData
}

func file_adaptive_proto_init() {
	if File_adaptive_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_adaptive_proto_rawDesc), len(file_adaptive_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_adaptive_proto_goTypes,
		DependencyIndexes: file_adaptive_proto_depIdxs,
		MessageInfos:      file_adaptive_proto_msgTypes,
	}.Build()
	File_adaptive_proto = out.File
	file_adaptive_proto_goTypes = nil
	file_adaptive_proto_depIdxs = nil
}

func NewCodecClient(addr string) (*CodecClient, error) {
	conn, err := grpc.NewClient(addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		return nil, fmt.Errorf("grpc dial %s: %w", addr, err)
	}
	return &CodecClient{
		conn:   conn,
		client: pb.NewCodecServiceClient(conn),
	}, nil
}

func (c *CodecClient) Generate(ctx context.Context, prompt string, stateVec [128]float32, evidence []string, ollamaCtx []int64) (GenerateResult, error) {
	vecSlice := make([]float32, 128)
	copy(vecSlice, stateVec[:])

	resp, err := c.client.Generate(ctx, &pb.GenerateRequest{
		Prompt:      prompt,
		StateVector: vecSlice,
		Evidence:    evidence,
		Context:     ollamaCtx,
	})
	if err != nil {
		return GenerateResult{}, fmt.Errorf("generate rpc: %w", err)
	}

	return GenerateResult{
		Text:    resp.Text,
		Entropy: resp.Entropy,
		Logits:  resp.Logits,
		Context: resp.Context,
	}, nil
}

func (c *CodecClient) Embed(ctx context.Context, text string) ([]float32, error) {
	resp, err := c.client.Embed(ctx, &pb.EmbedRequest{
		Text: text,
	})
	if err != nil {
		return nil, fmt.Errorf("embed rpc: %w", err)
	}
	return resp.Embedding, nil
}

func (c *CodecClient) Search(ctx context.Context, queryText string, topK int, similarityThreshold float32) ([]SearchResult, error) {
	resp, err := c.client.Search(ctx, &pb.SearchRequest{
		QueryText:           queryText,
		TopK:                int32(topK),
		SimilarityThreshold: similarityThreshold,
	})
	if err != nil {
		return nil, fmt.Errorf("search rpc: %w", err)
	}

	results := make([]SearchResult, len(resp.Results))
	for i, r := range resp.Results {
		results[i] = SearchResult{
			ID:           r.Id,
			Text:         r.Text,
			Score:        r.Score,
			MetadataJSON: r.MetadataJson,
		}
	}
	return results, nil
}

func (c *CodecClient) StoreEvidence(ctx context.Context, text string, metadataJSON string) (string, error) {
	resp, err := c.client.StoreEvidence(ctx, &pb.StoreEvidenceRequest{
		Text:         text,
		MetadataJson: metadataJSON,
	})
	if err != nil {
		return "", fmt.Errorf("store evidence rpc: %w", err)
	}
	return resp.Id, nil
}

func (c *CodecClient) WebSearch(ctx context.Context, query string, maxResults int) ([]WebSearchResult, error) {
	resp, err := c.client.WebSearch(ctx, &pb.WebSearchRequest{
		Query:      query,
		MaxResults: int32(maxResults),
	})
	if err != nil {
		return nil, fmt.Errorf("web search rpc: %w", err)
	}

	results := make([]WebSearchResult, len(resp.Results))
	for i, r := range resp.Results {
		results[i] = WebSearchResult{
			Title:   r.Title,
			Snippet: r.Snippet,
			URL:     r.Url,
		}
	}
	return results, nil
}

func (h *EvalHarness) Run(newState state.StateRecord, entropy float32) EvalResult {
	var metrics []EvalMetric
	passed := true
	var failReasons []string

	// 1. State norm bounds: L2 norm of full 128-dim vector
	stateNorm := fullVectorNorm(newState.StateVector)
	stateNormPass := stateNorm <= h.config.MaxStateNorm
	metrics = append(metrics, EvalMetric{
		Name:  "state_norm",
		Value: stateNorm,
		Pass:  stateNormPass,
	})
	if !stateNormPass {
		passed = false
		failReasons = append(failReasons, fmt.Sprintf("state norm %.4f exceeds %.4f", stateNorm, h.config.MaxStateNorm))
	}

	// 2. Segment norm bounds: each of the 4 segments
	segments := []struct {
		name string
		seg  [2]int
	}{
		{"prefs", newState.SegmentMap.Prefs},
		{"goals", newState.SegmentMap.Goals},
		{"heuristics", newState.SegmentMap.Heuristics},
		{"risk", newState.SegmentMap.Risk},
	}

	for _, s := range segments {
		norm := segNorm(newState.StateVector, s.seg)
		segPass := norm <= h.config.MaxSegmentNorm
		metrics = append

func fullVectorNorm(v [128]float32) float32 {
	var sum float64
	for _, x := range v {
		sum += float64(x) * float64(x)
	}
	return float32(math.Sqrt(sum))
}

func segNorm(v [128]float32, seg [2]int) float32 {
	var sum float64
	for i := seg[0]; i < seg[1]; i++ {
		sum += float64(v[i]) * float64(v[i])
	}
	return float32(math.Sqrt(sum))
}

func DefaultEvalConfig() EvalConfig {
	return EvalConfig{
		MaxStateNorm:    50.0,
		MaxSegmentNorm:  15.0,
		EntropyBaseline: 2.0,
	}
}

func (g *Gate) Evaluate(
	old state.StateRecord,
	proposed state.StateRecord,
	signals update.Signals,
	metrics update.Metrics,
	entropy float32,
) GateDecision {
	var vetoes []VetoSignal

	// --- Hard veto pass ---

	// 1. Safety: RiskFlag from signals
	if signals.RiskFlag {
		vetoes = append(vetoes, VetoSignal{
			Type:   VetoSafety,
			Reason: "risk flag set in signals",
		})
	}

	// 2. User correction contradicts update
	if signals.UserCorrection {
		vetoes = append(vetoes, VetoSignal{
			Type:   VetoUserCorrection,
			Reason: "user explicitly corrected prior response",
		})
	}

	// 3. Tool/verifier failure
	if signals.ToolFailure {
		vetoes = append(vetoes, VetoSignal{
			Type:   VetoToolFailure,
			Reason: "tool or verifier reported failure",
		})
	}

	// 4. Constraint violation
	if signals.ConstraintViolation {
		vetoes = append(vetoes, VetoSignal{
			Type:   VetoConstraint,
			Reason: "detected contradiction with constraints",
		})
	}

	// 5. Delta norm exceeds cap
	deltaNorm :

func vectorDelta(old, proposed [128]float32) [128]float32 {
	var delta [128]float32
	for i := range delta {
		delta[i] = proposed[i] - old[i]
	}
	return delta
}

func vectorNorm(v [128]float32) float32 {
	var sum float64
	for _, x := range v {
		sum += float64(x) * float64(x)
	}
	return float32(math.Sqrt(sum))
}