GoGrab + Vitto — Comprehensive Master Plan

One plan to rule them all. This document replaces and supersedes all previous plans. It covers both the Platform Builder (GoGrab Space) and the Super Agent (Vitto).

The Vision in One Paragraph

GoGrab Space is the AI platform that builds and runs your online business. Tell Vitto what you need — on WhatsApp, in a browser, from your desktop — and it generates a full platform, deploys it, and manages it for you. Vitto gets smarter with every business it builds. After 100 restaurants, it knows what a restaurant needs before you ask. It has its own personality that adapts to how you communicate. It remembers your preferences, celebrates your wins, and proactively warns you about problems. You pay per outcome delivered, not per seat.

Current State: What Actually Exists (Verified March 11, 2026)

Platform Builder (Generate → Edit → Deploy)

Super Agent (Vitto Intelligence)

What's NOT Built

The Plan: 8 Tracks, Priority-Ordered

Track 1: PROVE IT WORKS (S202 — Immediate)

Goal: Verify the generation pipeline produces working code, Studio shows it, deploy works. Why first: Nothing else matters if the core product doesn't work. Effort: 2 sub-sessions

• Run E2E generation ("soccer club management platform")
• Verify: categories assigned, scaffold templates compile, parallel execution, path aliases correct
• Verify: Studio file tree loads from GitLab, file edits auto-commit
• Verify: Deploy to Cloudflare Pages produces a live site
• Fix any compilation issues in scaffold templates
• Wire rollback stubs to actual GitLab revert (Gap A)
• Persist generation summary to chat MongoDB (Gap B)

Pass criteria: A user can describe a platform → Vitto generates it → it appears in Studio → it deploys to a live URL → the summary persists in chat.

Track 2: MAKE VITTO KNOW YOU (S202-S203 — High Priority)

Goal: Connect the existing Dossier + Persona systems into a coherent "Vitto grows with you" experience. Why: This is the differentiator. Bolt/v0/Cursor don't know their users. Effort: 3.5 sub-sessions

2A: Verify Existing Systems Work (0.5 session)

The dossier (S196) and persona (S120-S197) systems are built but may not be fully wired:

• Verify UserDossierService.getDossierForPrompt() is called in ContextAssemblyService
• Verify PersonaService.getActivePersona() is called in prompt assembly
• Verify PersonaSelectorComponent renders in vitto-hub
• Verify behavioral sliders (emoji, humor, depth, formality) are exposed in UI
• Verify expression engine works on WhatsApp (contextual emoji, progress phrases)
• Verify emotional tone detection actually changes Vitto's response behavior

2B: Persona Adaptation Loop (1 session)

Make Vitto auto-learn how each user communicates:

• Create PersonaAdaptationService in backend-vitto-api/src/app/engine/
• Track user message patterns: average length, emoji frequency, formality markers, question vs statement ratio
• After 20 interactions, compute inferredCommunicationStyle and store in dossier
• Auto-adjust persona behavioral sliders (or suggest switch to a better-matching preset)
• Feed inferredCommunicationStyle into ContextAssemblyService prompt

Files:

• New: APIs/backend-vitto-api/src/app/engine/persona-adaptation.service.ts
• Modify: APIs/backend-vitto-api/src/app/users/schemas/user-dossier.schema.ts (add inferredCommunicationStyle)
• Modify: APIs/backend-vitto-api/src/app/engine/context-assembly.service.ts (read inferred style)

2C: Relationship Deepening (1 session)

Make Vitto remember shared history and reference it naturally:

• Add relationshipNotes: string[] to dossier schema (Vitto's internal notes about the user)
• After every significant interaction (module gen, deploy, long conversation), generate 1 note via Haiku (~$0.001): "User celebrated hitting 100 orders. They were excited about the new dashboard."
• Hook into MemoryPersistenceService.generateAndRememberConversation() to populate dossier timeline
• In compileBrief(), include 3 most relevant relationship notes + 2 most relevant timeline events
• Inject under "Your history with this user" section in system prompt

The "wow" moment this creates:

User: "How's my store doing?"
Vitto: "Last time we talked, you'd just hit 100 orders — let me check
        if that trend continued. [runs analytics] You're at 147 now!
        That's 47% growth in a week. 🚀"

Files:

• Modify: APIs/backend-vitto-api/src/app/users/schemas/user-dossier.schema.ts
• Modify: APIs/backend-vitto-api/src/app/users/user-dossier.service.ts
• Modify: APIs/backend-vitto-api/src/app/engine/memory-persistence.service.ts
• Modify: APIs/backend-vitto-api/src/app/engine/context-assembly.service.ts

2D: Dialectic Enrichment (1 session)

When Vitto doesn't know enough about a user, ask naturally:

• In UserDossierService.getOrCreateDossier(), compute missingFields[] from empty dossier sections
• Return missing fields alongside the brief in getDossierForPrompt()
• In ContextAssemblyService, if missingFields.length > 0, inject 1-2 natural questions into the system prompt: "If natural in the conversation, ask about: {field}. Don't force it."
• User answers feed into existing memory extraction pipeline → dossier hydration on next interaction

Track 3: WHATSAPP-NATIVE PLATFORM MANAGEMENT (S203 — The Demo That Wins)

Goal: Users manage their entire platform from WhatsApp — generate, preview, deploy. Why: This is the feature no competitor has. This is the investor demo. Effort: 2 sub-sessions

3A: Conversational Generate + Deploy (1.5 sessions)

• Add generate_platform as a channel-safe tool in ToolRegistryService
• When triggered from WhatsApp, run the generation pipeline and stream progress as WhatsApp messages (not SSE)
• Use existing WhatsAppProgressEmitter for phase updates
• On completion, generate a screenshot preview via ComputerUseLoopService or a Playwright snapshot
• Send preview image as WhatsApp media message (requires Twilio media API integration)
• Ask for deploy confirmation: "Here's your platform. Deploy it? 👍"
• On confirmation, run StudioDeployController flow, send back the live URL

Files:

• Modify: APIs/backend-vitto-api/src/app/tools/tool-registry.service.ts (add channel-safe gen tool)
• Modify: APIs/backend-vitto-api/src/app/engine/channel-processing.service.ts (generation flow)
• Modify: APIs/backend-vitto-api/src/app/connectivity/channel-gateway.service.ts (media messages)
• New: APIs/backend-vitto-api/src/app/engine/channel-gen-flow.service.ts (conversational gen flow)

3B: WhatsApp Platform Management Commands (0.5 session)

Natural language commands that work from WhatsApp:

• "Add a special offers section" → triggers module generation for that specific module
• "Show me my analytics" → queries space analytics, returns formatted summary
• "Who visited my site today?" → queries Cloudflare analytics
• "Update my menu prices" → opens an edit context with edit_module_file tool
• "Deploy my latest changes" → runs deploy pipeline

These work because Vitto already has the tools. The gap is making them feel natural in a chat context (no buttons, no UI — just conversation).

Track 4: VITTO GETS SMARTER OVER TIME (S204 — Intelligence)

Goal: Vitto learns from successful tasks and reuses that knowledge. Why: This is the compounding advantage. Every interaction makes Vitto better. Effort: 3 sub-sessions

4A: Skill Generation (1.5 sessions)

When Vitto successfully completes a complex task:

• Create VittoSkill schema: taskType, approach, tools used, pitfalls, scope (platform vs space), embedding
• Hook into task completion in VittoEngineService
• Quality gate: only generate skills from first-attempt successes with user confirmation
• Use Haiku to compress task + approach into a skill document (~$0.002)
• Store with vector embedding in vitto-mind
• Multi-tenant scope: space-learned skills stay in that space unless promoted

4B: Skill Retrieval + Injection (1 session)

Before executing new tasks, check for relevant past skills:

• skillService.findRelevant(taskDescription, spaceId) — MongoDB vector search, scope-filtered
• Inject top 3 skills into system prompt as "Past experience that may help"
• Track: did the skill actually help? (outcome tracking)

4C: Business Insight Service (0.5 session)

Cross-space pattern recommendations:

• Track which modules each space type has (restaurant, fitness, etc.)
• Compare against other spaces of same type
• Identify gaps: "80% of fitness spaces have class-scheduling. You don't."
• Generate proactive suggestions via existing ProactiveReachService

Track 5: RELIABILITY (S203-S204 — Foundation)

Goal: Long-running tasks survive crashes. Agent behavior is regression-tested. Why: Can't build intelligence on an unreliable foundation. Effort: 3.5 sub-sessions

5A: Golden Path Regression Tests (1 session)

20 test scenarios covering every major Vitto capability. Run before any agent refactor.

• JSON fixtures: input, expectedToolCalls, expectedOutputContains, forbiddenActions
• Test runner service in backend-vitto-api/src/app/engine/__tests__/golden-paths/
• Pass criteria: all 20 pass = safe to refactor

5B: Agent Checkpointing (1.5 sessions)

Redis-backed state persistence at each decision boundary:

• CheckpointService serializes agent loop state before each tool call
• On process crash + restart, recoverActiveTasks() loads checkpoint and resumes
• Key: checkpoint:{taskId}:{iteration}, TTL = session timeout

5C: BullMQ Circular Dependency Fix (1 session)

Replace sync HTTP cycle (ai-api ↔ vitto-api) with async queue:

• VittoClientService.orchestrate() drops job on BullMQ queue
• TaskQueueService in backend-vitto-api picks it up
• Response via existing WebSocket relay

Track 6: UNIT ECONOMICS (S203-S204 — Business-Critical)

Goal: Know what everything costs, price correctly, prove viability. Why: Can't raise, can't scale, can't survive without this. Effort: 2 sub-sessions

6A: Cost-Per-Feature Endpoint (0.5 session)

• GET /observatory/cost-by-feature — groups LlmCostTrackerService records by caller
• Returns: { caller, totalCost, avgCost, requestCount }[]
• Immediate insight: "module generation costs $0.12 avg, chat costs $0.03 avg"

6B: Fix Cost Alert Approximation (0.5 session)

• Add getCostSince(timestampMs) to LlmCostTrackerService
• CostAlertService uses actual per-hour records, not total/24

6C: VWU Pricing Spec (0.5 session — design doc only)

• Define what counts as a "Vitto Work Unit"
• VWU weights per action type
• Pricing tiers (free: 50/mo, pro: 500/mo at $29, business: 2000/mo at $99)
• Dispute window, cost target, measurement method

6D: Proactive Auto-Tuning (0.5 session)

• Track proactive message engagement rate per user
• Auto-adjust confidence threshold: high engagement → lower bar, low engagement → higher bar
• Prevents "notification fatigue" while maximizing value for engaged users

Track 7: OPERATIONAL HARDENING (S205+ — Infrastructure)

Goal: Webhooks never drop, MCP tools are per-platform, health is standardized. Effort: 4 sub-sessions

7A: Cloudflare Edge Gateway (2 sessions)

• vitto-gateway Worker: acknowledge webhooks at edge (<100ms), forward to Railway
• Dead letter to Durable Objects if Railway is down, cron retry every 5min
• vitto-pulse Worker: ping all 4 backends every 30s, status page

7B: MCP Per-Platform Tool Filtering (1 session)

• Filter tool list based on detectPlatform().type
• Cursor: code-focused tools. Desktop: desktop-control. Web: chat-optimized.

7C: Health Standardization (1 session)

• Unified health endpoint format across all 4 backends
• Environment variable documentation
• Deprecated code removal

Track 8: THE NETWORK EFFECT (S206+ — The Unicorn Play)

Goal: Every user makes Vitto smarter for all users. Effort: 4 sub-sessions (after 1000+ users)

8A: Platform-Level Skill Aggregation (2 sessions)

• Weekly cron: cluster space-scoped skills with >0.92 similarity
• If 10+ spaces independently discover the same pattern → candidate for promotion
• Human review queue for approval
• Anonymize, promote to scope: 'platform'

8B: Voice Message Support (2 sessions)

• WhatsApp voice notes → Whisper → text → Vitto → TTS → voice note back
• User preference: voiceResponses: boolean in dossier
• Opt-in: first voice note triggers "Want me to respond with voice too?"

Session Allocation

The Three Milestones That Matter

Milestone 1: "It Works" (End of S202)

A user describes a platform → Vitto generates it → it appears in Studio → it deploys to a live URL. The rollback works. The cost is known. Regression tests protect against breakage.

This is the minimum viable demo.

Milestone 2: "It Knows Me" (End of S203)

Vitto adapts its personality to how you communicate. It references your shared history. It asks questions to learn about you. You can manage your entire platform from WhatsApp — generate, preview, deploy, edit — all in a conversation.

This is the demo that makes investors say "holy shit."

Milestone 3: "It Gets Smarter" (End of S204)

Vitto learns from every successful task. It recommends modules based on what similar businesses use. It survives crashes mid-task. You know exactly what each Vitto action costs and charge per outcome.

This is the business that can raise a Series A.

What We're NOT Building (And Why)

The Competitive Moat (Honest Assessment)

What no competitor has:

1. Multi-channel AI that knows your business (WhatsApp + web + desktop + mobile + extensions)
2. Configurable AI personality with adaptive learning (5 presets + custom + auto-adaptation)
3. Per-user dossier with per-space context, relationship memory, and job mastery tracking
4. Proactive monitoring with channel-routed alerts and severity escalation
5. Trust escalation with adaptive thresholds (the agent earns autonomy over time)
6. Generate → Edit → Deploy lifecycle managed by a persistent AI partner

What competitors do better:

1. Generation speed (Bolt: 30s vs our 5-10min)
2. UI polish (v0's preview-in-editor is seamless)
3. Proven scale (Bolt has public user numbers; we have zero)

The honest truth: We have more infrastructure than anyone in our category. The gap is proving it works with real users and polishing the experience. Tracks 1-3 close that gap.

Key File Reference

Platform Builder

Super Agent — Intelligence

Super Agent — Resilience

Prepared March 11, 2026 — Sessions 201-202 This document is the single source of truth for GoGrab + Vitto engineering priorities. It supersedes: UNIFIED-VITTO-MASTER-PLAN.md, vitto-more-reliable-intelligence.plan.md, vitto-unicorn-features.plan.md