@miller-tech/uap 1.129.0 → 1.129.2

package/docs/reference/CLI.md

@@ -557,7 +557,7 @@ Aliased as `dash`.
 | `agents` | `-v` | Agent activity, resource claims, coordination status |
 | `memory` | `-v` | Memory system health, capacity, layer architecture |
 | `progress` | `-v` | Completion tracking per-priority and per-type |
-| `serve` | `-p, --port` (3847) | Start the web-based dashboard server with live updates |
+| `serve` | `-p, --port` (3847), `--host`, `--refresh <seconds>` (2) | Start the web-based dashboard server with live updates; `--refresh` sets the snapshot push/poll cadence (min 0.25s, env `UAP_DASH_REFRESH_MS`) |
 | `stats` | `-v` | Session context consumption stats with per-tool breakdown |
 | `session` | `-v`, `--compact` | Live UAP session state: infra, patterns, skills, git, policies |
 | `benchmark` | `-v` | Benchmark results and performance comparison |

package/docs/reference/CONFIGURATION.md

@@ -91,6 +91,7 @@ Top level: `version`, `project`, `memory`, `worktree`, `costOptimization`,
 | `UAP_BENCHMARK_PARALLEL` | Parallel model count in benchmarks | — |
 | `UAP_SNAPSHOT_DIR` | Base dir for `--keep-best` snapshots (absolute path) | `~/.cache/uap/snapshots` |
 | `UAP_SNAPSHOT_MAX_MB` | Skip the `--keep-best` snapshot (rollback disabled) when the tree exceeds this size | `4096` |
+| `UAP_DASH_REFRESH_MS` | Dashboard live snapshot push/poll interval in ms (`--refresh` flag wins; min 250) | `2000` |
 | `HERMES_HOME` | Hermes home dir | `~/.hermes` |
 | `FACTORY_PROJECT_DIR` | Project dir in Factory hook commands | — |
 | `FORGE_UAP_PROJECT` | Project dir in ForgeCode hook scripts | `.` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.129.0",
+  "version": "1.129.2",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
     "start": "node dist/bin/cli.js",
     "test": "vitest",
     "test:ci": "vitest run",
-    "test:enforcers": "python3 -m unittest tools.agents.tests.test_enforcement_self_protect tools.agents.tests.test_workdir_scope_enforcer tools.agents.tests.test_path_containment tools.agents.tests.test_path_normalizer_hardened tools.agents.tests.test_sandbox_tool_strip tools.agents.tests.test_proxy_env_loader tools.agents.tests.test_stream_required_tool tools.agents.tests.test_tool_call_wrapper_profiles tools.agents.tests.test_tool_convert_cache",
+    "test:enforcers": "python3 -m unittest tools.agents.tests.test_enforcement_self_protect tools.agents.tests.test_schema_diff_gate tools.agents.tests.test_stream_telemetry tools.agents.tests.test_workdir_scope_enforcer tools.agents.tests.test_path_containment tools.agents.tests.test_path_normalizer_hardened tools.agents.tests.test_sandbox_tool_strip tools.agents.tests.test_proxy_env_loader tools.agents.tests.test_stream_required_tool tools.agents.tests.test_tool_call_wrapper_profiles tools.agents.tests.test_tool_convert_cache",
     "test:coverage": "vitest --coverage",
     "bench": "vitest --config vitest.bench.config.ts",
     "lint": "eslint src --ext .ts",

package/tools/agents/scripts/anthropic_proxy.py

@@ -8954,6 +8954,12 @@ async def stream_anthropic_response(
     text_chunks: list[str] = []  # accumulate text for logging
     reasoning_chunks: list[str] = []  # accumulate reasoning for fallback
 
+    # Real token counts from upstream's final usage chunk (llama-server /
+    # OpenAI emit it on the last data frame). The per-delta output_tokens
+    # counter is a chunk count that misses tool-call deltas entirely; prefer
+    # upstream truth for telemetry and the session monitor.
+    upstream_usage: dict = {}
+
     try:
         async for line in openai_stream.aiter_lines():
             if not line.startswith("data: "):
@@ -8966,6 +8972,9 @@ async def stream_anthropic_response(
             except json.JSONDecodeError:
                 continue
 
+            if isinstance(chunk.get("usage"), dict):
+                upstream_usage = chunk["usage"]
+
             choice = (chunk.get("choices") or [{}])[0]
             delta = choice.get("delta", {})
 
@@ -9239,6 +9248,28 @@ async def stream_anthropic_response(
     # message_stop
     yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
 
+    # Per-project telemetry for the TRUE streaming path. The only other call
+    # sites are on the non-stream / guarded-non-stream paths, so streaming
+    # sessions (the client default) wrote no task_outcomes rows and
+    # per-project dashboards froze at the last non-stream response.
+    # Prefer upstream's real usage: last_input_tokens is a char-based request
+    # estimate, and the per-delta counter misses tool-call turns entirely.
+    upstream_input = int(upstream_usage.get("prompt_tokens") or 0)
+    if upstream_input > 0:
+        monitor.last_input_tokens = upstream_input
+    usage_final = {
+        "input_tokens": upstream_input or getattr(monitor, "last_input_tokens", 0) or 0,
+        "output_tokens": int(upstream_usage.get("completion_tokens") or 0) or output_tokens,
+    }
+    # After message_stop (never delays the client's final frame; a disconnect
+    # parked exactly on that yield skips recording, matching the non-stream
+    # "completed responses only" semantics) and off the event loop (a locked
+    # analytics DB must not stall token delivery for concurrent sessions).
+    try:
+        await asyncio.to_thread(_record_project_telemetry, anthropic_body, model, usage_final)
+    except Exception:
+        pass
+
 
 # ===========================================================================
 # API Endpoints

package/tools/agents/tests/test_stream_telemetry.py

@@ -0,0 +1,82 @@
+"""The TRUE streaming path must record per-project telemetry.
+
+Regression for the frozen-dashboard incident (2026-07-08): the only
+_record_project_telemetry call sites were on the non-stream / guarded
+non-stream paths, so streaming sessions (the client default) wrote no
+task_outcomes rows and per-project dashboards showed static data forever.
+"""
+import asyncio
+import importlib.util
+import unittest
+from pathlib import Path
+
+proxy_path = Path(__file__).resolve().parents[1] / "scripts" / "anthropic_proxy.py"
+spec = importlib.util.spec_from_file_location("anthropic_proxy", proxy_path)
+ap = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(ap)
+
+
+class FakeOpenAIStream:
+    """Minimal httpx.Response stand-in: yields OpenAI SSE lines."""
+
+    def __init__(self, lines):
+        self._lines = lines
+
+    async def aiter_lines(self):
+        for line in self._lines:
+            yield line
+
+    async def aclose(self):
+        pass
+
+
+OPENAI_LINES = [
+    'data: {"choices": [{"delta": {"content": "hello"}, "finish_reason": null}]}',
+    'data: {"choices": [{"delta": {}, "finish_reason": "stop"}], "usage": {"prompt_tokens": 456, "completion_tokens": 5}}',
+    "data: [DONE]",
+]
+
+
+class StreamTelemetryTest(unittest.TestCase):
+    def _drive(self, body):
+        monitor = ap.SessionMonitor()
+        monitor.last_input_tokens = 123
+        recorded = []
+        saved = ap._record_project_telemetry
+        ap._record_project_telemetry = lambda b, m, u: recorded.append((b, m, u))
+        try:
+            gen = ap.stream_anthropic_response(
+                FakeOpenAIStream(OPENAI_LINES), "test-model", monitor, body
+            )
+
+            async def consume():
+                return [frame async for frame in gen]
+
+            frames = asyncio.run(consume())
+        finally:
+            ap._record_project_telemetry = saved
+        return frames, recorded
+
+    def test_streaming_response_records_project_telemetry(self):
+        body = {"messages": [{"role": "user", "content": "hi"}]}
+        frames, recorded = self._drive(body)
+        self.assertTrue(any("message_stop" in f for f in frames))
+        self.assertEqual(len(recorded), 1)
+        recorded_body, model, usage = recorded[0]
+        self.assertIs(recorded_body, body)
+        self.assertEqual(model, "test-model")
+        # Upstream's final usage chunk wins over the request-side estimate and
+        # the per-delta chunk counter (which misses tool-call turns).
+        self.assertEqual(usage.get("input_tokens"), 456)
+        self.assertEqual(usage.get("output_tokens"), 5)
+
+    def test_telemetry_recorded_after_client_visible_stream_end(self):
+        # The recorder must not delay or reorder client frames: message_stop is
+        # emitted before the telemetry write happens.
+        frames, recorded = self._drive({"messages": []})
+        self.assertIn("message_stop", frames[-1])
+        self.assertEqual(len(recorded), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/web/dashboard.html

@@ -629,6 +629,9 @@
       // page is opened without the server substitution (mutations then 401).
       const DASHBOARD_TOKEN = '__UAP_DASHBOARD_TOKEN__'.startsWith('__UAP') ? '' : '__UAP_DASHBOARD_TOKEN__';
       const MUTATION_HEADERS = { 'X-Uap-Dashboard-Token': DASHBOARD_TOKEN };
+      // Server-injected push cadence (uap dash serve --refresh); the fallback
+      // poll below matches it. 2000 when opened without server substitution.
+      const REFRESH_MS = Number('__UAP_DASH_REFRESH_MS__') > 0 ? Number('__UAP_DASH_REFRESH_MS__') : 2000;
       let ws = null;
       let reconnectTimer = null;
       let reconnectDelay = 1000;
@@ -1281,7 +1284,7 @@
       setInterval(async()=>{
         if(ws&&ws.readyState===WebSocket.OPEN)return;
         try{const r=await fetch(API_URL+'/api/dashboard');if(!r.ok)return;const d=await r.json();if(d)render(d);document.getElementById('ws-status').className='status-dot polling';document.getElementById('refresh-info').textContent='Polling - '+new Date().toLocaleTimeString();document.title='UAP Dashboard - Polling';}catch{}
-      }, 2000);
+      }, REFRESH_MS);
 
       // Resize: re-init charts
       let resizeT;