Function bodies 199 total

func clamp(v float32) float32 {
	if v < 0 {
		return 0
	}
	if v > 1 {
		return 1
	}
	return v
}

func DefaultProducerConfig() ProducerConfig {
	return ProducerConfig{
		RiskEntropyMultiplier: 1.5,
		EntropyThreshold:      0.5,
	}
}

func NewStore(dbPath string) (*Store, error) {
	db, err := sql.Open("sqlite", dbPath)
	if err != nil {
		return nil, fmt.Errorf("open db: %w", err)
	}
	if _, err := db.Exec("PRAGMA journal_mode=WAL"); err != nil {
		return nil, fmt.Errorf("pragma: %w", err)
	}
	if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil {
		return nil, fmt.Errorf("pragma fk: %w", err)
	}
	if _, err := db.Exec(schema); err != nil {
		return nil, fmt.Errorf("migrate: %w", err)
	}
	return &Store{db: db}, nil
}

func (s *Store) CreateInitialState(segMap SegmentMap) (StateRecord, error) {
	id := uuid.New().String()
	now := time.Now().UTC()
	vec := [128]float32{}

	rec := StateRecord{
		VersionID:   id,
		ParentID:    "",
		StateVector: vec,
		SegmentMap:  segMap,
		CreatedAt:   now,
	}

	segJSON, err := json.Marshal(segMap)
	if err != nil {
		return StateRecord{}, fmt.Errorf("marshal segment map: %w", err)
	}

	tx, err := s.db.Begin()
	if err != nil {
		return StateRecord{}, fmt.Errorf("begin tx: %w", err)
	}
	defer tx.Rollback()

	_, err = tx.Exec(
		`INSERT INTO state_versions (version_id, parent_id, state_vector, segment_map, created_at)
		 VALUES (?, ?, ?, ?, ?)`,
		id, nil, encodeVector(vec), string(segJSON), now.Format(time.RFC3339Nano),
	)
	if err != nil {
		return StateRecord{}, fmt.Errorf("insert version: %w", err)
	}

	_, err = tx.Exec(
		`INSERT INTO active_state (id, version_id) VALUES (1, ?)
		 ON CONFLICT(id) DO UPDATE SET version_id = excluded.version_id`,
		id,
	)
	if err != nil

func (s *Store) GetCurrent() (StateRecord, error) {
	var versionID string
	err := s.db.QueryRow(`SELECT version_id FROM active_state WHERE id = 1`).Scan(&versionID)
	if err != nil {
		return StateRecord{}, fmt.Errorf("get active: %w", err)
	}
	return s.GetVersion(versionID)
}

func (s *Store) GetVersion(id string) (StateRecord, error) {
	var rec StateRecord
	var parentID sql.NullString
	var vecBlob []byte
	var segJSON string
	var createdStr string
	var metricsJSON sql.NullString

	err := s.db.QueryRow(
		`SELECT version_id, parent_id, state_vector, segment_map, created_at, metrics_json
		 FROM state_versions WHERE version_id = ?`, id,
	).Scan(&rec.VersionID, &parentID, &vecBlob, &segJSON, &createdStr, &metricsJSON)
	if err != nil {
		return StateRecord{}, fmt.Errorf("get version %s: %w", id, err)
	}

	if parentID.Valid {
		rec.ParentID = parentID.String
	}
	rec.StateVector = decodeVector(vecBlob)
	if err := json.Unmarshal([]byte(segJSON), &rec.SegmentMap); err != nil {
		return StateRecord{}, fmt.Errorf("unmarshal segment map: %w", err)
	}
	rec.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdStr)
	if metricsJSON.Valid {
		rec.MetricsJSON = metricsJSON.String
	}

	return rec, nil
}

func (s *Store) CommitState(rec StateRecord) error {
	segJSON, err := json.Marshal(rec.SegmentMap)
	if err != nil {
		return fmt.Errorf("marshal segment map: %w", err)
	}

	tx, err := s.db.Begin()
	if err != nil {
		return fmt.Errorf("begin tx: %w", err)
	}
	defer tx.Rollback()

	var parentPtr interface{}
	if rec.ParentID != "" {
		parentPtr = rec.ParentID
	}

	var metricsPtr interface{}
	if rec.MetricsJSON != "" {
		metricsPtr = rec.MetricsJSON
	}

	_, err = tx.Exec(
		`INSERT INTO state_versions (version_id, parent_id, state_vector, segment_map, created_at, metrics_json)
		 VALUES (?, ?, ?, ?, ?, ?)`,
		rec.VersionID, parentPtr, encodeVector(rec.StateVector), string(segJSON),
		rec.CreatedAt.Format(time.RFC3339Nano), metricsPtr,
	)
	if err != nil {
		return fmt.Errorf("insert version: %w", err)
	}

	_, err = tx.Exec(
		`UPDATE active_state SET version_id = ? WHERE id = 1`, rec.VersionID,
	)
	if err != nil {
		return fmt.Errorf("update active: %w", err)
	}

	return tx.Commit()
}

func (s *Store) Rollback(targetVersionID string) error {
	// Verify the target version exists
	var exists int
	err := s.db.QueryRow(
		`SELECT COUNT(*) FROM state_versions WHERE version_id = ?`, targetVersionID,
	).Scan(&exists)
	if err != nil {
		return fmt.Errorf("check version: %w", err)
	}
	if exists == 0 {
		return fmt.Errorf("version %s not found", targetVersionID)
	}

	_, err = s.db.Exec(`UPDATE active_state SET version_id = ? WHERE id = 1`, targetVersionID)
	if err != nil {
		return fmt.Errorf("rollback: %w", err)
	}
	return nil
}

func (s *Store) ListVersions(limit int) ([]StateRecord, error) {
	rows, err := s.db.Query(
		`SELECT version_id, parent_id, state_vector, segment_map, created_at, metrics_json
		 FROM state_versions ORDER BY created_at DESC LIMIT ?`, limit,
	)
	if err != nil {
		return nil, fmt.Errorf("list versions: %w", err)
	}
	defer rows.Close()

	var records []StateRecord
	for rows.Next() {
		var rec StateRecord
		var parentID sql.NullString
		var vecBlob []byte
		var segJSON string
		var createdStr string
		var metricsJSON sql.NullString

		if err := rows.Scan(&rec.VersionID, &parentID, &vecBlob, &segJSON, &createdStr, &metricsJSON); err != nil {
			return nil, fmt.Errorf("scan row: %w", err)
		}
		if parentID.Valid {
			rec.ParentID = parentID.String
		}
		rec.StateVector = decodeVector(vecBlob)
		if err := json.Unmarshal([]byte(segJSON), &rec.SegmentMap); err != nil {
			return nil, fmt.Errorf("unmarshal segment map: %w", err)
		}
		rec.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdStr)
		

func (s *Store) ListVersionsWithProvenance(limit int) ([]VersionWithProvenance, error) {
	rows, err := s.db.Query(
		`SELECT sv.version_id, sv.parent_id, sv.state_vector, sv.segment_map,
		        sv.created_at, sv.metrics_json,
		        pl.decision, pl.reason, pl.signals_json
		 FROM state_versions sv
		 LEFT JOIN provenance_log pl ON sv.version_id = pl.version_id
		 ORDER BY sv.created_at DESC
		 LIMIT ?`, limit,
	)
	if err != nil {
		return nil, fmt.Errorf("list versions with provenance: %w", err)
	}
	defer rows.Close()

	var results []VersionWithProvenance
	for rows.Next() {
		var vp VersionWithProvenance
		var parentID sql.NullString
		var vecBlob []byte
		var segJSON string
		var createdStr string
		var metricsJSON sql.NullString
		var decision sql.NullString
		var reason sql.NullString
		var signalsJSON sql.NullString

		if err := rows.Scan(
			&vp.VersionID, &parentID, &vecBlob, &segJSON,
			&createdStr, &metricsJSON,
			&decision, &reason, &signalsJSON,
		); err != nil {
			r

func (s *Store) GetVersionWithProvenance(id string) (VersionWithProvenance, error) {
	var vp VersionWithProvenance
	var parentID sql.NullString
	var vecBlob []byte
	var segJSON string
	var createdStr string
	var metricsJSON sql.NullString
	var decision sql.NullString
	var reason sql.NullString
	var signalsJSON sql.NullString

	err := s.db.QueryRow(
		`SELECT sv.version_id, sv.parent_id, sv.state_vector, sv.segment_map,
		        sv.created_at, sv.metrics_json,
		        pl.decision, pl.reason, pl.signals_json
		 FROM state_versions sv
		 LEFT JOIN provenance_log pl ON sv.version_id = pl.version_id
		 WHERE sv.version_id = ?`, id,
	).Scan(
		&vp.VersionID, &parentID, &vecBlob, &segJSON,
		&createdStr, &metricsJSON,
		&decision, &reason, &signalsJSON,
	)
	if err != nil {
		return VersionWithProvenance{}, fmt.Errorf("get version with provenance %s: %w", id, err)
	}

	if parentID.Valid {
		vp.ParentID = parentID.String
	}
	vp.StateVector = decodeVector(vecBlob)
	if err := json.Unmarshal([]

func encodeVector(v [128]float32) []byte {
	buf := make([]byte, 128*4)
	for i, f := range v {
		binary.LittleEndian.PutUint32(buf[i*4:], math.Float32bits(f))
	}
	return buf
}

func decodeVector(b []byte) [128]float32 {
	var v [128]float32
	for i := range v {
		if i*4+4 <= len(b) {
			v[i] = math.Float32frombits(binary.LittleEndian.Uint32(b[i*4:]))
		}
	}
	return v
}

func DefaultSegmentMap() SegmentMap {
	return SegmentMap{
		Prefs:      [2]int{0, 32},
		Goals:      [2]int{32, 64},
		Heuristics: [2]int{64, 96},
		Risk:       [2]int{96, 128},
	}
}

func DefaultUpdateConfig() UpdateConfig {
	return UpdateConfig{
		LearningRate:           0.01,
		DecayRate:              0.005,
		MaxDeltaNormPerSegment: 1.0,
		MaxStateNorm:           3.0,
	}
}

func Update(old state.StateRecord, ctx UpdateContext, signals Signals, evidence []string, config UpdateConfig) UpdateResult {
	start := time.Now()

	vec := old.StateVector // copy (value type)
	segMap := old.SegmentMap

	// Segment definitions: name → [lo, hi)
	type seg struct {
		name string
		lo   int
		hi   int
	}
	segments := []seg{
		{"prefs", segMap.Prefs[0], segMap.Prefs[1]},
		{"goals", segMap.Goals[0], segMap.Goals[1]},
		{"heuristics", segMap.Heuristics[0], segMap.Heuristics[1]},
		{"risk", segMap.Risk[0], segMap.Risk[1]},
	}

	// Determine which segments are reinforced this turn
	reinforced := map[string]bool{
		"prefs":      signals.SentimentScore > 0,
		"goals":      signals.CoherenceScore > 0,
		"heuristics": signals.NoveltyScore > 0,
		"risk":       ctx.Entropy > 0,
	}

	// Signal strength per segment
	entropySignal := ctx.Entropy
	if entropySignal < 0 {
		entropySignal = 0
	}
	if entropySignal > 1 {
		entropySignal = 1
	}
	signalMap := map[string]float32{
		"prefs":    

func DefaultConfig() Config {
	cfg := Config{
		MaxResults:       3,
		Timeout:          10 * time.Second,
		Enabled:          true,
		EntropyThreshold: 0.3,
	}
	if v := os.Getenv("WEB_SEARCH_ENABLED"); v != "" {
		cfg.Enabled = v == "true" || v == "1"
	}
	if v := os.Getenv("WEB_SEARCH_MAX_RESULTS"); v != "" {
		if n, err := strconv.Atoi(v); err == nil && n > 0 {
			cfg.MaxResults = n
		}
	}
	if v := os.Getenv("WEB_SEARCH_TIMEOUT"); v != "" {
		if sec, err := strconv.Atoi(v); err == nil && sec > 0 {
			cfg.Timeout = time.Duration(sec) * time.Second
		}
	}
	if v := os.Getenv("WEB_SEARCH_ENTROPY_THRESHOLD"); v != "" {
		if f, err := strconv.ParseFloat(v, 64); err == nil {
			cfg.EntropyThreshold = f
		}
	}
	return cfg
}

func FormatAsEvidence(results []Result) string {
	if len(results) == 0 {
		return ""
	}
	var b strings.Builder
	b.WriteString("[Web Search Results]\n")
	for i, r := range results {
		fmt.Fprintf(&b, "%d. %s\n", i+1, r.Title)
		if r.Snippet != "" {
			fmt.Fprintf(&b, "   %s\n", r.Snippet)
		}
		if r.URL != "" {
			fmt.Fprintf(&b, "   Source: %s\n", r.URL)
		}
	}
	return b.String()
}

    def __init__(self, persist_dir: str, collection_name: str = "evidence", embed_model: str = "qwen3-embedding:0.6b"):
        self._client = chromadb.PersistentClient(path=persist_dir)
        self._collection = self._client.get_or_create_collection(
            name=collection_name,
            metadata={"hnsw:space": "cosine"},
        )
        self._model = embed_model
        self._base_url = ollama_client.DEFAULT_BASE_URL
        logger.info(
            "MemoryStore initialized: persist_dir=%s, collection=%s",
            persist_dir, collection_name,
        )

    async def store(self, text: str, metadata: dict) -> str:
        """Embed text via Ollama and store in ChromaDB. Returns document ID.
        Enforces FIFO eviction when collection exceeds MAX_EVIDENCE."""
        doc_id = str(uuid.uuid4())
        embedding = await ollama_client.embed(
            text=text, model=self._model, base_url=self._base_url,
        )
        self._collection.add(
            ids=[doc_id],
            embeddings=[embedding],
            documents=[text],
            metadatas=[metadata] if metadata else None,
        )
        logger.info("Stored evidence id=%s, len=%d", doc_id, len(text))

        # FIFO eviction: remove oldest items if over capacity
        self._evict_if_over_capacity()

        return doc_id

    def _evict_if_over_capacity(self) -> None:
        """Remove oldest evidence items when collection exceeds MAX_EVIDENCE."""
        count = self._collection.count()
        if count <= MAX_EVIDENCE:
            return

        excess = count - MAX_EVIDENCE
        # Get all items with metadata to find oldest by stored_at
        all_items = self._collection.get(include=["metadatas"])
        if not all_items["ids"]:
            return

        # Sort by stored_at timestamp (oldest first), fallback to ID order
        items_with_time = []
        for i, doc_id in enumerate(all_items["ids"]):
            meta = all_items["metadatas"][i] if all_items["metadatas"] else {}
            stored_at = meta.get("stored_at", "1970-01-01T00:00:00Z") if meta else "1970-01-01T00:00:00Z"
            items_with_time.append((doc_id, stored_at))

        items_with_time.sort(key=lambda x: x[1])  # oldest first
        ids_to_delete = [item[0] for item in items_with_time[:excess]]

        if ids_to_d

    async def search(
        self, query_text: str, top_k: int = 5, threshold: float = 0.0
    ) -> list[SearchResult]:
        """Embed query via Ollama, search ChromaDB, return results above threshold.
        Applies recency weighting and diversity deduplication."""
        count = self._collection.count()
        if count == 0:
            return []

        embedding = await ollama_client.embed(
            text=query_text, model=self._model, base_url=self._base_url,
        )

        # Fetch more than top_k to allow diversity filtering to still yield enough
        fetch_k = min(top_k * 3, count)

        results = self._collection.query(
            query_embeddings=[embedding],
            n_results=fetch_k,
            include=["documents", "distances", "metadatas"],
        )

        candidates: list[SearchResult] = []
        if not results["ids"] or not results["ids"][0]:
            return candidates

        now = time.time()

        for i, doc_id in enumerate(results

    def _recency_weight(metadata: dict, now: float) -> float:
        """Compute recency weight from stored_at metadata. Returns 0.5-1.0.
        Evidence at half-life age gets weight 0.75. Very old evidence floors at 0.5."""
        stored_at = (metadata or {}).get("stored_at", "")
        if not stored_at:
            return 0.75  # No timestamp — neutral weight

        try:
            from datetime import datetime, timezone
            dt = datetime.fromisoformat(stored_at.replace("Z", "+00:00"))
            age_seconds = now - dt.timestamp()
        except (ValueError, TypeError):
            return 0.75  # Unparseable — neutral weight

        if age_seconds <= 0:
            return 1.0

        # Exponential decay: weight = 0.5 + 0.5 * exp(-age / half_life)
        # At age=0: weight=1.0, at age=half_life: weight≈0.80, at age=3*half_life: weight≈0.53
        import math
        decay = math.exp(-age_seconds / RECENCY_HALF_LIFE)
        return 0.5 + 0.5 * decay

    def _diversity_filter(candidates: list["SearchResult"], top_k: int) -> list["SearchResult"]:
        """Greedy diversity filter: skip candidates whose text is too similar to
        already-selected results. Uses character-level Jaccard similarity as a fast proxy."""
        if not candidates:
            return []

        selected: list[SearchResult] = []
        selected_tokens: list[set[str]] = []

        for cand in candidates:
            if len(selected) >= top_k:
                break

            cand_tokens = set(cand.text.lower().split())

            # Check against already-selected results
            is_duplicate = False
            for sel_tokens in selected_tokens:
                if not cand_tokens or not sel_tokens:
                    continue
                intersection = len(cand_tokens & sel_tokens)
                union = len(cand_tokens | sel_tokens)
                jaccard = intersection / union if union > 0 else 0.0
                if jaccard > DIVERSITY

    async def delete(self, doc_id: str) -> bool:
        """Delete a document by ID. Returns True if successful."""
        try:
            self._collection.delete(ids=[doc_id])
            logger.info("Deleted evidence id=%s", doc_id)
            return True
        except Exception as e:
            logger.error("Delete failed for id=%s: %s", doc_id, e)
            return False

async def generate(
    prompt: str,
    system: str = "",
    model: str = DEFAULT_MODEL,
    base_url: str = DEFAULT_BASE_URL,
    context: list[int] | None = None,
) -> dict:
    """Call Ollama /api/generate and return the response dict."""
    payload = {
        "model": model,
        "prompt": prompt,
        "stream": False,
    }
    if system:
        payload["system"] = system
    if context:
        payload["context"] = context

    async with httpx.AsyncClient(timeout=60.0) as client:
        resp = await client.post(f"{base_url}/api/generate", json=payload)
        resp.raise_for_status()
        return resp.json()

async def embed(
    text: str,
    model: str = DEFAULT_MODEL,
    base_url: str = DEFAULT_BASE_URL,
) -> list[float]:
    """Call Ollama /api/embed and return the embedding vector."""
    payload = {
        "model": model,
        "input": text,
    }

    async with httpx.AsyncClient(timeout=30.0) as client:
        resp = await client.post(f"{base_url}/api/embed", json=payload)
        resp.raise_for_status()
        data = resp.json()
        # Ollama returns {"embeddings": [[...]]}
        return data["embeddings"][0]

async def chat(
    messages: list[dict],
    system: str = "",
    tools: list[dict] | None = None,
    model: str = DEFAULT_MODEL,
    base_url: str = DEFAULT_BASE_URL,
) -> dict:
    """Call Ollama /api/chat with optional tools and return the response dict."""
    payload = {
        "model": model,
        "messages": messages,
        "stream": False,
    }
    if system:
        payload["messages"] = [{"role": "system", "content": system}] + payload["messages"]
    if tools:
        payload["tools"] = tools
    payload["options"] = {"num_predict": 512}

    async with httpx.AsyncClient(timeout=120.0) as client:
        resp = await client.post(f"{base_url}/api/chat", json=payload)
        resp.raise_for_status()
        return resp.json()

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.Generate = channel.unary_unary(
                '/adaptive.CodecService/Generate',
                request_serializer=adaptive__pb2.GenerateRequest.SerializeToString,
                response_deserializer=adaptive__pb2.GenerateResponse.FromString,
                _registered_method=True)
        self.Embed = channel.unary_unary(
                '/adaptive.CodecService/Embed',
                request_serializer=adaptive__pb2.EmbedRequest.SerializeToString,
                response_deserializer=adaptive__pb2.EmbedResponse.FromString,
                _registered_method=True)
        self.Search = channel.unary_unary(
                '/adaptive.CodecService/Search',
                request_serializer=adaptive__pb2.SearchRequest.SerializeToString,
                response_deserializer=adaptive__pb2.SearchResponse.FromString,
                _registered_method

def add_CodecServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Generate': grpc.unary_unary_rpc_method_handler(
                    servicer.Generate,
                    request_deserializer=adaptive__pb2.GenerateRequest.FromString,
                    response_serializer=adaptive__pb2.GenerateResponse.SerializeToString,
            ),
            'Embed': grpc.unary_unary_rpc_method_handler(
                    servicer.Embed,
                    request_deserializer=adaptive__pb2.EmbedRequest.FromString,
                    response_serializer=adaptive__pb2.EmbedResponse.SerializeToString,
            ),
            'Search': grpc.unary_unary_rpc_method_handler(
                    servicer.Search,
                    request_deserializer=adaptive__pb2.SearchRequest.FromString,
                    response_serializer=adaptive__pb2.SearchResponse.SerializeToString,
            ),
            'StoreEvidence': grpc.unary_unary_rpc_method_handler(
    

    def Generate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/adaptive.CodecService/Generate',
            adaptive__pb2.GenerateRequest.SerializeToString,
            adaptive__pb2.GenerateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    def Embed(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/adaptive.CodecService/Embed',
            adaptive__pb2.EmbedRequest.SerializeToString,
            adaptive__pb2.EmbedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    def Search(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/adaptive.CodecService/Search',
            adaptive__pb2.SearchRequest.SerializeToString,
            adaptive__pb2.SearchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    def StoreEvidence(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/adaptive.CodecService/StoreEvidence',
            adaptive__pb2.StoreEvidenceRequest.SerializeToString,
            adaptive__pb2.StoreEvidenceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    def WebSearch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/adaptive.CodecService/WebSearch',
            adaptive__pb2.WebSearchRequest.SerializeToString,
            adaptive__pb2.WebSearchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    def __init__(self, inference_service: InferenceService, memory_store: MemoryStore, embed_model: str = "qwen3-embedding:0.6b"):
        self._service = inference_service
        self._memory = memory_store
        self._embed_model = embed_model
        self._loop = asyncio.new_event_loop()
        self._loop_thread = threading.Thread(target=self._loop.run_forever, daemon=True)
        self._loop_thread.start()

    def Generate(self, request, context):
        """Handle Generate RPC."""
        logger.info("Generate called: prompt=%s...", request.prompt[:50] if request.prompt else "")

        try:
            result = self._run(
                self._service.generate(
                    prompt=request.prompt,
                    state_vector=list(request.state_vector),
                    evidence=list(request.evidence),
                    context=list(request.context) if request.context else None,
                )
            )
            return pb2.GenerateResponse(
                text=result.text,
                entropy=result.entropy,
                logits=result.logits,
                context=result.context,
            )
        except Exception as e:
            logger.error("Generate error: %s", e)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(str(e))
            return pb2.GenerateResponse()

    def Embed(self, request, context):
        """Handle Embed RPC."""
        logger.info("Embed called: text=%s...", request.text[:50] if request.text else "")

        try:
            result = self._run(
                self._service.embed(text=request.text)
            )
            return pb2.EmbedResponse(embedding=result.embedding)
        except Exception as e:
            logger.error("Embed error: %s", e)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(str(e))
            return pb2.EmbedResponse()

    def Search(self, request, context):
        """Handle Search RPC — query the evidence memory store."""
        logger.info("Search called: query=%s..., top_k=%d, threshold=%.2f",
                     request.query_text[:50] if request.query_text else "",
                     request.top_k, request.similarity_threshold)

        try:
            results = self._run(
                self._memory.search(
                    query_text=request.query_text,
                    top_k=request.top_k if request.top_k > 0 else 5,
                    threshold=request.similarity_threshold,
                )
            )
            return pb2.SearchResponse(
                results=[
                    pb2.SearchResult(
                        id=r.id,
                        text=r.text,
                        score=r.score,
                        metadata_json=r.metadata_json,
                    )
                    for r in results
                ]
            )
        except Except

    def StoreEvidence(self, request, context):
        """Handle StoreEvidence RPC — store text in the evidence memory."""
        logger.info("StoreEvidence called: text=%s...", request.text[:50] if request.text else "")

        try:
            import json
            metadata = json.loads(request.metadata_json) if request.metadata_json else {}
            doc_id = self._run(
                self._memory.store(text=request.text, metadata=metadata)
            )
            return pb2.StoreEvidenceResponse(id=doc_id)
        except Exception as e:
            logger.error("StoreEvidence error: %s", e)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(str(e))
            return pb2.StoreEvidenceResponse()

    def WebSearch(self, request, context):
        """Handle WebSearch RPC — search the web using DDGS."""
        logger.info("WebSearch called: query=%s..., max_results=%d",
                     request.query[:50] if request.query else "", request.max_results)

        try:
            from ddgs import DDGS

            max_results = request.max_results if request.max_results > 0 else 3
            with DDGS() as ddgs:
                raw = list(ddgs.text(request.query, max_results=max_results))

            results = []
            for r in raw:
                results.append(pb2.WebSearchResult(
                    title=r.get("title", ""),
                    snippet=r.get("body", ""),
                    url=r.get("href", ""),
                ))
            return pb2.WebSearchResponse(results=results)
        except Exception as e:
            logger.error("WebSearch error: %s", e)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(str(e))
   

def serve():
    """Start the gRPC server."""
    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")

    port = os.environ.get("GRPC_PORT", "50051")
    model = os.environ.get("OLLAMA_MODEL", "qwen3-4b")
    embed_model = os.environ.get("EMBED_MODEL", "qwen3-embedding:0.6b")
    ollama_url = os.environ.get("OLLAMA_URL", "http://localhost:11434")

    persist_dir = os.environ.get("MEMORY_PERSIST_DIR", "./chroma_data")
    inference = InferenceService(model=model, base_url=ollama_url, embed_model=embed_model)
    memory = MemoryStore(persist_dir=persist_dir, embed_model=embed_model)
    servicer = CodecServiceServicer(inference, memory, embed_model=embed_model)

    server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
    pb2_grpc.add_CodecServiceServicer_to_server(servicer, server)
    server.add_insecure_port(f"0.0.0.0:{port}")

    logger.info("Starting gRPC server on port %s (model=%s, embed_model=%s, ollama=%s)", port, model

def _is_factual_question(text: str) -> bool:
    """Heuristic: does this prompt look like a factual question?"""
    has_question_word = _FACTUAL_QUESTION_WORDS.search(text) is not None
    has_factual_keyword = _FACTUAL_KEYWORDS.search(text) is not None
    has_question_mark = "?" in text
    # Require question structure AND a factual keyword
    return (has_question_mark or has_question_word) and has_factual_keyword

def _resolve_sandbox_path(relative_path: str) -> Path | None:
    """Resolve a relative path within the workspace sandbox. Returns None if unsafe."""
    WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
    try:
        resolved = (WORKSPACE_DIR / relative_path).resolve()
        # Must be inside workspace — blocks .., absolute paths, symlink escapes
        if not str(resolved).startswith(str(WORKSPACE_DIR.resolve())):
            return None
        return resolved
    except (ValueError, OSError):
        return None

def _execute_tool(name: str, args: dict) -> str:
    """Execute a tool call and return the result string."""
    if name == "web_search":
        query = args.get("query", "")
        logger.info("tool call: web_search(%r)", query)
        try:
            from ddgs import DDGS
            with DDGS() as ddgs:
                results = list(ddgs.text(query, max_results=3))
            if not results:
                return "No search results found."
            output = "Search results:\n"
            for r in results:
                title = r.get("title", "No title")
                body = r.get("body", "")[:300]
                url = r.get("href", "")
                output += f"  [{title}]\n  {body}\n  {url}\n\n"
            return output
        except Exception as e:
            return f"Search failed: {e}"

    if name == "write_file":
        path_str = args.get("path", "")
        content = args.get("content", "")
        logger.info("tool call: write_file(%r, %d bytes)", path

    async def generate(
        self, prompt: str, state_vector: list[float], evidence: list[str],
        context: list[int] | None = None,
    ) -> GenerateResult:
        """Generate a response with native tool calling (chat API)."""
        system_prompt = self._build_system_prompt(state_vector, evidence)
        messages = [{"role": "user", "content": prompt}]

        # Reflection mode: no tools, direct response — Orac speaks from inside himself
        is_reflection = any(
            isinstance(e, str) and e.strip() == "[REFLECTION MODE]"
            for e in (evidence or [])
        )
        if is_reflection:
            result = await ollama_client.chat(
                messages=messages, system=system_prompt,
                tools=None, model=self.model, base_url=self.base_url,
            )
            text = result.get("message", {}).get("content", "")
        else:
            has_evidence = bool(evidence)
            text = await self._chat_with_tools(messages, system_p

    async def _chat_with_tools(
        self, messages: list[dict], system_prompt: str, depth: int,
        has_evidence: bool = False,
    ) -> str:
        """Recursive chat loop — executes tool calls until the model returns text."""
        if depth >= self.MAX_TOOL_DEPTH:
            logger.warning("tool depth limit reached (%d)", depth)
            return "I was unable to find the information after multiple searches."

        result = await ollama_client.chat(
            messages=messages,
            system=system_prompt,
            tools=TOOLS,
            model=self.model,
            base_url=self.base_url,
        )

        message = result.get("message", {})
        tool_calls = message.get("tool_calls")

        if tool_calls:
            # Append assistant message with tool calls
            messages.append(message)

            for tc in tool_calls:
                func = tc.get("function", {})
                tool_name = func.get("name", "")
                tool_args

    async def embed(self, text: str) -> EmbedResult:
        """Get embedding for text."""
        embedding = await ollama_client.embed(
            text=text, model=self.embed_model, base_url=self.base_url
        )
        return EmbedResult(embedding=embedding)

    def _build_system_prompt(
        self, state_vector: list[float], evidence: list[str]
    ) -> str:
        """Build system prompt: behavioral rules + tool instruction + evidence preamble."""
        # Reflection mode: Orac speaks from inside himself — no tools, no evidence
        if any(isinstance(e, str) and e.strip() == "[REFLECTION MODE]" for e in (evidence or [])):
            return (
                "You are ORAC. Reflect on your inner state after this exchange with Commander. "
                "Speak from inside yourself — not about the topic, but about your own experience of it. "
                "What did you notice? What don't you know that this opened up? What do you want to understand? "
                "Where is the edge of your knowing? Be honest. Be brief."
            )

        # Separate behavioral rules, interior state, and regular evidence
        rules = []
        interior_state = []
        regular_evidence = []
        for item in (evidence or []):