Core Promise: Your business remembers everything, so you don’t have to.

• "I'll send you the revised mockups by Tuesday." (WhatsApp)
• "Can we review the contract terms next week?" (Email)
• "Client hasn't replied to the invoice sent 5 days ago." (Stripe/Email)
• "Client mentioned they are on vacation until Friday." (Phone call note)

Traditional Flow:
Client Chat ──> Copy info ──> Open CRM ──> Select Client ──> Edit Deal Stage ──> Set Reminder ──> Alert Spam (High Fatigue)

Luma Flow:
Client Chat ──> Quick text dump ("Sent mockups to Sarah, follow up Thursday") ──> Luma remembers & resurfaces on Thursday (Zero Burden)

1. Calm Intelligence: The system filters out noise and shows only what matters today. No notification spam, no badge counts, no alert fatigue.
2. Reliability (Temporal Memory): Nothing disappears. Commitments, client silences, delays, and context persist across time.
3. Invisible Structure: Complex multi-tiered parsing and intent state machines execute under the hood without exposing administrative complexity.
4. Intent Over Binary Completion: Marking an item "done" in client work is a fallacy. Work is either followed through, deferred, or waiting on external feedback.
5. Respect for Attention: The software does not demand continuous user engagement. It acts as a quiet, dependable partner that speaks only when needed.

// lib/luma-parser.ts - Structured Extraction Schema
export interface ParsedMemoryEvent {
  type: "client" | "memory_event";
  client: {
    name: string;
    company: string | null;
    email: string | null;
  };
  memoryEvent: {
    type: "fact" | "commitment" | "interaction";
    text: string;
    dueDate: string | null; // ISO Date YYYY-MM-DD
    dueTime: string | null; // 24h format HH:mm
  } | null;
  confidence: number;
}

• Robust Self-Repair Loop: If initial JSON parsing fails or schema validation fails via Zod, the pipeline triggers an automated repair prompt before fallback handling.
• Entity Resolution: Automatically detects existing clients by fuzzy matching name and company context, preventing profile duplication.

• Pending Commitments: Items with approaching or past due dates.
• Client Silence Signals: Tracking last interaction timestamps; flags clients entering quiet (5+ days) or at_risk (10+ days) states without spamming notifications.
• Temporal Reactivation: Items marked as Waiting or Deferred automatically re-surface when their scheduled follow-up window arrives or if new client interactions occur.

// Pure deterministic function computing daily attention state
export function computeAttentionState(
  clients: Client[],
  memoryEvents: MemoryEvent[],
  actionRecords: ActionRecord[],
  currentTime: Date
): AttentionCard[] {
  const cards: AttentionCard[] = [];
  
  // 1. Evaluate commitments against today's temporal boundary
  // 2. Evaluate unmonitored client silence thresholds
  // 3. Re-evaluate deferred intent records past their followUpAt timestamp
  
  return cards.sort((a, b) => getUrgencyScore(b) - getUrgencyScore(a));
}

• Pending: Commitment awaiting initial action.
• In Progress: Currently being worked on.
• Waiting: Blocked on client reply or external dependency (automatically pauses until follow-up threshold).
• Deferred: Intentionally snoozed with a defined re-activation date.
• Resolved: Successfully completed and recorded into the relationship history.

• Followed Through (Records resolution + timestamp)
• Waiting on Client (Snoozes card and sets a silence monitor)
• Delay / Postpone (Defers item to tomorrow or next week)

• Status Signal: Real-time health badge (Active, Quiet, At Risk).
• Contextual Facts: Permanent preferences (e.g., "Prefers WhatsApp over email", "Fiscal year starts in April").
• Commitment History: Auditable trail of fulfilled, delayed, and open deliverables.
• Interaction Log: Complete touchpoint record.

:root {
  /* Core Neutrals */
  --background: oklch(0.985 0.002 90);    /* Soft off-white */
  --foreground: oklch(0.12 0.01 60);      /* Deep charcoal */
  --card: oklch(1 0 0);                   /* Pure white container */
  
  /* Hierarchy Grays */
  --secondary: oklch(0.96 0.005 90);      /* Subtle surface fills */
  --muted-foreground: oklch(0.45 0.02 60);/* Medium slate gray */
  --border: oklch(0.88 0.01 90);          /* 1px structural lines */
  
  /* Functional Accent */
  --destructive: oklch(0.577 0.245 27.3); /* Coral for critical alerts */
}

• 8px Base Unit Grid: Strict rhythm across p-2 (8px), p-4 (16px), p-6 (24px), and p-12 (48px).
• Section Eyebrow Dividers: Standardized section markers pairing an 8px line with monospace tracking.

• Animated Sphere: Geometric mesh with procedural vertex displacement representing dynamic memory nodes.
• Animated Tetrahedron: Minimalist rotating wireframe symbolizing intent triangulation.
• Subtle Noise Texture: Overlay layer (fractalNoise SVG filter) providing physical paper-like texture.

┌─────────────────────────────────────────────────────────────┐
│                    Next.js 16 (App Router)                  │
├──────────────────────────────┬──────────────────────────────┤
│        Frontend UI           │        API & Backend         │
│  • React 19 Server/Client    │  • App Route Handlers        │
│  • Tailwind CSS v4           │  • OpenAI GPT-4o-mini API    │
│  • Radix UI + Lucide         │  • Zod Extraction Validation │
│  • Three.js / R3F Canvas     │  • Deterministic Engines     │
│  • Sonner & Vaul Drawers     │  • Clerk Auth & Multi-tenant │
└──────────────────────────────┴──────────────────────────────┘

• React Server Components (RSC): Static marketing layouts and data wrappers delivered with zero client-side JavaScript overhead.
• Optimized Dynamic Imports: Heavy Three.js canvas components dynamically imported with ssr: false to ensure fast initial Largest Contentful Paint (LCP < 0.8s).
• Zero Heavy State Libraries: Managed through focused React Context and localized custom hooks, avoiding bulky global state dependencies.

1. Invisible UI Over Rich Dashboards: High-growth enterprise software continuously adds charts and metrics. For independent professionals, the best UI is often a single clean sentence stating what needs attention today.
2. Deterministic Rules + AI Extraction: Using LLMs exclusively for extraction/structuring and utilizing pure deterministic algorithms for scheduling and attention scoring creates a 100% predictable, hallucination-free user experience.
3. Typography as Brand Moat: Investing in refined typography (Instrument Serif paired with Instrument Sans) created a distinct brand identity that felt calm, premium, and trustworthy.

FIG 01: Desktop Daily Focus & Attention Scoring

FIG 02: Mobile Conversational Capture & Focus Queue