@matt82198/aesop 0.1.0-beta.4 → 0.1.0-rc.1

package/ui/collectors.py

@@ -233,7 +233,7 @@ def get_main_thread_messages():
             return messages
 
         newest = jsonl_files[0]
-        with open(newest, 'r', encoding='utf-8', errors='ignore') as f:
+        with open(newest, 'r', encoding='utf-8', errors='replace') as f:
             lines = f.readlines()
             # Get last 30 lines to extract ~12 message turns
             for line in lines[-30:]:
@@ -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)."""
@@ -529,28 +639,155 @@ def _snapshot_orchestrator_status():
         print(f"[status] Snapshot error: {e}", file=sys.stderr)
         return {"orchestrators": []}
 
+def _recover_stranded_inbox_files():
+    """Defect 3 fix: Recovery sweep for .tracker-inbox.jsonl.processing-* files.
+
+    If drain_tracker_inbox crashes mid-process, it leaves a .processing-* file.
+    This sweep re-ingests those files on the next drain call, preventing silent
+    data loss. Returns list of items recovered.
+    """
+    recovered = []
+    try:
+        for processing_file in sorted(config.STATE_DIR.glob(".tracker-inbox.jsonl.processing-*")):
+            if not processing_file.exists():
+                continue
+            try:
+                content = processing_file.read_text(encoding='utf-8')
+                if not content.strip():
+                    try:
+                        processing_file.unlink()
+                    except Exception:
+                        pass
+                    continue
+
+                # Build dedup hash set from both tracker.json and event store
+                existing_hashes = set()
+
+                # 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)
+
+                # Check event store projection
+                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] Recovery: failed to project tracker state: {e}", file=sys.stderr)
+
+                # Reprocess lines from the recovered file
+                lines = content.strip().splitlines()
+                for line in lines:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                        if not isinstance(entry, dict):
+                            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)
+                            recovered.append(item)
+                            existing_hashes.add(h)
+                    except (json.JSONDecodeError, Exception):
+                        pass
+
+                # Only delete after successful re-ingest
+                try:
+                    processing_file.unlink()
+                except Exception as e:
+                    print(f"[inbox] Recovery: failed to unlink {processing_file}: {e}", file=sys.stderr)
+
+            except Exception as e:
+                print(f"[inbox] Recovery sweep error on {processing_file}: {e}", file=sys.stderr)
+    except Exception as e:
+        print(f"[inbox] Recovery sweep failed: {e}", file=sys.stderr)
+
+    return recovered
+
+
 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.
+
+    Defect 3 fix: Before processing the current inbox, perform a recovery sweep
+    to re-ingest leftover .tracker-inbox.jsonl.processing-* files from any
+    previous crashes. This prevents silent data loss if a crash happens
+    mid-drain: stranded files are recovered on the next drain call.
+    """
     inbox_file = config.STATE_DIR / ".tracker-inbox.jsonl"
+
+    # Defect 3: Recovery sweep for stranded .processing-* files from prior crashes.
+    created = _recover_stranded_inbox_files()
+
+    # Now process the current inbox if it exists
     if not inbox_file.exists():
-        return []
-    
-    created = []
+        return created
+
+    # 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 created
+    except Exception as e:
+        print(f"[inbox] Failed to rename inbox: {e}", file=sys.stderr)
+        return created
+
     try:
-        content = inbox_file.read_text(encoding='utf-8')
+        content = processing_file.read_text(encoding='utf-8')
         if not content.strip():
-            inbox_file.unlink()
-            return []
-        
+            processing_file.unlink()
+            return created
+
         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()
@@ -558,29 +795,34 @@ def drain_tracker_inbox():
                 continue
             try:
                 entry = json.loads(line)
-                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)
-                    existing_hashes.add(h)
             except json.JSONDecodeError:
                 rejects.append(line)
-            except Exception as e:
-                rejects.append(line + " # " + str(e))
-        
+                continue
+
+            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:
+                # create_tracker_item can raise real errors (not malformed JSON)
+                # let those bubble up rather than silently adding to rejects
+                item = create_tracker_item(entry)
+                created.append(item)
+                existing_hashes.add(h)
+
         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()
+
+        # Only delete the processing file after successful completion.
+        # If an exception occurs, the file is left behind for recovery.
+        processing_file.unlink()
     except Exception as e:
-        print(f"[inbox] Drain error: {e}", file=sys.stderr)
-    
+        print(f"[inbox] Drain error: {e}; processing file {processing_file.name} left for recovery", file=sys.stderr)
+        # Don't delete the file on error; let recovery sweep handle it next time
+
     return created

package/ui/config.py

@@ -28,13 +28,34 @@ 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
     PORT = int(os.getenv("PORT", "8770"))
 
-    # Determine AESOP_ROOT: env AESOP_ROOT > default $HOME/aesop
-    AESOP_ROOT = Path(os.getenv("AESOP_ROOT", Path.home() / "aesop"))
+    # Determine AESOP_ROOT with fallback tiers (matching daemons/run-watchdog.sh pattern):
+    # (1) AESOP_ROOT env var if set
+    # (2) Derive from file location: Path(__file__).resolve().parents[1]
+    # (3) Load config from derived location; if it has aesop_root, use that
+    env_root = os.getenv("AESOP_ROOT")
+    if env_root:
+        AESOP_ROOT = Path(env_root)
+    else:
+        # Derive from file location (matches daemons/run-watchdog.sh pattern)
+        AESOP_ROOT = Path(__file__).resolve().parents[1]
+
+        # Check if derived location's config has aesop_root key
+        derived_config_file = AESOP_ROOT / "aesop.config.json"
+        if derived_config_file.exists():
+            try:
+                with open(derived_config_file) as f:
+                    derived_config = json.load(f)
+                    if "aesop_root" in derived_config:
+                        AESOP_ROOT = Path(derived_config["aesop_root"])
+            except Exception:
+                # Silently ignore config errors here; will attempt full load below
+                pass
 
     # Try to load config file for additional settings
     CONFIG_FILE = AESOP_ROOT / "aesop.config.json"
@@ -75,6 +96,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 +131,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