Observatory Redesign — Unified Vitto Super-Agent Monitoring

Session: 176.3 Date: 2026-03-04 Status: Approved design, pending implementation

Vision

Vitto is the super-agent that orchestrates, monitors, and governs all AI activity. The Observatory is Vitto's eyes — the unified surface where humans see what Vitto sees. Every piece of monitoring data queryable by Vitto through MCP has a corresponding visualization in the Observatory.

Current State

Two separate observatory surfaces exist:

• /observatory (Sessions 104-175) — 3 tabs: Agents, System, Sandbox. Real-time ops monitoring.
• /vitto/observatory (Sessions 111-158) — 6 tabs: Approvals, Audit, Costs, Trust, Failure Chains, Specialization. Administrative governance.

Both are functional with real backend integrations. The split happened historically: /observatory was built when monitoring was a platform concern; /vitto/observatory was built when Vitto became a standalone product. Now that Vitto IS the platform's AI layer, they should be one surface.

Architecture Decision

Vitto's Observatory becomes THE canonical observatory.

• /vitto/observatory gains all 9 tabs organized in 3 groups
• /observatory renders the same ObservatoryPanelComponent shell — one codebase, two URLs
• Chrome extension updates to load the unified surface
• AI panel (<ai-panel-tabs>) continues embedding AgentObservatoryComponent directly (no change)

Tab Structure

/vitto/observatory (OR /observatory)
├── Operations (all roles)
│   ├── agents      → AgentObservatoryComponent (enhanced)
│   ├── system      → ObservatoryDashboardComponent (enhanced)
│   └── sandbox     → SandboxTabComponent (fixed)
├── Governance (all roles)
│   ├── approvals   → ObservatoryApprovalsComponent (fixed)
│   ├── audit       → ObservatoryAuditComponent
│   └── trust       → TrustDashboardComponent
└── Intelligence (developer/admin only)
    ├── costs       → CostDashboardComponent
    ├── failures    → FailureChainsComponent (fixed)
    └── specialization → SpecializationMatrixComponent (fixed)

Backend Responsibilities (Unchanged)

The frontend abstracts this split — observatory services talk to both backends and present a unified view.

Implementation Plan

Part 1: Unified Surface (Route Consolidation)

Goal: Both /observatory and /vitto/observatory render the same shell with all 9 tabs.

Changes:

1. Enhance ObservatoryPanelComponent to accept all 9 child routes grouped into Operations / Governance / Intelligence
2. Add agents, system, sandbox as new child routes under /vitto/observatory
3. Update /observatory in apps/gograb-ai to render ObservatoryPanelComponent with the same child route config
4. Update Chrome extension sidepanel iframe URL
5. Role-based tab visibility: Intelligence group hidden for non-developer roles

Files:

• libs/libs-ai/vitto-hub/src/lib/components/observatory-panel/observatory-panel.component.ts — enhance with tab groups
• libs/libs-ai/vitto-hub/src/lib/components/observatory-panel/observatory-panel.component.html — grouped tab layout
• libs/libs-ai/vitto-hub/src/lib/routes/vitto-hub.routes.ts — add 3 new child routes
• apps/gograb-ai/src/app/pages/observatory/observatory-page.component.ts — render ObservatoryPanelComponent
• apps/gograb-ai/src/app/routes/ — update observatory route config
• apps/vitto-chrome-extension/sidepanel/sidepanel.js — update iframe URL

Part 2: Bug Fixes (11 confirmed issues)

Part 3: Wire Unwired Code

Goal: Every component built by a previous session gets wired to its intended home.

Part 4: LLM Cost Persistence (MongoDB)

Goal: LLM costs survive server restarts. Historical trends available.

Backend changes (backend-ai-api):

New Mongoose schema:

@Schema({ collection: 'llm-usage', timestamps: true })
export class LlmUsageDocument {
  @Prop() model: string;
  @Prop() tokensIn: number;
  @Prop() tokensOut: number;
  @Prop() estimatedCostUsd: number;
  @Prop() userId: string;
  @Prop() sessionId?: string;
  @Prop() timestamp: Date;
}

TTL index: auto-expire after 90 days (configurable).

LlmCostTrackerService.recordUsage():

• Continues updating in-memory 24h window (fast reads)
• Also writes to MongoDB (fire-and-forget, non-blocking)

New endpoints:

• GET /infrastructure/observatory/llm-history?days=30 — daily cost aggregates for charting
• GET /infrastructure/observatory/llm-by-user?days=7 — per-user cost breakdown

Frontend changes:

• ObservatoryDashboardComponent gains:
  • 30-day cost trend chart (simple SVG, no heavy charting lib)
  • Per-user cost breakdown table (the byUser field currently fetched but never rendered)
  • Backend health details field rendered (currently silently dropped)

Part 5: Unified Alert Pipeline

Goal: All alert sources flow through one service, persist to MongoDB, push to frontend in real-time.

Backend (backend-ai-api):

New AlertAggregatorService:

@Injectable()
export class AlertAggregatorService implements OnModuleInit {
  // Subscribes to:
  // - PipelineMetricsService events (pipeline.alert, pipeline.unhealthy, pipeline.degraded)
  // - ConditionMonitorService events (monitor.alert, monitor.recovered)
  // - ObservatoryService health results (backend down/degraded)
  // - Vitto proactive alerts (forwarded from vitto-api)

  // Persists to 'alerts' collection (deduplication by message hash + 1h window)
  // Emits to WebSocket for real-time frontend push
  // Exposes via REST for polling fallback
}

Mongoose schema:

@Schema({ collection: 'alerts', timestamps: true })
export class AlertDocument {
  @Prop() severity: 'critical' | 'warning' | 'info';
  @Prop() source: string; // 'pipeline' | 'condition-monitor' | 'health-check' | 'vitto-proactive'
  @Prop() check: string;  // e.g., 'api-health', 'build-health', 'dependency-audit'
  @Prop() message: string;
  @Prop() details?: string;
  @Prop() resolved: boolean;
  @Prop() resolvedAt?: Date;
  @Prop() firstSeenAt: Date;
  @Prop() lastSeenAt: Date;
  @Prop() occurrenceCount: number;
}

TTL index: auto-expire resolved alerts after 30 days.

New endpoint:

• GET /infrastructure/observatory/alerts?severity=critical&resolved=false&limit=50
• POST /infrastructure/observatory/alerts/:id/resolve — manual resolution

Frontend:

• New "Alerts" section in System tab with persistent alert history
• Alert badge count on Observatory navigation item
• Existing proactive alerts in Agent Monitor continue via SSE (complementary, not replaced)

Part 6: MCP Convergence — Vitto Self-Monitoring

Goal: Every observatory visualization maps to an MCP tool. Vitto can self-diagnose.

New MCP actions (in MCP/mcp-gograb-ai/):

1. stats({ action: "alerts" }) — returns active unresolved alerts

   • Calls GET /infrastructure/observatory/alerts?resolved=false
   • Vitto uses this to self-diagnose when backends are degraded

2. stats({ action: "costs", days: 7 }) — returns cost breakdown by model/user

   • Calls GET /infrastructure/observatory/llm-history?days=7
   • Vitto can monitor spend and warn proactively

3. intelligence({ action: "trust", actionType: "deploy::execute" }) — returns trust score

   • Calls GET /engine/trust-scores on vitto-api
   • Vitto checks its own trust before attempting risky actions

Existing MCP tool ↔ Observatory mapping:

Vitto self-monitoring flow:

• On task start: preflight already checks system health
• If preflight detects degraded health: Vitto can decide to pause, warn, or proceed with caution
• Vitto can call stats.alerts proactively to surface issues
• After task completion: outcome.report feeds the learning pipeline (already happens)

Part 7: Wire Key Unused Backend Endpoints

Goal: 8 existing VittoApiService methods with high value get wired to observatory tabs.

Data Flow

                    ┌─────────────────────────────────────────┐
                    │          Observatory UI (Angular)        │
                    │                                         │
                    │  ┌─────────────┐  ┌──────────────────┐ │
                    │  │ VittoMonitor│  │ Orchestration     │ │
                    │  │ Service     │  │ ClientService     │ │
                    │  │ (SSE)       │  │ (WebSocket)       │ │
                    │  └──────┬──────┘  └────────┬─────────┘ │
                    │         │                   │           │
                    │  ┌──────┴───────────────────┴─────────┐ │
                    │  │ ObservatoryDataService (REST poll)  │ │
                    │  │ VittoApiService (REST on-demand)    │ │
                    │  └──────┬───────────────────┬─────────┘ │
                    └─────────┼───────────────────┼───────────┘
                              │                   │
                    ┌─────────▼─────────┐ ┌──────▼──────────┐
                    │ backend-ai-api    │ │ backend-vitto-api│
                    │ (port 3001)       │ │ (port 3003)      │
                    │                   │ │                   │
                    │ • Health checks   │ │ • Task engine     │
                    │ • LLM costs (DB)  │ │ • Mind/memories   │
                    │ • Sandbox mgmt    │ │ • Trust scores    │
                    │ • Alerts (DB)     │ │ • Security audit  │
                    │ • Agent specs     │ │ • Task costs      │
                    │ • MCP data        │ │ • Smart routing   │
                    │ • Computer use    │ │ • Skills/personas │
                    │ • Command center  │ │ • A2A protocol    │
                    └───────────────────┘ └──────────────────┘
                              │                   │
                    ┌─────────▼───────────────────▼───────────┐
                    │              MCP Server                  │
                    │ (same data, programmatic access)        │
                    │                                         │
                    │ stats.alerts → backend-ai-api           │
                    │ stats.costs → backend-ai-api            │
                    │ intelligence.trust → backend-vitto-api  │
                    │ preflight → both backends               │
                    └─────────────────────────────────────────┘

Dead Code Resolution

Overlap Resolution

Files Touched (Estimated)

Modified: ~25 files New: ~5 files (alert service, alert schema, LLM usage schema, new MCP actions, shared DTOs) Deprecated: 1 file (VittoMonitorComponent marked @deprecated)

Success Criteria

1. Single observatory surface accessible from both /observatory and /vitto/observatory
2. All 9 tabs render real data from their respective backends
3. Zero (res as any) patterns — all responses typed
4. LLM costs persisted to MongoDB with 30-day trend chart
5. Alerts aggregated, persisted, and visible in System tab
6. 3 new MCP actions for Vitto self-monitoring
7. All 4 OrchestrationClientService signals rendered in Agent Monitor (full mode)
8. All previously unwired components connected to their intended homes
9. All 11 confirmed bugs fixed
10. 8 high-value unused backend endpoints wired to observatory tabs