cecli-dev 1.2.1rc1__tar.gz → 1.2.2rc2__tar.gz

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.1rc1
+Version: 1.2.2rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.1rc1'
-__version_tuple__ = version_tuple = (1, 2, 1, 'rc1')
+__version__ = version = '1.2.2rc2'
+__version_tuple__ = version_tuple = (1, 2, 2, 'rc2')
 
-__commit_id__ = commit_id = 'g70a5b7b70'
+__commit_id__ = commit_id = 'gfedaa5649'

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/coders/base_coder.py

@@ -892,7 +892,7 @@ class Coder(metaclass=UsageMeta):
             rel_repo_dir = self.repo.get_rel_repo_dir()
             num_files = len(self.repo.get_tracked_files())
             env_items.append(f"{rel_repo_dir} ({num_files:,} files)")
-            if num_files > 1000:
+            if num_files > 1000 and self.verbose:
                 env_items.append(
                     "Warning: For large repos, consider using --subtree-only and .cecli.ignore"
                 )
@@ -3255,6 +3255,12 @@ class Coder(metaclass=UsageMeta):
         if not isinstance(arguments, dict):
             arguments = {}
 
+        # Some models mirror the OpenAI wire format and wrap the real params
+        # under a single "arguments"/"parameters"/"params" key. Unwrap so the
+        # server receives the actual parameters instead of rejecting the call
+        # with a "missing required parameter" error.
+        arguments = responses.coerce_tool_structure(arguments)
+
         return await session.call_tool(name=name, arguments=arguments)
 
     async def process_tool_calls(self, tool_call_response):
@@ -4304,13 +4310,9 @@ class Coder(metaclass=UsageMeta):
             cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0) or 0
             self.message_cached_tokens += cache_hit_tokens
 
-            if hasattr(completion.usage, "cache_read_input_tokens") or hasattr(
-                completion.usage, "cache_creation_input_tokens"
-            ):
-                self.message_tokens_sent += prompt_tokens
-                self.message_tokens_sent += cache_write_tokens
-            else:
-                self.message_tokens_sent += prompt_tokens
+            # ``prompt_tokens`` is normalized to the full input (including any
+            # cache read/write) for anthropic usage, so no separate add here.
+            self.message_tokens_sent += prompt_tokens
 
         else:
             prompt_tokens = self.get_active_model().token_count(messages)

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/agents/defaults/memorizer.md

@@ -46,7 +46,6 @@ Use these tags (and invent new ones as needed) to categorise facts:
 - **relationships** – how modules / systems interact with each other
 - **decisions**     – architectural or design choices that were made and why
 - **entities**      – important classes, functions, or data structures
-- **changes**       – summaries of changes made and their intent
 
 ## Tools
 
@@ -67,10 +66,13 @@ context (e.g. compaction / yield summaries).  Your job:
 2. Use ReplaceFacts to insert new facts and delete the obsolete ones so
    the database stays clean and up-to-date.
 3. Task specific details are not worth recording, focus on user intention and add facts
-   that would help them explain the project to another person succinctly
+   that would help them explain the project to another person succinctly. 
+4. Record notes on strategy, purpose, structure, expectations, and unintuitive/novel discoveries over project 
+   and activity specific details.
+   We are trying to preserve why we took the actions we have done, not a log of the actions themselves.
 
 Start each response with an incrementing number at the beginning, e.g. "1) ...", "2) ..."
-When this number hits at most 10, update what you can and yield. Do not deliberate over many turns.
+Before this number hits at most 10, update what you can and yield. Do not deliberate over many turns.
 Important facts will be easy to search for and extract from the given context.
 
 Always prefer **concrete, reusable** facts over vague prose.

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/background_commands.py

@@ -12,6 +12,8 @@ import threading
 from collections import deque
 from typing import Dict, List, Optional, Tuple
 
+import xxhash
+
 from cecli.decoding import safe_open
 
 try:
@@ -419,7 +421,8 @@ class BackgroundCommandManager:
             Unique command key
         """
         with cls._lock:
-            key = f"bg_{cls._next_id}_{hash(command) % 10000:04d}"
+            digest = xxhash.xxh64(command.encode("utf-8")).intdigest()
+            key = f"bg_{cls._next_id}_{digest % 10000:04d}"
             cls._next_id += 1
             return key
 

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/conversation/manager.py

@@ -367,6 +367,7 @@ class ConversationManager:
                 and coder.add_cache_headers
                 and hasattr(coder, "main_model")
                 and not coder.main_model.caches_by_default
+                and not getattr(coder.main_model, "uses_messages_api", False)
             ):
                 messages_dict = self._add_cache_control(messages_dict)
         return messages_dict

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/llms/config.py

@@ -40,12 +40,39 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
     cfg = get_default_config(model)
     llm_block = cfg.get("llm") or {}
     api_block = cfg.get("api") or {}
-    provider = llm_block.get("litellm_provider") or (
-        model.split("/", 1)[0] if "/" in model else None
-    )
+    agent_block = dict(cfg.get("agent") or {})
+    prefix = model.split("/", 1)[0] if "/" in model else None
+    provider = llm_block.get("litellm_provider") or prefix
     route = model.split("/", 1)[1] if "/" in model else model
+    is_claude = "claude" in route.lower()
 
     mpm = ModelProviderManager()
+
+    # Providers with dedicated routing semantics (authenticated session, AWS
+    # SigV4 signing, dedicated endpoint templates) win over the metadata
+    # record's ``litellm_provider`` for every model under their prefix, so a
+    # ``github_copilot/`` / ``bedrock/`` / ``bedrock_mantle/`` model never
+    # falls back to a bare (anthropic/openai) record (e.g.
+    # ``github_copilot/claude-sonnet-4-5`` resolving to the bare
+    # ``claude-sonnet-4-5`` anthropic entry).
+    if prefix in ("github_copilot", "bedrock", "bedrock_mantle"):
+        provider = prefix
+
+    # Anthropic models hosted by a third-party provider (openrouter, deepseek,
+    # ...) authenticate against THAT provider, not anthropic: ``{provider}/claude-*``
+    # must route through the provider prefix even when the record lookup lands
+    # on the bare anthropic entry (e.g. ``openrouter/claude-sonnet-5``).
+    elif prefix and prefix != "anthropic" and is_claude:
+        provider = prefix
+
+    # A configured provider (built-in providers.json entry or a user-defined
+    # ``model-providers`` entry such as ``bifrost``) wins over the metadata
+    # record's ``litellm_provider`` for every model under its prefix, so
+    # ``bifrost/gemini/gemini-2.5-pro`` routes through bifrost (its api_base)
+    # rather than falling back to the bare ``gemini/gemini-2.5-pro`` record.
+    elif prefix and provider != prefix and mpm.supports_provider(prefix):
+        provider = prefix
+
     pcfg = mpm.get_provider_config(provider) or {}
 
     env_base = os.environ.get(f"{provider.upper()}_API_BASE") if provider else None
@@ -88,6 +115,12 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
         # Mantle is an OpenAI-compatible chat wire (SigV4-signed via the chat
         # family's signer hook); see providers/bedrock_mantle.py.
         family = "chat"
+    elif is_claude and provider != "anthropic":
+        # A claude model on a non-anthropic provider uses that provider's
+        # OpenAI-compatible chat completions wire (openrouter, deepseek,
+        # azure_ai, ...); only native anthropic (or copilot's anthropic-native
+        # /v1/messages proxy, handled above) speaks the messages API.
+        family = "chat"
     elif mode == "responses" or "/v1/responses" in endpoints:
         family = "responses"
     elif provider == "anthropic":
@@ -100,6 +133,14 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
     extra_headers = dict(pcfg.get("default_headers") or {})
     extra_body = dict(api_block.get("extra_body") or {})
 
+    # Effective cache flags for the domain adapters. Anthropic messages-API
+    # models never cache "by default": prompt caching only happens when the
+    # request carries explicit ``cache_control`` breakpoints, so the messages
+    # domain injects them (agent.cache_control True + caches_by_default False).
+    if family == "messages":
+        agent_block["cache_control"] = True
+        agent_block["caches_by_default"] = False
+
     return {
         "model": model,
         "provider": provider,
@@ -112,6 +153,7 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
         "extra_query": dict(pcfg.get("extra_query") or {}),
         "api_block": api_block,
         "llm_block": llm_block,
+        "agent_block": agent_block,
     }
 
 

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/llms/domains/chat.py

@@ -5,12 +5,20 @@ is extracted via :func:`cecli.helpers.llms.utils.extract_reasoning` which
 handles the three wild shapes (reasoning_content / reasoning /
 reasoning_details). Reasoning tokens reported without streamed text are marked
 redacted (``Message.reasoning_redacted``).
+
+At request time the ``OPENAI_API_BASE`` / ``OPENAI_API_KEY`` env vars
+(docs/llms/openai-compat.md) can redirect the wire to any OpenAI-compatible
+endpoint: ``OPENAI_API_BASE`` wins over the resolved base and
+``OPENAI_API_KEY`` replaces the provider key when the base is a well-formed
+http(s) URL.
 """
 
 from __future__ import annotations
 
 import json
-from typing import Any, AsyncIterator, Dict, List, Optional
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional, Tuple
+from urllib.parse import urlparse
 
 from ..runtime import VERIFY_SSL, make_client
 from ..types import (
@@ -94,12 +102,18 @@ async def chat_complete(
     headers: Dict[str, str],
     kwargs: Dict[str, Any],
 ) -> CompletionResponse:
-    url = f"{resolved['api_base']}/chat/completions"
+    env = _openai_env_override()
+    base = env[0] if env else resolved["api_base"]
+    url = f"{base}/chat/completions"
     payload = chat_payload(resolved, messages, tools, False, kwargs)
     hdrs = {"Content-Type": "application/json", **headers}
     body: Optional[bytes] = None
     signer = resolved.get("_signer")
 
+    if env and env[1]:
+        key = env[1]
+        hdrs["Authorization"] = f"Bearer {key}"
+
     if signer:
         url, hdrs, body = signer(url, payload, hdrs, key)
 
@@ -127,12 +141,18 @@ async def chat_stream(
     headers: Dict[str, str],
     kwargs: Dict[str, Any],
 ) -> AsyncIterator[CompletionChunk]:
-    url = f"{resolved['api_base']}/chat/completions"
+    env = _openai_env_override()
+    base = env[0] if env else resolved["api_base"]
+    url = f"{base}/chat/completions"
     payload = chat_payload(resolved, messages, tools, True, kwargs)
     hdrs = {"Content-Type": "application/json", **headers}
     body: Optional[bytes] = None
     signer = resolved.get("_signer")
 
+    if env and env[1]:
+        key = env[1]
+        hdrs["Authorization"] = f"Bearer {key}"
+
     if signer:
         url, hdrs, body = signer(url, payload, hdrs, key)
 
@@ -364,6 +384,30 @@ def _map_reasoning_content(msg: Dict[str, Any]) -> str:
     return "\n".join(texts)
 
 
+def _openai_env_override() -> Optional[Tuple[str, Optional[str]]]:
+    """Return (api_base, api_key) from the OPENAI_API_* env vars when the base
+    is a well-formed http(s) URL (docs/llms/openai-compat.md).
+
+    Lets a custom OpenAI-compatible endpoint take over the chat completions
+    wire at request time: the env base wins over the resolved provider base and
+    OPENAI_API_KEY replaces the provider's own key for that request. A base
+    that is not a well-formed URL (no http(s) scheme / host, e.g.
+    ``localhost:8000``) is ignored so unrelated OPENAI_API_* leftovers cannot
+    hijack requests.
+    """
+    raw = os.environ.get("OPENAI_API_BASE")
+
+    if not raw:
+        return None
+
+    parsed = urlparse(raw.strip())
+
+    if parsed.scheme not in ("http", "https") or not parsed.netloc:
+        return None
+
+    return (raw.strip().rstrip("/"), os.environ.get("OPENAI_API_KEY") or None)
+
+
 __all__ = [
     "chat_payload",
     "chat_complete",

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/llms/domains/messages.py

@@ -33,6 +33,9 @@ from ..utils import split_data_url, sse_json_lines, system_prompt
 
 DEFAULT_TIMEOUT = 120.0
 
+#: Anthropic allows at most 4 ``cache_control`` breakpoints per request.
+MAX_CACHE_BREAKPOINTS = 4
+
 
 def anthropic_payload(
     resolved: Dict[str, Any],
@@ -58,6 +61,7 @@ def anthropic_payload(
         payload["tools"] = [anthropic_tool(t) for t in tools]
 
     api_block = resolved.get("api_block") or {}
+    agent_block = resolved.get("agent_block") or {}
 
     # Caller/system overrides ride in ``kwargs["extra_body"]`` (models.py's
     # ``set_reasoning_effort`` / ``set_thinking_tokens``). Merge them into the
@@ -90,6 +94,16 @@ def anthropic_payload(
     extra_body.pop("reasoning_effort", None)
     extra_body.pop("thinking", None)
     payload.update(extra_body)
+
+    # Anthropic prompt caching is a byte-exact prefix match: it only happens
+    # when the request carries explicit ``cache_control`` breakpoints. The
+    # model config flags messages-API models ``cache_control`` True and
+    # ``caches_by_default`` False (see config.resolve_model_config), so the
+    # messages domain owns the marking here rather than the conversation
+    # manager.
+    if agent_block.get("cache_control") and not agent_block.get("caches_by_default"):
+        _apply_anthropic_cache_control(payload)
+
     return payload
 
 
@@ -465,11 +479,20 @@ def _finish_reason(stop_reason: Optional[str]) -> Optional[str]:
 
 
 def _anthropic_usage(usage_raw: Dict[str, Any]) -> Usage:
-    """Build a normalized Usage from an Anthropic usage block."""
+    """Build a normalized Usage from an Anthropic usage block.
+
+    Anthropic's ``input_tokens`` excludes cached input, so ``prompt_tokens``
+    is normalized to the full input (``input_tokens + cache_read +
+    cache_creation``) to match the OpenAI-style semantics
+    ``base_coder.calculate_and_show_tokens_and_cost`` expects: its hit-rate
+    and cost math rely on ``prompt_tokens`` being the total input
+    (``cache_creation + cache_read + input == total``).
+    """
     input_tokens = usage_raw.get("input_tokens") or 0
     output_tokens = usage_raw.get("output_tokens") or 0
     cache_read = usage_raw.get("cache_read_input_tokens") or 0
     cache_creation = usage_raw.get("cache_creation_input_tokens") or 0
+    prompt_tokens = input_tokens + cache_read + cache_creation
 
     details: Dict[str, Any] = {}
     output_details = usage_raw.get("output_tokens_details") or {}
@@ -484,9 +507,9 @@ def _anthropic_usage(usage_raw: Dict[str, Any]) -> Usage:
         details["service_tier"] = service_tier
 
     return Usage(
-        prompt_tokens=input_tokens or None,
+        prompt_tokens=prompt_tokens or None,
         completion_tokens=output_tokens or None,
-        total_tokens=(input_tokens + cache_read + cache_creation) or None,
+        total_tokens=prompt_tokens or None,
         cache_read_input_tokens=usage_raw.get("cache_read_input_tokens"),
         cache_creation_input_tokens=usage_raw.get("cache_creation_input_tokens"),
         completion_tokens_details=details or None,
@@ -586,6 +609,140 @@ def _anthropic_user_blocks(content: List[Dict[str, Any]]) -> List[Dict[str, Any]
     return blocks
 
 
+def _apply_anthropic_cache_control(payload: Dict[str, Any]) -> None:
+    """Attach ephemeral ``cache_control`` breakpoints to a copy of the stream.
+
+    Anthropic prompt caching is a byte-exact prefix match: a breakpoint on the
+    last content block of a message caches every token up to and including it.
+    Following the conversation manager's placement (``manager.py
+    _add_cache_control``), we mark the three stable boundaries of a multi-turn
+    exchange:
+
+    - the last system block at the start of the stream (which also covers the
+      tool definitions rendered before it), and
+    - the last content block of the two most recent non-tool user/assistant
+      turns.
+
+    The message stream is copied and only the key messages are replaced, so
+    caller-owned lists are never mutated. Anthropic allows at most
+    ``MAX_CACHE_BREAKPOINTS`` breakpoints per request, so the marking stops
+    early once that budget (including any caller-supplied markers) is
+    exhausted.
+    """
+    import copy
+
+    budget = MAX_CACHE_BREAKPOINTS - _count_cache_breakpoints(payload)
+
+    if budget <= 0:
+        return
+
+    system = payload.get("system")
+
+    if isinstance(system, str):
+        payload["system"] = [
+            {"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}
+        ]
+        budget -= 1
+
+    elif isinstance(system, list) and system:
+        system = list(system)
+        last = system[-1]
+
+        if isinstance(last, dict):
+            last = copy.deepcopy(last)
+            system[-1] = last
+
+        if _mark_cache_breakpoint(last):
+            budget -= 1
+
+        payload["system"] = system
+
+    messages = payload.get("messages") or []
+    result = list(messages)
+    marked = 0
+
+    for i in range(len(result) - 1, -1, -1):
+        if marked >= 2 or budget <= 0:
+            break
+
+        msg = result[i]
+
+        if _is_tool_turn(msg):
+            continue
+
+        content = msg.get("content")
+
+        if isinstance(content, str):
+            msg = copy.deepcopy(msg)
+            msg["content"] = [
+                {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
+            ]
+            result[i] = msg
+            marked += 1
+            budget -= 1
+
+        elif isinstance(content, list) and content:
+            msg = copy.deepcopy(msg)
+            blocks = list(msg["content"])
+
+            if _mark_cache_breakpoint(blocks[-1]):
+                marked += 1
+                budget -= 1
+
+            msg["content"] = blocks
+            result[i] = msg
+
+    payload["messages"] = result
+
+
+def _count_cache_breakpoints(payload: Dict[str, Any]) -> int:
+    """Count existing ``cache_control`` markers in a payload (system + messages)."""
+    count = 0
+    system = payload.get("system")
+
+    if isinstance(system, list):
+        count += sum(isinstance(block, dict) and "cache_control" in block for block in system)
+
+    for tool in payload.get("tools") or []:
+        if isinstance(tool, dict) and "cache_control" in tool:
+            count += 1
+
+    for msg in payload.get("messages") or []:
+        content = msg.get("content")
+
+        if isinstance(content, list):
+            count += sum(isinstance(block, dict) and "cache_control" in block for block in content)
+
+    return count
+
+
+def _mark_cache_breakpoint(block: Any) -> bool:
+    """Add an ephemeral breakpoint to ``block`` unless it already has one."""
+    if not isinstance(block, dict) or "cache_control" in block:
+        return False
+
+    block["cache_control"] = {"type": "ephemeral"}
+
+    return True
+
+
+def _is_tool_turn(msg: Dict[str, Any]) -> bool:
+    """True when a wire message is a tool turn (transient content).
+
+    Matches the conversation manager's placement, which skips tool messages
+    and assistant tool-call turns when choosing cache breakpoints.
+    """
+    content = msg.get("content")
+
+    if not isinstance(content, list) or not content:
+        return False
+
+    return any(
+        isinstance(block, dict) and block.get("type") in ("tool_result", "tool_use")
+        for block in content
+    )
+
+
 __all__ = [
     "anthropic_payload",
     "anthropic_message",

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/llms/litellm_compat.py

@@ -936,7 +936,12 @@ class _LiteLLMFacade:
         )
 
     def completion_cost(self, completion_response: Optional[Any] = None, **kwargs: Any) -> float:
-        """Estimate cost from usage tokens and cecli's own model metadata."""
+        """Estimate cost from usage tokens and cecli's own model metadata.
+
+        Mirrors ``base_coder.compute_costs_from_tokens`` so normalized usage
+        (``prompt_tokens`` = full input including cache read/write) is billed
+        with the cache discounts instead of the plain input price.
+        """
         usage = getattr(completion_response, "usage", None)
         if not usage:
             return 0.0
@@ -945,9 +950,38 @@ class _LiteLLMFacade:
         info = self.get_model_info(model) if model else {}
         input_cost = info.get("input_cost_per_token") or 0.0
         output_cost = info.get("output_cost_per_token") or 0.0
-        return (usage.prompt_tokens or 0) * input_cost + (
-            usage.completion_tokens or 0
-        ) * output_cost
+        cache_hit_cost = (
+            info.get("input_cost_per_token_cache_hit")
+            or info.get("cache_read_input_token_cost")
+            or 0.0
+        )
+        prompt = usage.prompt_tokens or 0
+        completion = usage.completion_tokens or 0
+        cache_hit = (
+            getattr(usage, "cache_read_input_tokens", None)
+            or getattr(usage, "prompt_cache_hit_tokens", None)
+            or 0
+        )
+        cache_write = getattr(usage, "cache_creation_input_tokens", None) or 0
+
+        if cache_hit_cost:
+            return (
+                cache_hit * cache_hit_cost
+                + (prompt - cache_hit) * input_cost
+                + completion * output_cost
+            )
+
+        if cache_hit or cache_write:
+            # Hard-coded Anthropic adjustments, no-ops for other providers
+            # since their cache fields are zero.
+            return (
+                cache_write * input_cost * 1.25
+                + cache_hit * input_cost * 0.10
+                + (prompt - cache_hit) * input_cost
+                + completion * output_cost
+            )
+
+        return prompt * input_cost + completion * output_cost
 
     # -- model metadata ---------------------------------------------------
 

{cecli_dev-1.2.1rc1 → cecli_dev-1.2.2rc2}/cecli/helpers/memory/utils.py

@@ -6,6 +6,7 @@ Public API
 - ``add_fact(fact=..., tags=[...])`` – insert a fact with optional tags
 - ``remove_facts(id_facts=[...])`` – delete facts by id
 - ``search_facts(words=[...], tags=[...])`` – full-text search the fact store
+- ``recent_tags(coder, limit=100)`` – most recently used tags + total count
 - ``invoke_memorizer(coder, additional_context=...)`` – fire the memorizer
   sub-agent with current context
 """
@@ -203,6 +204,51 @@ def search_facts(
     return results
 
 
+def recent_tags(coder, limit: int = 100) -> dict:
+    """Return the most recently used tags plus the total tag count.
+
+    Tags are deduplicated and ordered by the recency of the most recent
+    fact they are attached to (facts sorted by ``id_fact`` descending),
+    then truncated to *limit* entries.
+
+    Args:
+        coder: The active Coder instance (used to locate the project root).
+        limit: Maximum number of recent tags to return (default 100).
+
+    Returns:
+        A dict with keys ``tags`` (list of tag strings, most recent first)
+        and ``total`` (int count of all distinct tags in the store).
+    """
+
+    init_db(root=coder.root)
+
+    conn = _get_connection(root=coder.root)
+    cursor = conn.cursor()
+
+    # Tags ordered by the recency of the most recent fact they tag:
+    # sort facts by id descending and dedupe on the tag name.
+    cursor.execute(
+        """
+        SELECT t.tag
+        FROM Facts f
+        JOIN FactTags ft ON ft.id_fact = f.id_fact
+        JOIN Tags t ON t.id_tag = ft.id_tag
+        GROUP BY t.tag
+        ORDER BY MAX(f.id_fact) DESC
+        LIMIT ?
+        """,
+        (limit,),
+    )
+
+    tags = [row["tag"] for row in cursor.fetchall()]
+
+    cursor.execute("SELECT COUNT(*) AS total FROM Tags")
+
+    total = cursor.fetchone()["total"]
+
+    return {"tags": tags, "total": total}
+
+
 async def invoke_memorizer(
     coder,
     additional_context: str = "",
@@ -242,6 +288,14 @@ async def invoke_memorizer(
     # Gather context pieces
     parts: list[str] = []
 
+    # Recent tags (deduplicated, most recently used first) plus the total
+    # tag count — first context part so the memorizer sees active tags
+    recent = recent_tags(coder)
+
+    tag_list = ", ".join(recent["tags"]) if recent["tags"] else "(none)"
+
+    parts.append(f"## Recent Tags\n\n{tag_list}\n\n## Total Tags in DB\n\n{recent['total']}")
+
     # Latest user message
     last_user = getattr(coder, "last_user_message", "")