Session 144 — Work Summary (February 26, 2026)

What Was Done

Session 144 closed 4 "gaps" from the Vitto Super-Agent roadmap (Gaps 9-12). Here's what each one means in plain English.

Gap 12 — A2A Protocol Tests (DONE)

What is A2A? Google's Agent-to-Agent protocol — a standard way for AI agents to discover each other and send tasks. We already had a working A2A implementation in backend-vitto-api. What was missing: tests.

What was built: 5 test files covering every public method:

• Discovery (agent card shape, required fields)
• Task lifecycle (submit -> status -> completion)
• Error handling (missing tasks, cancel flow, DB failures)
• Status mapping (all 9 Vitto->A2A status translations)
• SSE events (event shape, stream closure)

Location: APIs/backend-vitto-api/src/app/a2a/__tests__/

Status: Complete. Zero production code changed — tests only.

Gap 10 — Sandbox Provider Abstraction (DONE)

The problem: Our Computer Use system (where an AI controls a browser/desktop) was hardcoded to use E2B Cloud. If we wanted to use our own servers instead, we'd have to rewrite the entire loop.

What was built: A Strategy pattern that lets us swap sandbox providers without touching the core logic.

ComputerUseLoopService
    -> SandboxProviderFactory (picks the right one automatically)
            |-- E2BCloudProvider    <- wraps existing E2B Desktop SDK
            |-- SelfHostedProvider  <- HTTP client for our future server
            |-- PlaywrightProvider  <- local browser fallback

How it picks a provider (env vars):

1. If SANDBOX_SERVER_URL is set -> SelfHostedProvider
2. If E2B_API_KEY is set -> E2BCloudProvider (this is what we use today)
3. Neither -> PlaywrightProvider (free, local, limited)

What changed in the codebase:

• New sandbox/ directory with 6 files (interface, 3 providers, factory, barrel export)
• computer-use-loop.service.ts no longer imports E2BDesktopService directly
• All e2bSandbox variable names renamed to sandboxHandle

Location: APIs/backend-ai-api/src/app/infrastructure/services/sandbox/

Status: Complete. E2B Cloud works exactly as before. Self-hosted provider is scaffolded (HTTP client code exists, but there's no server to connect to yet — see Gaps section below).

Gap 11 — Observability Dashboard (DONE)

The problem: We had no unified view of system health. Each backend had its own /health endpoint, but nothing aggregated them or tracked LLM spending.

What was built:

Backend (3 new files)

1. LLM Cost Tracker (llm-cost-tracker.service.ts)

   • Records every LLM API call: model, tokens in/out, cost, user
   • Rolling 24-hour window (in-memory, no database overhead)
   • Model-specific pricing (Claude Opus 4.6: $15/$75 per 1M tokens, etc.)
   • Called automatically after every Anthropic API call in Computer Use

2. Observatory Service (observatory.service.ts)

   • Checks health of all 4 backends every 30 seconds (cached)
   • Aggregates into a single dashboard JSON
   • Also generates Prometheus-format text metrics

3. Observatory Controller (observatory.controller.ts)

   • GET /infrastructure/observatory/dashboard — full dashboard JSON
   • GET /infrastructure/observatory/metrics — Prometheus text format
   • GET /infrastructure/observatory/llm-spend — 24h token summary
   • GET /infrastructure/observatory/llm-daily — daily cost history

Frontend (4 new files)

4. Observatory Data Service — Angular service that polls the dashboard endpoint
5. Observatory Dashboard Component — Shows backend health cards, LLM spend breakdown, agent/system metrics
6. Observatory Page updated with tab system: "Agent Monitor" (existing) + "System Dashboard" (new)

Location:

• Backend: APIs/backend-ai-api/src/app/infrastructure/
• Frontend: libs/libs-ai/gograb-ai-lib/src/lib/components/observatory-dashboard/
• Page: apps/gograb-ai/src/app/pages/observatory/

Status: Complete. Navigate to /observatory and click "System Dashboard" tab.

Gap 9 — Vitto Mobile App (SCAFFOLDED)

What is it? A native mobile wrapper around our existing Angular app, exactly like vitto-desktop wraps it with Tauri — but using Capacitor for iOS/Android instead.

What exists today

Tech Stack

• Framework: Capacitor v6 (by Ionic team)
• App ID: space.gograb.vitto.mobile
• Web directory: Points to the same Angular build output: dist/apps/gograb-ai/browser
• Bridge service: Uses window.Capacitor.Plugins['Name'] for runtime access (no compile-time dependencies needed)
• Planned plugins: Push Notifications, Haptics, Splash Screen, Status Bar, Browser (OAuth)

How it works (same pattern as Tauri desktop)

Angular App (gograb-ai)
    |-- Tauri wrapper   -> Vitto Desktop (macOS/Windows/Linux)
    |-- Capacitor wrapper -> Vitto Mobile (iOS/Android)  <- NEW

The Angular app builds once. Both wrappers load the same dist/ output. Each wrapper provides native capabilities through a bridge service (TauriBridgeService for desktop, CapacitorBridgeService for mobile). Both services are no-ops when running in a regular browser.

Is it ready to use?

No. It's a scaffolding — the NX project and configuration exist, but you can't run cap sync or open it in Xcode/Android Studio yet because:

1. Capacitor packages aren't installed in root package.json
2. No npx cap add ios / npx cap add android has been run
3. No native directories exist
4. No signing certificates configured

What's needed to make it work

# 1. Install Capacitor
yarn add @capacitor/core @capacitor/ios @capacitor/android
yarn add -D @capacitor/cli

# 2. Install plugins
yarn add @capacitor/push-notifications @capacitor/haptics \
         @capacitor/splash-screen @capacitor/status-bar @capacitor/browser

# 3. Build Angular app
nx build app-gograb-ai

# 4. Add native platforms
cd apps/vitto-mobile
npx cap add ios
npx cap add android
npx cap sync

# 5. Open in IDE
npx cap open ios     # Opens Xcode
npx cap open android # Opens Android Studio

Current State of E2B / Sandbox Infrastructure

What works RIGHT NOW

What is SCAFFOLDED (not working yet)

In simple terms

We currently pay E2B for cloud VMs. The abstraction layer is done, so when we're ready to run our own VMs, we just:

1. Build the Sandbox Orchestrator server (NestJS service on Hetzner)
2. Set SANDBOX_SERVER_URL=https://sandbox.gograb.space in .env.local
3. The system automatically switches to self-hosted. No changes to the Computer Use loop.

The break-even point is ~10 active users (E2B Pro is $150/mo + usage vs self-hosted at $46/mo fixed).

Files Created This Session

Files Modified This Session

Remaining Gaps / Next Steps

1. Self-Hosted Sandbox Orchestrator — The biggest remaining piece. Need to build the NestJS service that runs on Hetzner and manages Firecracker VMs. Plan is written, implementation is zero.

2. Vitto Mobile -> Real Device — Install Capacitor packages, run cap add ios/android, test on simulator, set up signing and CI/CD.

3. A2A Tests -> Run them — Tests were written but should be verified with nx test backend-vitto-api --testPathPattern=a2a.

4. LLM Cost Persistence — Currently in-memory only (resets on server restart). Could add MongoDB persistence for historical trends.

5. Prometheus Scraping — The /metrics endpoint exists but no Prometheus/Grafana instance is set up to scrape it.