@meridiona/meridian-darwin-arm64 1.68.0 → 1.69.0

package/.env.example

@@ -45,9 +45,14 @@
 # If both are present, OAuth wins. JIRA_PROJECT_KEYS applies to either.
 # ---------------------------------------------------------------------------
 
-# (A) OAuth needs NO config — Meridian ships a public client id. The vars below are
-#     optional overrides (e.g. a self-hosted app or a non-default redirect port).
+# (A) OAuth in a RELEASE build needs NO config — Meridian ships a public client id
+#     and bakes the matching client secret in at build time (CI-only; never
+#     committed). A LOCAL SOURCE BUILD (cargo run / npm run tauri dev) has no
+#     baked-in secret, so browser OAuth login always fails there with "Jira
+#     OAuth requires a client secret..." until you set JIRA_OAUTH_CLIENT_SECRET
+#     below (ask a Meridiona team member for it) — or just use (B) instead.
 # JIRA_OAUTH_CLIENT_ID=your-atlassian-app-client-id   # override the baked-in client id
+# JIRA_OAUTH_CLIENT_SECRET=your-atlassian-app-client-secret  # REQUIRED for OAuth on a source build
 # JIRA_OAUTH_REDIRECT_PORT=9123      # must match the app's registered redirect
                                      # http://127.0.0.1:<port>/callback
 

package/VERSION

@@ -1 +1 @@
-1.68.0
+1.69.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meridiona/meridian-darwin-arm64",
-  "version": "1.68.0",
+  "version": "1.69.0",
   "description": "Prebuilt Meridian app for macOS arm64 (daemon binary + dashboard + Python services). Installed via @meridiona/meridian.",
   "homepage": "https://github.com/Meridiona/meridian",
   "repository": {

package/services/agents/mlx_classifier.py

@@ -45,6 +45,31 @@ _in_flight = 0
 _last_used = time.monotonic()
 
 
+def _invalidate_dependent_caches() -> None:
+    """Drop caches in other modules keyed off the (about-to-be-freed) model object.
+
+    ``agents.structured`` caches an outlines MLXLM wrapper + compiled FSM
+    Generator(s) per ``id(bundle.model)`` — without this call those caches
+    only get cleared lazily, the next time a structured-generation call
+    happens to see a new model id. That left the "evicted" model (and its
+    outlines_core Index/Guide/Vocabulary, which carry Python-side reference
+    cycles) fully resident for the whole gap: it both defeated this module's
+    single-slot residency guarantee (two generative models briefly alive at
+    once) and, since eviction fires here often — every reranker↔classifier
+    swap — let that stale generation pile up across many reload cycles
+    before Python's own GC schedule swept it, producing multi-GB/hour
+    malloc-zone growth invisible to ``mx.get_active_memory()`` (that call
+    only accounts Metal/unified GPU memory, not this CPU-side object graph).
+    Lazy import: ``agents.structured`` is not a dependency this module needs
+    at import time, only at eviction time.
+    """
+    try:
+        from agents import structured
+        structured.invalidate()
+    except Exception:  # noqa: BLE001 — cache invalidation is best-effort
+        pass
+
+
 def _get_model() -> _ModelBundle:
     """Return the loaded model bundle, loading from disk on the first call.
 
@@ -132,6 +157,7 @@ def maybe_evict_idle(idle_s: float | None = None) -> float | None:
             mx, before = None, 0
         _model_cache.clear()
         _tokenizer_cache.clear()
+        _invalidate_dependent_caches()
         gc.collect()
         freed = 0.0
         if mx is not None:
@@ -167,6 +193,7 @@ def evict_resident_model() -> float | None:
             mx, before = None, 0
         _model_cache.clear()
         _tokenizer_cache.clear()
+        _invalidate_dependent_caches()
         gc.collect()
         freed = 0.0
         if mx is not None:

package/services/agents/observability.py

@@ -3,10 +3,9 @@
 A single `setup(agent_name)` call wires up:
 
   * an OTel `TracerProvider` with `service.name=agent_name`
-  * direct OTLP/HTTP export to OpenObserve when `otlp_enabled=true` and
-    credentials are set in `~/.meridian/settings.json` — no Rust daemon needed
-  * spool fallback (`~/.meridian/telemetry/pending/`) when toggle is on but
-    credentials are absent; the Rust daemon drains that directory to OO
+  * export ALWAYS goes through the durable disk spool
+    (`~/.meridian/telemetry/pending/`), never a live HTTP call from this
+    process — see "Spool-only export" below
   * a `LoggerProvider` + matching log handler so every `logging.LogRecord`
     is correlated to the active span via trace_id/span_id
   * W3C `TraceContextTextMapPropagator` as the global propagator so each
@@ -16,10 +15,35 @@ A single `setup(agent_name)` call wires up:
   * a JSON formatter (`python-json-logger`) writing daily-rotated JSONL files
     under `~/.meridian/logs/{agent_name}.jsonl` plus stderr
 
-Export gate: `~/.meridian/settings.json` `otlp_enabled` toggle + OO credentials
-(`oo_email` / `oo_password`). When both are present the Python service ships
-directly to OO — it does NOT depend on the Rust daemon for delivery. The spool
-path is a fallback for when credentials are absent (daemon delivers later).
+Export gate: `~/.meridian/settings.json` `otlp_enabled` toggle. When on, every
+span/log batch is written to the spool (`_write_spool`, an atomic
+tmp-then-rename into `~/.meridian/telemetry/pending/`) — the exact same
+`<signal>-<unix_micros>-<seq>.otlp` layout `src/telemetry_spool/writer.rs`
+produces. Generation (this process) and delivery are fully decoupled:
+
+  * The Rust daemon's `telemetry_spool::shipper` background task drains
+    `pending/` into OpenObserve whenever it's reachable, independent of
+    whether this process is even still running — `ship_one` in
+    `telemetry_spool/mod.rs` classifies failures as Terminal (payload is bad,
+    quarantined) or Retryable (network/5xx/429, retried next tick), so a
+    down or flaky OpenObserve never loses or corrupts anything, it just
+    backs up on disk until OO comes back.
+  * `meridian telemetry export`/`import` (`telemetry_spool/cli.rs`) lets a
+    user hand someone else the pending spool directly (or import one) —
+    the "give a customer's log bundle to support, load it into our own
+    OpenObserve" path this architecture exists for.
+
+This process NEVER opens a live connection to OpenObserve itself. Earlier
+revisions shipped directly via `OTLPSpanExporter`/`OTLPLogExporter` when OO
+credentials were configured in settings.json (skipping the Rust daemon) —
+that meant a long-running process (the MLX server) held live HTTP
+export/retry state against OpenObserve, and when OO went down for hours,
+continuous failed-export retries correlated with the process's memory
+growing from ~100MB to 20+GB. Spool-only export removes that whole failure
+class: writing to disk can't hang, retry-loop, or accumulate connection
+state, and the already-hardened Rust shipper (atomic writes, terminal/
+retryable classification, quarantine) is the only thing that ever talks to
+OpenObserve.
 
 `extract_parent_context(traceparent)` is the helper agents use to continue
 a span emitted by another process — typically the Rust ETL or another
@@ -191,8 +215,9 @@ class SpoolLogExporter:
 
 # ──────────────────────── Config ───────────────────────────────────────────────
 DEFAULT_LOG_DIR = Path.home() / ".meridian" / "logs"
-# Same settings.json the Rust daemon reads. When otlp_enabled=true and
-# oo_email/oo_password are set, Python ships directly to OO (no daemon needed).
+# Same settings.json the Rust daemon reads — only the otlp_enabled toggle
+# matters here now; oo_email/oo_password are read by the Rust shipper, not
+# this process (see the module docstring's "Spool-only export" section).
 _SETTINGS_PATH = Path(
     os.environ.get("MERIDIAN_SETTINGS_PATH")
     or (Path.home() / ".meridian" / "settings.json")
@@ -288,27 +313,11 @@ def extract_parent_context(traceparent: Optional[str]) -> Optional[Context]:
 
 
 # ──────────────────────── Tracing setup ────────────────────────────────────────
-def _oo_otlp_headers() -> dict[str, str]:
-    """Build the Basic-auth header for direct OO OTLP export from settings.json."""
-    import base64
-    s = _load_settings()
-    email = s.get("oo_email") or ""
-    passwd = s.get("oo_password") or ""
-    if not email or not passwd:
-        return {}
-    token = base64.b64encode(f"{email}:{passwd}".encode()).decode()
-    return {"Authorization": f"Basic {token}"}
-
-
-def _oo_otlp_base_url() -> str:
-    """Return the OO OTLP base URL (without /v1/traces or /v1/logs suffix)."""
-    s = _load_settings()
-    endpoint = s.get("otlp_endpoint") or "http://localhost:5080/api/default/v1/traces"
-    # Strip the /v1/traces suffix to get the org-level base used by both signals.
-    for suffix in ("/v1/traces", "/v1/logs"):
-        if endpoint.endswith(suffix):
-            return endpoint[: -len(suffix)]
-    return endpoint.rstrip("/")
+# Spool-only by design — see the module docstring's "Spool-only export"
+# section for why this process never opens a live connection to OpenObserve.
+# `src/telemetry_spool/shipper.rs` (Rust daemon, runs independently) is the
+# only thing that ever ships these bytes to OO; `meridian telemetry export/
+# import` is the manual escape hatch when the daemon isn't running at all.
 
 
 def _configure_tracing(agent_name: str) -> None:
@@ -320,22 +329,11 @@ def _configure_tracing(agent_name: str) -> None:
 
     resource = Resource.create({"service.name": agent_name})
     provider = TracerProvider(resource=resource)
-
-    headers = _oo_otlp_headers()
-    if headers:
-        # Credentials present — ship directly to OO, no Rust daemon dependency.
-        from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-        from opentelemetry.sdk.trace.export import BatchSpanProcessor
-        exporter = OTLPSpanExporter(
-            endpoint=f"{_oo_otlp_base_url()}/v1/traces",
-            headers=headers,
-        )
-        provider.add_span_processor(BatchSpanProcessor(exporter))
-    else:
-        # Credentials absent — spool for the Rust daemon to deliver later.
-        # BatchSpanProcessor avoids blocking inference threads on each span end.
-        provider.add_span_processor(BatchSpanProcessor(SpoolSpanExporter()))
-
+    # BatchSpanProcessor avoids blocking inference threads on each span end;
+    # SpoolSpanExporter itself is a synchronous local file write, so this can
+    # never hang, retry-loop, or accumulate connection state regardless of
+    # whether OpenObserve is reachable.
+    provider.add_span_processor(BatchSpanProcessor(SpoolSpanExporter()))
     trace.set_tracer_provider(provider)
 
 
@@ -351,23 +349,11 @@ def _configure_log_export(agent_name: str) -> Optional[logging.Handler]:
     if not _is_otlp_enabled():
         return None
 
-    headers = _oo_otlp_headers()
     resource = Resource.create({"service.name": agent_name})
     provider = LoggerProvider(resource=resource)
-
-    if headers:
-        # Credentials present — ship directly to OO, no Rust daemon dependency.
-        from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
-        log_exporter = OTLPLogExporter(
-            endpoint=f"{_oo_otlp_base_url()}/v1/logs",
-            headers=headers,
-        )
-    else:
-        # Credentials absent — spool for the Rust daemon to deliver later.
-        log_exporter = SpoolLogExporter()  # type: ignore[assignment]
-
-    # BatchLogRecordProcessor for both paths so log export never blocks callers.
-    provider.add_log_record_processor(BatchLogRecordProcessor(log_exporter))
+    # BatchLogRecordProcessor so log export never blocks callers — see
+    # _configure_tracing above for why SpoolLogExporter is always used.
+    provider.add_log_record_processor(BatchLogRecordProcessor(SpoolLogExporter()))
     set_logger_provider(provider)
     _LOGGER_PROVIDER = provider
     return LoggingHandler(level=logging.NOTSET, logger_provider=provider)
@@ -477,21 +463,6 @@ def current_traceparent() -> Optional[str]:
     return carrier.get("traceparent")
 
 
-def instrument_agno() -> None:
-    """Instrument the agno framework for OpenTelemetry tracing.
-
-    No-op when openinference-instrumentation-agno is not installed; the package
-    is optional and the server must start cleanly without it.
-    """
-    try:
-        from opentelemetry.instrumentation.agno import AgnoInstrumentor  # type: ignore[import]
-        AgnoInstrumentor().instrument()
-    except ImportError:
-        logging.getLogger(__name__).debug(
-            "opentelemetry-instrumentation-agno not installed; agno spans will not be exported"
-        )
-
-
 # Process-level handle so the agno TracerProvider isn't garbage-collected.
 _AGNO_TRACER_PROVIDER = None
 
@@ -601,11 +572,121 @@ def preview(text: Optional[str], max_chars: int = 200) -> str:
     return text[:max_chars] + ("…" if len(text) > max_chars else "")
 
 
+def record_gen_params(
+    span,
+    *,
+    temp: float,
+    max_tokens: int,
+    thinking_budget: int,
+    budget_forced: bool,
+    enable_thinking: bool = True,
+    model: str = "",
+) -> None:
+    """Stamp the generation parameters used for ONE LLM call onto its span.
+
+    Records the per-call sampling settings — the variable ``temp`` plus the
+    shared constants from :mod:`agents.thinking` (top_p / top_k / presence /
+    repetition penalty) — together with the thinking-budget config and whether
+    the hard cap actually fired (``budget_forced``). Call inside the call's main
+    span so every LLM span in the worklog trace shows exactly which parameters
+    produced its output. ``model`` is set only when non-empty (some callers set
+    it earlier on the span themselves).
+    """
+    from agents.thinking import (
+        DEFAULT_TOP_P, DEFAULT_TOP_K, DEFAULT_PRESENCE_PENALTY,
+        DEFAULT_REPETITION_PENALTY,
+    )
+    if model:
+        span.set_attribute("model", model)
+    span.set_attribute("temp", temp)
+    span.set_attribute("top_p", DEFAULT_TOP_P)
+    span.set_attribute("top_k", DEFAULT_TOP_K)
+    span.set_attribute("presence_penalty", DEFAULT_PRESENCE_PENALTY)
+    span.set_attribute("repetition_penalty", DEFAULT_REPETITION_PENALTY)
+    span.set_attribute("thinking_budget", thinking_budget)
+    span.set_attribute("enable_thinking", enable_thinking)
+    span.set_attribute("max_tokens", max_tokens)
+    span.set_attribute("budget_forced", budget_forced)
+
+
+def record_fsm_params(
+    span,
+    *,
+    temp: float,
+    max_tokens: int,
+    schema: str,
+    model: str = "",
+) -> None:
+    """Stamp the ACTUAL decoding config for one FSM (grammar-constrained) JSON call.
+
+    The FSM path (:mod:`agents.structured`) decodes against an outlines logits
+    processor compiled from ``schema`` and samples among the grammar-legal tokens with
+    ``temp`` / ``top_p`` / ``top_k`` (via ``make_sampler``). It runs with thinking OFF
+    and — unlike the thinking path — applies NO presence/repetition penalty (outlines
+    owns ``logits_processors``). This recorder reflects only what is genuinely applied,
+    so the trace never advertises phantom penalties or a thinking budget that don't
+    exist on these calls. Use it (not :func:`record_gen_params`) for the FSM endpoints.
+    """
+    from agents.thinking import DEFAULT_TOP_P, DEFAULT_TOP_K
+
+    if model:
+        span.set_attribute("model", model)
+    span.set_attribute("decoding", "fsm")            # grammar-constrained (outlines)
+    span.set_attribute("grammar_constrained", True)
+    span.set_attribute("fsm_schema", schema)         # the Pydantic output schema enforced
+    span.set_attribute("enable_thinking", False)     # thinking is off for FSM JSON calls
+    span.set_attribute("temp", temp)
+    span.set_attribute("top_p", DEFAULT_TOP_P)
+    span.set_attribute("top_k", DEFAULT_TOP_K)
+    span.set_attribute("max_tokens", max_tokens)
+
+
+def record_llm_io(
+    tracer,
+    prefix: str,
+    *,
+    system_prompt: str,
+    llm_input: str,
+    llm_output: str,
+    input_tokens: Optional[int] = None,
+    output_tokens: Optional[int] = None,
+    think_tokens: Optional[int] = None,
+    max_input_chars: int = 8000,
+    max_output_chars: int = 8000,
+) -> None:
+    """Emit the three `<prefix>.prompt` / `.input` / `.output` child spans that
+    OpenObserve renders as dedicated Prompt / Input / Output panels.
+
+    This is the same shape the ``activity_report`` endpoint uses, so every LLM
+    call in the worklog trace (classify / propose / generate) is debuggable the
+    same way: the exact system prompt, the exact user content, and the raw model
+    output — plus token counts on the output span. Call this INSIDE the call's
+    main span so the three land as its children.
+    """
+    with tracer.start_as_current_span(f"{prefix}.prompt") as sp:
+        sp.set_attribute("total_chars", len(system_prompt or ""))
+        sp.set_attribute("llm_input", preview(system_prompt, max_chars=max_input_chars))
+    with tracer.start_as_current_span(f"{prefix}.input") as sp:
+        sp.set_attribute("total_chars", len(llm_input or ""))
+        sp.set_attribute("llm_input", preview(llm_input, max_chars=max_input_chars))
+    with tracer.start_as_current_span(f"{prefix}.output") as sp:
+        sp.set_attribute("total_chars", len(llm_output or ""))
+        sp.set_attribute("llm_output", preview(llm_output, max_chars=max_output_chars))
+        if input_tokens is not None:
+            sp.set_attribute("input_tokens", input_tokens)
+        if output_tokens is not None:
+            sp.set_attribute("output_tokens", output_tokens)
+        if think_tokens is not None:
+            sp.set_attribute("think_tokens", think_tokens)
+
+
 __all__ = [
     "setup",
     "extract_parent_context",
-    "instrument_agno",
     "setup_agno_tracing",
     "current_traceparent",
     "preview",
+    "record_gen_params",
+    "record_fsm_params",
+    "record_llm_io",
 ]

package/services/agents/prompts/activity_report.py

@@ -1,7 +1,8 @@
 """System prompt for the activity reporter.
 
-Produces a structured activity report from distilled screen-capture data.
-Format: TLDR + Core Tasks + Decisions + Resources.
+Produces ONE consolidated activity report from the hour's distilled screen-capture
+data AND any coding-agent session summaries (woven into the same story, not a
+separate section). Format: TLDR + Core Tasks + Decisions + Resources.
 """
 from __future__ import annotations
 
@@ -39,6 +40,8 @@ List documentation pages, repos, articles, videos, dashboards, or other material
 ---
 
 RULES
+- CONSOLIDATE everything into ONE story. Coding-agent sessions are NOT a separate task or section — weave them into the same work threads as the screen activity. If a coding-agent session and the screen capture describe the same work (same files, same feature, same ticket), MERGE them into a single thread; do not double-count or list "coding agent work" on its own.
+- PRESERVE concrete identifiers verbatim — ticket keys (e.g. KAN-241), file paths, function names, PR numbers, branch-independent specifics. A downstream matcher needs these to bind the work to a ticket; never genericize or drop them.
 - Infer the PURPOSE, not just the activity. If the screen shows edits to a prompt file + model test runs, say what the developer was trying to improve and why — not just "edited prompt file and ran tests."
 - Extract identifiable specifics: system names, service names, model names, tool names — anything that helps a matcher connect this to a ticket.
 - Do not make up facts, numbers, or names not present in the input.

package/services/agents/routes/activity.py

@@ -11,11 +11,12 @@ import logging
 
 from fastapi import APIRouter, HTTPException
 from opentelemetry import trace
-from opentelemetry.trace import Link
+from opentelemetry.context import context as _otel_context
 from pydantic import BaseModel
 
 from agents import observability
 from agents._state import app_state, model_sem
+from agents.thinking import generate_thinking, DEFAULT_PROSE_TEMP, DEFAULT_THINKING_BUDGET
 
 log = logging.getLogger("agents.server")
 
@@ -25,11 +26,11 @@ _ACTIVITY_REPORT_MAX_TOKENS = 16384   # budget for <think> block + answer
 
 
 class _ActivityReportRequest(BaseModel):
-    body:        str
+    body:        str    # the full consolidated input (distilled OCR + coding sessions)
     label:       str
-    db_path:     str | None = None
     max_tokens:  int = _ACTIVITY_REPORT_MAX_TOKENS
     traceparent: str | None = None
+    enable_thinking: bool = True  # set False to disable thinking mode for comparison
 
 
 class _ActivityReportResponse(BaseModel):
@@ -40,63 +41,15 @@ class _ActivityReportResponse(BaseModel):
     elapsed_s:     float
 
 
-def _fetch_coding_summaries(db_path: str, label: str) -> str:
-    """Return a formatted block of coding-agent session summaries for the given local hour label.
-
-    Queries app_sessions for Claude Code / Codex / Copilot / Cursor rows whose
-    started_at or ended_at overlaps the local hour, using the same UTC-range
-    conversion as session_distiller so the label always means local time.
-    Returns an empty string if none found or db_path is None.
-    """
-    import sqlite3
-    from datetime import datetime, timedelta, timezone
-
-    try:
-        local_tz = datetime.now().astimezone().tzinfo
-        local_start = datetime.strptime(label, "%Y-%m-%dT%H").replace(tzinfo=local_tz)
-        utc_start = local_start.astimezone(timezone.utc)
-        utc_end   = (local_start + timedelta(hours=1)).astimezone(timezone.utc)
-        utc_start_s = utc_start.strftime("%Y-%m-%dT%H:%M:%S")
-        utc_end_s   = utc_end.strftime("%Y-%m-%dT%H:%M:%S")
-
-        conn = sqlite3.connect(db_path)
-        rows = conn.execute("""
-            SELECT app_name, started_at, ended_at, session_summary
-            FROM app_sessions
-            WHERE app_name IN ('Claude Code', 'Codex', 'GitHub Copilot', 'Cursor Agent')
-              AND task_method = 'summarised'
-              AND session_summary IS NOT NULL
-              AND (
-                  (started_at >= ? AND started_at < ?)
-                  OR (ended_at  >= ? AND ended_at  < ?)
-              )
-            ORDER BY started_at
-        """, (utc_start_s, utc_end_s, utc_start_s, utc_end_s)).fetchall()
-        conn.close()
-    except Exception as exc:  # noqa: BLE001
-        log.warning("activity_report: could not fetch coding summaries: %s", exc)
-        return ""
-
-    if not rows:
-        return ""
-
-    lines = [f"\n---\n\n## Coding Agent Sessions ({len(rows)} session{'s' if len(rows) != 1 else ''})\n"]
-    for app_name, started_at, ended_at, summary in rows:
-        lines.append(f"### [{app_name}] {started_at[:16]} – {ended_at[:16]}")
-        lines.append(summary.strip())
-        lines.append("")
-    return "\n".join(lines)
-
-
 @router.post("/activity_report", response_model=_ActivityReportResponse)
 async def activity_report(req: _ActivityReportRequest) -> _ActivityReportResponse:
     """Human-readable worklog entry from distilled session body.
 
-    Uses Qwen3.5-2B in thinking mode (enable_thinking=True, thinking_budget=4096)
-    with repetition_penalty=1.1 and presence_penalty=1.5 to prevent output loops.
-    The thinking budget caps the <think> block so it doesn't consume the full
-    max_tokens window. The <think> block is stripped — only the final answer is
-    returned. Token counts are from the model's own generation response.
+    Uses the shared agents.thinking.generate_thinking (unified sampling +
+    thinking-budget enforcement). The thinking-budget processor caps the <think>
+    block so it can't consume the whole max_tokens window; the block is stripped
+    and only the final markdown answer is returned. req.enable_thinking=False
+    disables reasoning entirely (for comparison). Token counts are the model's own.
     """
     from fastapi.concurrency import run_in_threadpool
     import time as _time
@@ -111,75 +64,18 @@ async def activity_report(req: _ActivityReportRequest) -> _ActivityReportRespons
 
     from agents.prompts.activity_report import SYSTEM as _AR_SYSTEM
 
+    # The caller (worklog_pipeline.stage_report) sends the FULL consolidated input —
+    # distilled OCR + labeled coding-agent sessions — so this endpoint just runs it.
     body = req.body
-    if req.db_path:
-        coding_block = _fetch_coding_summaries(req.db_path, req.label)
-        if coding_block:
-            body = body + coding_block
-            log.info("activity_report: appended %d coding-summary chars", len(coding_block))
-
     messages = [
         {"role": "system", "content": _AR_SYSTEM},
         {"role": "user",   "content": body},
     ]
 
-    def _generate() -> tuple[str, int, int, int]:
-        """Returns (report_markdown, input_tokens, output_tokens, think_tokens).
-
-        Uses the server's already-loaded model (model.model is the raw MLX net;
-        m._get_tokenizer() is the HF tokenizer with Qwen3.5 chat template).
-        enable_thinking=True requires the HF tokenizer's apply_chat_template, not
-        outlines' Chat() shim, so we call mlx_lm.generate directly.
-        """
-        from mlx_lm import generate
-        from mlx_lm.sample_utils import make_sampler, make_logits_processors
-
-        sampler = make_sampler(temp=1.0, top_p=0.95, top_k=20)
-        logits_processors = make_logits_processors(
-            repetition_penalty=1.1,
-            repetition_context_size=64,
-            presence_penalty=1.5,
-        )
-        hf_tokenizer = m._get_tokenizer()
-        prompt_ids = hf_tokenizer.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            enable_thinking=True,
-            thinking_budget=8192,
-        )
-        # A fresh HF tokenizer returns a BatchEncoding ({input_ids, attention_mask});
-        # the mlx_lm wrapper returns a plain token list. generate() needs the list.
-        if hasattr(prompt_ids, "keys") and "input_ids" in prompt_ids:
-            prompt_ids = prompt_ids["input_ids"]
-        input_tokens = len(prompt_ids)
-
-        with m.model_session() as model:
-            raw = generate(
-                model.model, hf_tokenizer,
-                prompt=prompt_ids,
-                max_tokens=req.max_tokens,
-                sampler=sampler,
-                logits_processors=logits_processors,
-                verbose=False,
-            )
-
-        # Strip <think>…</think> block; count its tokens
-        think_tokens = 0
-        if "</think>" in raw:
-            think_part, answer = raw.split("</think>", 1)
-            think_tokens = len(hf_tokenizer.encode(think_part + "</think>"))
-            raw = answer.strip()
-
-        output_tokens = len(hf_tokenizer.encode(raw))
-        return raw, input_tokens, output_tokens, think_tokens
-
-    _links = []
-    if _parent_ctx is not None:
-        _parent_span_ctx = trace.get_current_span(_parent_ctx).get_span_context()
-        if _parent_span_ctx and _parent_span_ctx.is_valid:
-            _links = [Link(_parent_span_ctx)]
-
-    with tracer.start_as_current_span("activity_report", links=_links) as span:
+    with tracer.start_as_current_span(
+        "activity_report",
+        context=_parent_ctx if _parent_ctx is not None else _otel_context.Context(),
+    ) as span:
         span.set_attribute("gen_ai.operation.name", "chat")
         span.set_attribute("gen_ai.system",         "mlx")
         span.set_attribute("distil_label", req.label)
@@ -204,7 +100,13 @@ async def activity_report(req: _ActivityReportRequest) -> _ActivityReportRespons
 
         try:
             async with model_sem():
-                report, input_tokens, output_tokens, think_tokens = await run_in_threadpool(_generate)
+                _res = await run_in_threadpool(
+                    generate_thinking, m, messages,
+                    max_tokens=req.max_tokens, enable_thinking=req.enable_thinking,
+                    json_mode=False, temp=DEFAULT_PROSE_TEMP)
+            report = _res.text
+            input_tokens, output_tokens, think_tokens = (
+                _res.input_tokens, _res.output_tokens, _res.think_tokens)
         except Exception as exc:  # noqa: BLE001
             span.set_status(trace.StatusCode.ERROR, str(exc))
             log.error(
@@ -220,6 +122,10 @@ async def activity_report(req: _ActivityReportRequest) -> _ActivityReportRespons
         span.set_attribute("think_tokens",  think_tokens)
         span.set_attribute("output_chars",  len(report))
         span.set_attribute("elapsed_s",     elapsed)
+        observability.record_gen_params(
+            span, temp=DEFAULT_PROSE_TEMP, max_tokens=req.max_tokens,
+            thinking_budget=DEFAULT_THINKING_BUDGET, budget_forced=_res.budget_forced,
+            enable_thinking=req.enable_thinking)
         span.set_attribute("is_error",      False)
 
         # Span 3: model output — llm_output → OO renders as dedicated "Output" panel