@matt82198/aesop 0.1.0-beta.4 → 0.1.0-beta.5

package/tools/verify_submit_encoding.py

@@ -57,6 +57,14 @@ def build_fixture(root: Path):
     (root / "state").mkdir(exist_ok=True)
     (root / "transcripts").mkdir(exist_ok=True)
     (root / "dash").mkdir(exist_ok=True)
+
+    # Copy ui/web/dist from the real repo so the server can serve the built React app
+    repo = Path(__file__).resolve().parent.parent
+    real_dist = repo / "ui" / "web" / "dist"
+    if real_dist.is_dir():
+        fixture_dist = root / "ui" / "web" / "dist"
+        shutil.copytree(real_dist, fixture_dist)
+
     (root / "AUDIT-BACKLOG.md").write_text(
         "# Audit backlog — verify_submit_encoding fixture\n\n## Landing log\n- fixture\n",
         encoding="utf-8",
@@ -142,11 +150,11 @@ def main():
             page = browser.new_page()
             page.goto(f"http://127.0.0.1:{port}/", wait_until="domcontentloaded")
 
-            # Drive the real /submit flow: #inbox-input -> #inbox-button, real
+            # Drive the real /submit flow: inbox-input -> inbox-submit, real
             # CSRF token (window.__AESOP_CSRF_TOKEN__ injected server-side).
-            page.wait_for_selector("#inbox-input", timeout=8000)
-            page.fill("#inbox-input", MARKER)
-            page.click("#inbox-button")
+            page.wait_for_selector("[data-testid='inbox-input']", timeout=8000)
+            page.fill("[data-testid='inbox-input']", MARKER)
+            page.click("[data-testid='inbox-submit']")
 
             # Wait for the inbox file to land on disk (async POST).
             for _ in range(50):

package/ui/CLAUDE.md

@@ -2,28 +2,48 @@
 
 **Purpose**: Stdlib-only local observability dashboard. Serves a dark-theme HTML dashboard on a configurable port (realtime via Server-Sent Events), enabling real-time fleet monitoring without external dependencies.
 
-## Files (wave-9 split: serve.py monolith decomposed into focused modules)
+## Files (wave-14 U9 cutover: new React+Vite app structure)
 
+**Backend (Python, unchanged from wave-9 split)**:
 - **serve.py** — Thin (~65-line) entry point + composition layer. Wires the sibling modules, calls `config.reload()` / `csrf.init()` / `sse.reset_state()`, and re-exports their symbols so `serve.X` keeps resolving for the test suite (which loads serve.py by path) and for `python ui/serve.py`.
-- **config.py** — Path / env / `aesop.config.json` resolution. `reload()` recomputes all path globals from the current environment. **Load-bearing rule: every other module reads `config.X` at call time (`import config`), never `from config import <path>` — a frozen import would go stale after reload() (breaks test-fixture isolation).**
+- **config.py** — Path / env / `aesop.config.json` resolution. `reload()` recomputes all path globals from the current environment. **Load-bearing rule: every other module reads `config.X` at call time (`import config`), never `from config import <path>` — a frozen import would go stale after reload() (breaks test-fixture isolation).** Added in wave-14: `WEB_DIST` path pointing to `ui/web/dist/`.
 - **csrf.py** — Session-token generation (atomic O_EXCL 0600) + `validate_csrf_request()`; `init()` sets `SESSION_TOKEN`.
 - **collectors.py** — Read-only data collectors (heartbeats, repos, events, alerts, messages, backlog parse), tracker CRUD, and SSE section snapshots (incl. `read`-style tracker/orchestrator-status snapshots + inbox drain).
 - **agents.py** — Agent transcript reading (`get_fleet_agents`, `extract_agent_dispatch_prompt`) and path-traversal-safe agent-id handling (`_AGENT_ID_FORBIDDEN`).
-- **sse.py** — SSE client registry, bounded broadcast, hash-gated `_maybe_emit`, and the background `collector_loop`. `reset_state()` restores per-import collector isolation (the `sse` module is cached across test re-imports).
-- **render.py** — Renders `templates/dashboard.html`, substituting the CSRF token via a unique sentinel (no `.format`/% — the CSS/JS is full of `{}`/`%`).
-- **handler.py** — `DashboardHandler` (HTTP routing + all GET/POST endpoints incl. /api/tracker) and `run_server()`. Reads `config.X` / `csrf.SESSION_TOKEN` at call time.
-- **templates/dashboard.html** — The dashboard HTML/CSS/JS (extracted from the serve.py string), incl. tracker panel + orchestrator-status panel + audit-cycle ASCII banner.
-- **README.md** — User guide and configuration reference.
-
-## API Package (ui/api/)
-
-Shared mutation-request validation and domain-logic handlers (wave-10 split from handler.py). Every mutating endpoint (`/submit`, `POST /api/tracker`, `POST /api/tracker/<id>`) gates requests identically: CSRF token validation, Content-Length bounds-check, then JSON decode. This module centralizes those gates so they are directly unit-testable without HTTP coupling.
-
-- **__init__.py** — Shared mutation gate (`validate_mutation()`). Performs CSRF validation + Content-Length bounds-check (10 KB cap) + JSON decode. Returns `(True, parsed_json)` on success or `(False, (status_code, error_dict))` on gate failure. **Load-bearing rule**: callers must bound the socket read using the same Content-Length header before invoking, to prevent DoS; MAX_BODY_BYTES is re-derived here for validation but socket read is caller's responsibility.
-- **submit.py** — Inbox-append logic (`append_to_inbox(text)`). Appends one timestamped line to `config.INBOX_FILE`, rejects symlinks (TOCTOU defense), creates file with header if missing.
-- **tracker.py** — Tracker CRUD handlers (`list_items()`, `create()`, `update()`, `delete()`). Calls `collectors` tracker functions; returns `(status_code, response_dict)` for direct HTTP response writing. **Load-bearing**: all tracker mutations pass through `validate_mutation()` in create; update/delete check CSRF via `csrf.validate_csrf_request()` performed by caller before path is parsed.
-
-**Key invariant**: All three modules read `config.X` live via `import config` at call time, never `from config import X`. A frozen import goes stale after `config.reload()` (breaks test-fixture isolation). See ui/CLAUDE.md "load-bearing rule" note above.
+- **sse.py** — SSE client registry, bounded broadcast, hash-gated `_maybe_emit`, and the background `collector_loop`. `reset_state()` restores per-import collector isolation (the `sse` module is cached across test re-imports). Extended in wave-14: emits "cost" as a 6th SSE section.
+- **render.py** — Renders `ui/web/dist/index.html` (wave-14 U9 cutover: no fallback), substituting the CSRF token via a unique sentinel (the sentinel persists through Vite's build). Requires `template_path` parameter; legacy fallback removed.
+- **handler.py** — `DashboardHandler` (HTTP routing + all GET/POST endpoints incl. /api/tracker) and `run_server()`. Wave-14 additions: static serving (`GET /assets/*` from `ui/web/dist/assets/`), `/api/state` consolidated snapshot, `/api/session` for Vite dev server, `/api/cost` scorecard. Reads `config.X` / `csrf.SESSION_TOKEN` at call time.
+- **cost.py** — Parser for `state/ledger/OUTCOMES-LEDGER.md` (markdown table); returns per-model and per-day aggregates, verdict scorecards, and optional dollar estimates (only if `aesop.config.json` supplies `pricing` map).
+
+## State Store Integration (Wave-15)
+
+The tracker uses a **dual-path mutation model** backed by an event-sourced SQLite WAL store:
+
+- **Write path**: Mutations append events to `tracker_events.db` (WAL mode) via the StateAPI layer (`state_store/api.py`). Each mutation (create/update/delete) produces an immutable event in the event log.
+- **Read path**: `tracker.json` is re-rendered as an export (projection) from the event log on every read. This export is committed to git for checkpoint durability.
+- **Location**: `state/tracker_events.db` (SQLite WAL, never committed). `tracker.json` (rendered export, committed).
+- **Render-failure recovery**: If projection rendering fails, the UI falls back to the last-known good `tracker.json`; no data loss. Stale renders are repaired on the next successful mutation (idempotent re-render).
+
+This design provides:
+- **Durable event audit trail** (append-only events in WAL)
+- **Git-friendly checkpoints** (rendered tracker.json snapshots)
+- **Atomic mutations** (events append, projection re-renders)
+- **Graceful degradation** (fallback to last-known-good on render failure)
+
+**Frontend (React 18 + Vite + TypeScript, wave-14 U1–U8)**:
+- **ui/web/** — Complete React application (TypeScript, Vite, TypeScript strict mode).
+  - **src/main.tsx** — Vite entry point; renders `<App />` to `#root`.
+  - **src/App.tsx** — App shell: header + hash-routed view slots (/#/, /#/work, /#/activity, /#/cost).
+  - **src/styles/tokens.css** + **src/styles/global.css** — Design tokens (light/dark color palettes, spacing, typography) + base resets.
+  - **src/views/** — Page-level components (Overview, Work, Activity, Cost) with SSE bindings.
+  - **src/components/** — Reusable UI components (HealthHeader, AgentsPanel, TrackerBoard, Timeline, CostChart, etc.).
+  - **src/lib/api.ts** — Typed fetch helpers + CSRF header injection + `/api/session` fallback for dev server.
+  - **src/lib/useSSE.ts** — EventSource hook with reconnect logic, per-section state, connection status.
+  - **src/lib/types.ts** — TypeScript types for all API payloads (contract with backend).
+  - **src/lib/sanitizeUrl.ts** — XSS-safe URL parsing (PR links inert on bad schemes).
+  - **vite.config.ts** — Vite config with API proxy for `/data`, `/api`, `/events`, `/agent`, `/submit` to :8770.
+  - **dist/** — Built static files (committed to git; served by Python handler). Filenames are content-hashed by Vite.
+- **README.md** — User guide and configuration reference (updated for wave-14).
 
 ## Configuration & Path Precedence
 
@@ -62,43 +82,39 @@ Configuration is resolved in this order (first match wins):
 - CLI tools read token from `state/.ui-session-token` (0600) to submit to /submit endpoint
 - Legitimate browser clients: token injected into HTML template, sent by JavaScript
 
+## API Endpoints (wave-14 wave additions)
+
+**Read-only (no CSRF required)**:
+- `GET /` — Renders `ui/web/dist/index.html` with CSRF token substituted (hard 500 if dist missing).
+- `GET /assets/*` — Static files from `ui/web/dist/assets/` (content-hashed, immutable cache headers, path-traversal-safe).
+- `GET /api/state` — Consolidated first-paint snapshot: `{data, backlog, agents, tracker, status, cost}` in one round trip (reuses latest snapshots).
+- `GET /api/session` — Returns `{token}` for Vite dev server; Origin-checked fail-closed (only local origins).
+- `GET /api/cost` — Cost/scorecard summary from `state/ledger/OUTCOMES-LEDGER.md` (per-model, per-day, verdicts, optional pricing estimates).
+- `GET /events` — Server-Sent Events stream (read-only, no CSRF).
+
+**Mutations (CSRF-gated)**:
+- `POST /submit` — Append to inbox.
+- `POST /api/tracker`, `POST /api/tracker/<id>` — Tracker CRUD.
+
 ## Server-Sent Events (SSE) Model
 
 **Realtime streaming via GET /events**:
 - ThreadingHTTPServer required (SSE holds one connection per client)
-- Streams JSON frames: `event: data|backlog|agents` / `data: <json>`
+- Streams JSON frames: `event: <section>` / `data: <json>`
 - Keepalive comment-line (`: keepalive`) sent every ~15s to prevent timeout
 - Read-only stream; no mutations
 
-**Sections emitted** (only on content change):
+**Sections emitted** (only on content change, in order):
 1. **data** — heartbeat status, daemon state, log tail
 2. **backlog** — AUDIT-BACKLOG.md parsed into tier buckets (P0/P1/P2/Needs decision)
 3. **agents** — fleet agent activity (from Claude transcripts directory)
+4. **tracker** — tracker items (CRUD mutations reflected in realtime)
+5. **status** — orchestrator phase + activity
+6. **cost** — cost/scorecard summary (wave-14 addition)
 
 ## Background Collector Thread
 
-**Lifecycle**:
-- Started idempotently on first HTTP request (via `start_collector_thread()`)
-- Runs as daemon thread (terminates when main process exits)
-- Single-instance guard via `_collector_lock` (prevents double-start)
-
-**Polling strategy**:
-- Wakes every `COLLECTOR_INTERVAL` seconds (default: 1.0, overridable via `AESOP_UI_COLLECT_INTERVAL`)
-- Polls cheap sources: heartbeat file mtimes, log tails, file fingerprints
-- Only re-derives sections when underlying input changed (mtime/fingerprint gate)
-- Only emits to clients when section content-hash changed (avoids redundant broadcasts)
-
-**Cached data**:
-- Last computed hash per section (data/backlog/agents)
-- Last mtime of AUDIT-BACKLOG.md
-- Last fingerprint of transcripts directory (to detect agent activity changes)
-- Cached parsed backlog and agent snapshot (reused until inputs change)
-
-**Content-change detection**:
-- Mtime-gated: backlog section re-derived only if AUDIT-BACKLOG.md mtime changed
-- Fingerprint-gated: agents section re-derived only if transcripts directory content changed
-- Hash-gated: broadcast only sent if content-hash differs from last broadcast
-- This avoids expensive operations (subprocess for dash-extra.mjs, directory walk) on every tick
+Daemon thread polling heartbeats/logs via mtime/fingerprint gates; re-derives SSE sections only on input change, broadcasts only when content-hash differs (avoids expensive operations on every tick). Started idempotently on first HTTP request via `start_collector_thread()`, runs with single-instance guard `_collector_lock`, wakes every `COLLECTOR_INTERVAL` (default 1.0s, `AESOP_UI_COLLECT_INTERVAL`).
 
 ## Invariants & Gotchas
 

package/ui/agents.py

@@ -55,7 +55,7 @@ _AGENT_ID_FORBIDDEN = re.compile(r'\.\.|[/\\*?\[\]]')
 
 def extract_agent_dispatch_prompt(agent_id):
     """
-    Extract dispatch prompt and metadata from agent output file.
+    Extract dispatch prompt and metadata from agent jsonl transcript.
     Returns dict with prompt, dispatcher, model, activity times, and message count.
     Robust: missing/invalid file -> {error: "..."}
     Security: rejects agent_id containing path-traversal or glob-metacharacter
@@ -64,20 +64,24 @@ def extract_agent_dispatch_prompt(agent_id):
     carry "invalid": True when the input itself was rejected, so callers can
     map that to an HTTP 400 rather than a plain 404.
 
-    CRITICAL: Use prefix-matching via glob, not exact match. The dashboard supplies
-    truncated agent IDs; files on disk carry full IDs (e.g., a77b995bcdb953e9c.output).
+    CRITICAL: Use prefix-matching via glob, not exact match. The dashboard (dash-extra.mjs)
+    scans for agent-*.jsonl files and emits a 13-char truncated ID; files on disk carry
+    full IDs (e.g., agent-a77b995bcdb953e9c1234567.jsonl). This function must search for
+    the same file format that the dashboard actually finds.
     """
     try:
         if not agent_id or _AGENT_ID_FORBIDDEN.search(agent_id):
             return {"error": "invalid agent id", "invalid": True}
 
-        # Prefix-match: search in config.TRANSCRIPTS_ROOT for files matching agent_id*.output
+        # Prefix-match: search in config.TRANSCRIPTS_ROOT for files matching agent-agent_id*.jsonl
+        # The dashboard (dash-extra.mjs) scans for agent-*.jsonl files and emits
+        # a 13-char truncated ID; we must match against the same .jsonl files.
         if not config.TRANSCRIPTS_ROOT.exists():
             return {"error": f"transcripts root not found at {config.TRANSCRIPTS_ROOT}"}
 
         # Glob for matching files (prefix-match handles truncated IDs)
         matches = sorted(
-            config.TRANSCRIPTS_ROOT.glob(f"**/{agent_id}*.output"),
+            config.TRANSCRIPTS_ROOT.glob(f"**/agent-{agent_id}*.jsonl"),
             key=lambda p: p.stat().st_mtime, reverse=True,
         )
         if not matches:

package/ui/api/submit.py

@@ -11,13 +11,50 @@ planted at config.INBOX_FILE).
 Reads config.INBOX_FILE live via `import config` at call time, never
 `from config import INBOX_FILE` -- a frozen import goes stale after
 config.reload() (breaks test-fixture isolation). See ui/CLAUDE.md.
+
+Detects both POSIX symlinks and Windows junctions/reparse points.
 """
 import os
+import stat
 from datetime import datetime
 
 import config
 
 
+def _is_link_or_reparse(path):
+    """Check if path is a symlink or Windows reparse point (junction/etc).
+
+    Returns True if:
+    - On all platforms: path is a POSIX symlink (detected via st_mode)
+    - On Windows: path has the FILE_ATTRIBUTE_REPARSE_POINT attribute
+      (which includes junctions, symlinks, and other reparse points)
+
+    Uses os.lstat() to detect without following links (includes dangling ones).
+    On error (e.g., path doesn't exist), returns False to let caller's
+    exists() check handle it normally.
+    """
+    try:
+        stat_result = os.lstat(str(path))
+
+        # On POSIX, check the symlink bit in st_mode
+        if stat.S_ISLNK(stat_result.st_mode):
+            return True
+
+        # On Windows, check for reparse point attribute (junctions, symlinks, etc)
+        # FILE_ATTRIBUTE_REPARSE_POINT = 0x400 (1024 decimal)
+        # st_file_attributes only exists on Windows
+        if hasattr(stat_result, 'st_file_attributes'):
+            FILE_ATTRIBUTE_REPARSE_POINT = 0x400
+            if stat_result.st_file_attributes & FILE_ATTRIBUTE_REPARSE_POINT:
+                return True
+
+        return False
+    except (OSError, AttributeError):
+        # If we can't stat it, let it fall through to the exists() check
+        # (file doesn't exist, which is fine)
+        return False
+
+
 def append_to_inbox(text):
     """Append one inbox line for `text` to config.INBOX_FILE.
 
@@ -35,11 +72,13 @@ def append_to_inbox(text):
     """
     inbox_content = f"- [{datetime.now().isoformat()}] {text}\n"
 
-    # Security: reject symlinks (TOCTOU defense) FIRST — check islink independent
-    # of exists(). Path.exists() follows the link, so a DANGLING symlink (target
-    # not yet created) returns False and would otherwise skip this check, then
-    # open(...,'w') would follow the link and create the attacker's target.
-    if os.path.islink(str(config.INBOX_FILE)):
+    # Security: reject symlinks and Windows junctions (TOCTOU defense) FIRST —
+    # check link/reparse INDEPENDENT of exists(). Path.exists() follows the link,
+    # so a DANGLING symlink (target not yet created) returns False and would
+    # otherwise skip this check, then open(...,'w') would follow the link and
+    # create the attacker's target. Windows junctions are not detected by
+    # os.path.islink(), so we use _is_link_or_reparse() instead.
+    if _is_link_or_reparse(config.INBOX_FILE):
         return False, (400, {"error": "Inbox file is a symlink (rejected for security)"})
 
     if not config.INBOX_FILE.exists():

package/ui/collectors.py

@@ -316,7 +316,27 @@ def get_alerts():
     return alerts
 
 def load_tracker():
-    """Load tracker.json, return empty tracker if missing or corrupt."""
+    """Load tracker.json, return empty tracker if missing or corrupt.
+
+    Defect 2 fix: Check dirty flag. If render previously failed, the event log
+    and tracker.json may be out of sync. Re-render from projection to self-heal.
+    """
+    # Check dirty flag (indicates previous render failure)
+    dirty_file = config.STATE_DIR / ".tracker-render-dirty"
+    if dirty_file.exists():
+        try:
+            print("[tracker] Detected previous render failure; recovering...", file=sys.stderr)
+            api = _tracker_api()
+            # Force re-render from projection
+            try:
+                save_tracker(api.project("tracker"))
+                dirty_file.unlink()
+                print("[tracker] Recovery render completed", file=sys.stderr)
+            except Exception as e:
+                print(f"[tracker] Recovery render failed: {e}", file=sys.stderr)
+        except Exception as e:
+            print(f"[tracker] Failed to recover from dirty flag: {e}", file=sys.stderr)
+
     if not config.TRACKER_FILE.exists():
         return {"version": 1, "items": []}
 
@@ -418,9 +438,95 @@ def get_tracker_items(status=None, priority=None):
 
     return items
 
+# --- Event-sourced tracker backing (state_store) -----------------------------
+# The event log is the write-authority + audit trail; tracker.json is kept as
+# the rendered export that reads/SSE/UI consume. Each mutation appends an event
+# and re-renders the file (atomic os.replace via save_tracker), replacing the
+# old load->mutate->save read-modify-write that raced under concurrent writers.
+# The live read path (load_tracker / get_tracker_items / SSE snapshot) is
+# unchanged: it still reads tracker.json, which every write keeps current.
+
+def _tracker_api():
+    """Return a StateAPI over state/tracker_events.db (lazy import; call-time paths)."""
+    try:
+        from state_store import StateAPI
+    except ImportError:
+        from pathlib import Path as _Path
+        root = str(_Path(__file__).resolve().parents[1])
+        if root not in sys.path:
+            sys.path.insert(0, root)
+        from state_store import StateAPI
+    config.STATE_DIR.mkdir(parents=True, exist_ok=True)
+    return StateAPI(str(config.STATE_DIR / "tracker_events.db"))
+
+
+def _ensure_tracker_migrated(api):
+    """Backfill the event log from the existing tracker.json once (idempotent).
+
+    Defect 3 fix: Guard migration with a marker event (migration_started with
+    version=1). The first caller to append this marker wins and performs the
+    backfill. Subsequent callers see the marker and skip the backfill. This
+    prevents concurrent callers from polluting the audit log with duplicate
+    item_created events.
+    """
+    events = api.get("tracker")
+
+    # Check for migration marker (first event of type "migration_started")
+    has_migration_marker = any(e.get("type") == "migration_started" and
+                               e.get("payload", {}).get("version") == 1
+                               for e in events)
+    if has_migration_marker:
+        # Migration already completed (or in progress); skip backfill
+        return
+
+    # Append migration marker first to atomically claim the migration
+    try:
+        api.append("tracker", "migration_started", {"version": 1}, "system")
+    except Exception as e:
+        print(f"[tracker] Failed to append migration marker: {e}", file=sys.stderr)
+        return
+
+    # Now safe to backfill (other callers will see marker and skip)
+    if config.TRACKER_FILE.exists():
+        try:
+            data = json.loads(config.TRACKER_FILE.read_text(encoding='utf-8'))
+        except Exception:
+            data = {"items": []}
+        for item in data.get("items", []):
+            if isinstance(item, dict) and item.get("id"):
+                api.append("tracker", "item_created", item, "migration")
+
+
+def _tracker_items_by_id(api):
+    return {it["id"]: it for it in api.project("tracker")["items"]}
+
+
+def _render_tracker(api):
+    """Materialize the projection back to tracker.json (atomic).
+
+    Defect 2 fix: Wrap render in try/except. On failure, log loudly and mark
+    a dirty flag so the next read triggers a recovery re-render. This ensures
+    that if the event log has events but tracker.json is stale, the next read
+    self-heals by detecting the mismatch and re-rendering.
+    """
+    try:
+        save_tracker(api.project("tracker"))
+    except Exception as e:
+        print(f"[tracker] CRITICAL: Failed to render tracker after event append: {e}",
+              file=sys.stderr)
+        # Mark dirty flag for recovery on next read
+        dirty_file = config.STATE_DIR / ".tracker-render-dirty"
+        try:
+            dirty_file.write_text(str(time()), encoding='utf-8')
+        except Exception as e2:
+            print(f"[tracker] Failed to write dirty flag: {e2}", file=sys.stderr)
+        raise
+
+
 def create_tracker_item(data):
-    """Create a new tracker item."""
-    tracker = load_tracker()
+    """Create a new tracker item (event-sourced; tracker.json re-rendered)."""
+    api = _tracker_api()
+    _ensure_tracker_migrated(api)
 
     item = {
         "id": secrets.token_hex(6),
@@ -436,39 +542,43 @@ def create_tracker_item(data):
         "completed_at": None
     }
 
-    tracker["items"].append(item)
-    save_tracker(tracker)
+    api.append("tracker", "item_created", item, item["source"])
+    _render_tracker(api)
     return item
 
 def update_tracker_item(item_id, update_data):
-    """Update a tracker item by id."""
-    tracker = load_tracker()
+    """Update a tracker item by id (event-sourced)."""
+    api = _tracker_api()
+    _ensure_tracker_migrated(api)
 
-    item = next((i for i in tracker["items"] if i["id"] == item_id), None)
-    if not item:
+    current = _tracker_items_by_id(api)
+    if item_id not in current:
         raise Exception(f"404 Item not found: {item_id}")
 
+    patch = {"id": item_id}
     for key in ["status", "lane", "priority", "notes", "pr_link", "tags"]:
         if key in update_data:
-            item[key] = update_data[key]
+            patch[key] = update_data[key]
 
-    if update_data.get("status") == "done" and not item.get("completed_at"):
-        item["completed_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+    if update_data.get("status") == "done" and not current[item_id].get("completed_at"):
+        patch["completed_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 
-    save_tracker(tracker)
-    return item
+    api.append("tracker", "item_updated", patch, "api")
+    _render_tracker(api)
+    return _tracker_items_by_id(api)[item_id]
 
 def delete_tracker_item(item_id):
-    """Soft-delete a tracker item (mark as archived)."""
-    tracker = load_tracker()
+    """Soft-delete a tracker item (mark as archived; event-sourced)."""
+    api = _tracker_api()
+    _ensure_tracker_migrated(api)
 
-    item = next((i for i in tracker["items"] if i["id"] == item_id), None)
-    if not item:
+    current = _tracker_items_by_id(api)
+    if item_id not in current:
         raise Exception(f"404 Item not found: {item_id}")
 
-    item["status"] = "archived"
-    save_tracker(tracker)
-    return item
+    api.append("tracker", "item_archived", {"id": item_id}, "api")
+    _render_tracker(api)
+    return _tracker_items_by_id(api)[item_id]
 
 def _snapshot_data():
     """Everything the 'data' SSE section covers (header, repos, events, alerts, messages)."""
@@ -530,27 +640,66 @@ def _snapshot_orchestrator_status():
         return {"orchestrators": []}
 
 def drain_tracker_inbox():
-    """Drain .tracker-inbox.jsonl, create items idempotently."""
+    """Drain .tracker-inbox.jsonl, create items idempotently.
+
+    Defect 1 fix: Atomically rename inbox file to unique processing name FIRST
+    to ensure only one caller processes it under concurrent access. Strengthen
+    dedup to check both tracker.json AND api.project("tracker") so items
+    in the event store but not yet rendered are also excluded.
+    """
     inbox_file = config.STATE_DIR / ".tracker-inbox.jsonl"
     if not inbox_file.exists():
         return []
-    
+
     created = []
     try:
-        content = inbox_file.read_text(encoding='utf-8')
+        # Defect 1: Atomically rename inbox to unique processing name first.
+        # This ensures only one caller wins; others see no file.
+        processing_file = inbox_file.with_name(
+            f".tracker-inbox.jsonl.processing-{secrets.token_hex(8)}"
+        )
+        try:
+            os.replace(str(inbox_file), str(processing_file))
+        except FileNotFoundError:
+            # Another caller already renamed it; nothing to process
+            return []
+        except Exception as e:
+            print(f"[inbox] Failed to rename inbox: {e}", file=sys.stderr)
+            return []
+
+        content = processing_file.read_text(encoding='utf-8')
         if not content.strip():
-            inbox_file.unlink()
+            processing_file.unlink()
             return []
-        
+
         lines = content.strip().splitlines()
-        tracker = load_tracker()
+
+        # Defect 1: Build dedup hash set from both tracker.json AND event store projection.
+        # This catches items in the event store that haven't been rendered to tracker.json yet.
         existing_hashes = set()
-        for item in tracker.get("items", []):
+
+        # Check rendered tracker.json
+        tracker_json = load_tracker()
+        for item in tracker_json.get("items", []):
             source = item.get("source", "")
             title = item.get("title", "")
             h = hashlib.sha256((source + ":" + title).encode()).hexdigest()
             existing_hashes.add(h)
-        
+
+        # Also check event store projection (catches items in DB but not yet rendered)
+        try:
+            api = _tracker_api()
+            projected = api.project("tracker")
+            for item in projected.get("items", []):
+                source = item.get("source", "")
+                title = item.get("title", "")
+                h = hashlib.sha256((source + ":" + title).encode()).hexdigest()
+                existing_hashes.add(h)
+        except Exception as e:
+            print(f"[inbox] Failed to project tracker state: {e}", file=sys.stderr)
+            # Fall back to tracker.json only if projection fails
+            pass
+
         rejects = []
         for line in lines:
             line = line.strip()
@@ -561,11 +710,11 @@ def drain_tracker_inbox():
                 if not isinstance(entry, dict):
                     rejects.append(line)
                     continue
-                
+
                 source = entry.get("source", "")
                 title = entry.get("title", "")
                 h = hashlib.sha256((source + ":" + title).encode()).hexdigest()
-                
+
                 if h not in existing_hashes:
                     item = create_tracker_item(entry)
                     created.append(item)
@@ -574,13 +723,13 @@ def drain_tracker_inbox():
                 rejects.append(line)
             except Exception as e:
                 rejects.append(line + " # " + str(e))
-        
+
         if rejects:
             rejects_file = inbox_file.with_name(".tracker-inbox.rejects")
             rejects_file.write_text("\n".join(rejects) + "\n", encoding='utf-8')
-        
-        inbox_file.unlink()
+
+        processing_file.unlink()
     except Exception as e:
         print(f"[inbox] Drain error: {e}", file=sys.stderr)
-    
+
     return created

package/ui/config.py

@@ -28,6 +28,7 @@ def reload():
     global WATCHDOG_HEARTBEAT, MONITOR_HEARTBEAT, REPOS_JSON, BACKUP_LOG
     global ALERTS_LOG, INBOX_FILE, AUDIT_BACKLOG_FILE
     global UI_SESSION_TOKEN_FILE, TRACKER_FILE, ORCH_STATUS_FILE
+    global WEB_DIST, LEDGER_FILE
     global COLLECTOR_INTERVAL, SSE_KEEPALIVE_SECONDS, SSE_MAX_CLIENTS, SSE_QUEUE_MAXSIZE, SSE_WRITE_TIMEOUT
 
     # PORT: env PORT > default 8770
@@ -75,6 +76,12 @@ def reload():
     TRACKER_FILE = STATE_DIR / "tracker.json"
     ORCH_STATUS_FILE = STATE_DIR / "orchestrator-status.json"
 
+    # Wave-14 dashboard rewrite (plan D3): built frontend + cost ledger paths.
+    # WEB_DIST: the committed Vite build output served at / and /assets/*.
+    WEB_DIST = AESOP_ROOT / "ui" / "web" / "dist"
+    # LEDGER_FILE: outcomes ledger parsed by ui/cost.py; sse.py mtime-gates on it.
+    LEDGER_FILE = STATE_DIR / "ledger" / "OUTCOMES-LEDGER.md"
+
     # Collector and SSE configuration
     COLLECTOR_INTERVAL = float(os.getenv("AESOP_UI_COLLECT_INTERVAL", "1.0"))
     SSE_KEEPALIVE_SECONDS = 15
@@ -104,6 +111,8 @@ AUDIT_BACKLOG_FILE = AESOP_ROOT / "AUDIT-BACKLOG.md"
 UI_SESSION_TOKEN_FILE = STATE_DIR / ".ui-session-token"
 TRACKER_FILE = STATE_DIR / "tracker.json"
 ORCH_STATUS_FILE = STATE_DIR / "orchestrator-status.json"
+WEB_DIST = AESOP_ROOT / "ui" / "web" / "dist"
+LEDGER_FILE = STATE_DIR / "ledger" / "OUTCOMES-LEDGER.md"
 COLLECTOR_INTERVAL = 1.0
 SSE_KEEPALIVE_SECONDS = 15
 SSE_MAX_CLIENTS = 100