Resumay_I: Engineering AI Autonomy

Welcome to the End-to-End AI Orchestrator, a state-of-the-art intelligent system disguised as a Microsoft Outlook Add-in. This project acts as a "Velvet Rope" proxy and control plane for your digital life, protecting your Deep Work slots by intercepting, analyzing, and scheduling incoming tasks using high-granularity prompt architectures and Agentic AI workflows.

By ingesting your code, documents, and communication history, the Orchestrator doesn't just manage your calendar—it acts as a Career Refinery, actively transforming your static output into dynamic, highly viable professional narratives.

This project implements an advanced Multi-Agent Orchestration platform disguised as a Microsoft Outlook Add-in. Rather than relying on rigid, linear pipelines, the application utilizes a decentralized, autonomous agentic fabric consisting of a central Orchestrator Agent, a Multi-Tier Semantic Router, and a Message-Driven Two-Phase RAG Ingestion Pipeline. It is designed to act as an intelligent gateway, converting raw external context into actionable, persona-driven knowledge nodes while dynamically dodging service limits through proactive "tier jumping" and intelligent queue management.

Drawing from standard Multi-Agent Reference Architectures, the system separates concerns into discrete bounds, reflecting a robust distributed system design.

Designed within the constraints of the Microsoft Office Add-in iFrame sandbox, this layer serves as the primary gateway.

• src/components/: Houses the modular, React 18/Vite-based User Interface (e.g., KnowledgeIngestion.tsx, ChatPanel.tsx). It abstracts the task pane and Ribbon commands, acting as the trigger surface for human overrides and context injections.
• src/services/graphService.ts & src/services/ribbonManager.ts: Implement Microsoft Graph API integration via secure OAuth PKCE exchanges and synchronize state across disjointed runtimes using Office roaming settings.

The Distributor serves as the system's central nervous system—acting as the core Orchestrator Agent.

• Queue Management: Implements a localized "Leaky Bucket" strategy, utilizing a strict 30-second cycle lock for background processing to mitigate burst traffic and preserve free-tier limits.
• Workflow Management: Governs state, maintains long-running processes (e.g., massive repository ingestions), and dispatches task commands to specialized agents using a Message-Driven Communication paradigm.

• Intent Resolution: Intercepts tasks and determines optimal routing to specialized agents.
• Failover / Escalation: Dynamically shifts traffic along tiered architectural routes (e.g., Tier 1: Gemini Pro/Flash vs. Tier 2: GitHub Models REST) based on confidence thresholds and quota ceilings to ensure high availability.

The architecture diverges into a multi-phase system for grounding facts, mitigating hallucination via high-fidelity context structures.

• Backend Extraction: Node.js endpoints strictly parse, chunk, and securely back up raw input directly to localized git storage (gitStorageService), eliminating data loss during timeouts.
• Resilient Requeuing (src/components/KnowledgeIngestion.tsx): The UI utilizes Git Recovery capabilities to iterate through cached chunks. It dispatches them back into the Orchestrator queue (Distributor.ts) using Message-Driven Parallel Fan-Out for asynchronous semantic embedding and database upserting.
• Inspiration Separation (EXTERNAL_INSPIRATION): Prevents pollution of the primary RAG silo (which represents the user's authentic skills) by separating social/web techniques into a fully isolated "Inspiration" query boundary (FETCH_INSPIRATIONS).

• Contains foundational rules (core.ts, constants.ts, types.ts) for enforcing system limitations and shared agent data schemas, ensuring consistent interactions throughout the Dynamic Agent Registry.

The following sequence details how the robust agentic context is built via the two-phase pipeline pattern, utilizing asynchronous messaging.

sequenceDiagram
    title Multi-Agent Workflow: Two-Phase RAG and Message-Driven Delegation

    participant User
    participant Frontend as Frontend (Taskpane)
    participant Backend as Backend Ingestion Route
    participant GitStore as Local Git Store
    participant Dist as Orchestrator Agent (Distributor)
    participant AI as Specialized Agents (Multi-Tier)
    participant VectorDB as Vector Database

    User->>Frontend: Upload file / URL / Sync Repo
    Frontend->>Backend: Post Raw Payload
    Backend->>Backend: Chunk Payload
    Backend->>GitStore: Stash raw chunks (.nexus lineage)
    GitStore-->>Backend: Backup successful
    Backend-->>Frontend: Return chunk array

    loop Dynamic Chunk Processing (Parallel Fan-Out)
        Frontend->>Dist: Dispatch TRIAGE command message
        Dist->>AI: Evaluate Persona (e.g., Recruiter vs Engineer)
        AI-->>Dist: Return Extracted Skill Nodes
        
        loop Chained Task Sequencing
            Dist->>AI: Dispatch EMBEDDING command message
            AI-->>Dist: Return Float Vector
            Dist->>VectorDB: /api/vector/upsert
            VectorDB-->>Dist: Success
        end
    end

    Frontend->>User: RAG Grounding Complete

The architecture utilizes standardized Multi-Agent Patterns but injects crucial context-specific deviations (enhancements) to ensure unparalleled fault tolerance.

Standard Pattern: Request-Based Synchronous RAG pipeline handles indexing and processing within a single HTTP lifecycle. Architectural Deviation: The system separates the extraction of data from the semantic embedding of data via a Message-Driven broker structure. Backend extraction creates a bulletproof local backup. The frontend then offloads classification (TRIAGE) and embedding back to the Orchestrator Agent's queue using Chained Task Sequencing and Parallel Fan-Out. Why: This completely averts hard VM timeout boundaries. If an embedding throttles, the Orchestrator intelligently handles retry/requeuing mechanisms to ensure fault tolerance.

Standard Pattern: Basic Semantic Router with static LLM configurations. Implementation: Implements a dynamic failover matrix that functions as a highly available Agent Registry.

• Tier 1: Routes high volume RAG processing requests to Gemini free-tier limits.
• Tier 2 (Route C): Routes highly complex, logic-heavy planning requests to Azure gpt-4o integrations utilizing GitHub Models Direct REST calls. This hierarchy preserves localized GPU logic validation and reserves cost-effective models for large document indexing.

Standard Pattern: Schedulers treat calendars as collections of Date objects and allow infinite back-to-back bookings. Architectural Deviation: The system treats time as a discrete resource block ("BusLine" or BusBar) and applies constraint-solving physics to it. It is not a date planner; it's an algorithmic burnout-preventer execution mechanism. To achieve this autonomously, the system runs a physically segregated backend orchestrator comprising schedulerDaemon, physicsCore, and busHydrator.

• Auto-Scheduling Loop: The daemon analyzes newly captured tasks and synchronizes Graph API states without frontend intervention.
• Timezone-Agnostic Hydration: The busHydrator queries the user's localized mailboxSettings to offset the matrix dynamically, mapping Graph API representations directly into local 15-minute chunk dimensions without "time travel" overlap bugs.
• AI-Driven Dimensional Extraction: Tasks are assigned physical properties—Voltage (Priority), Amperage (Duration + 20% Buffer), and Gravity (Preferred Time of Day) dictating where a task wants to "settle" in the matrix.
• The Breather Protocol: The engine inherently refuses dense, back-to-back packaging. Once physicsCore finds contiguous null chunks that accommodate the inflated Amperage, it immediately burns a [[BREATHER]] slot afterward to logically enforce a physiological cooldown period.
• Bus Abstraction: Transactions are calculated on a one-dimensional mathematical array of chunks, preventing multiple tasks from occupying the same space-time coordinates. Once seamlessly scheduled, tasks update natively in To-Do to prevent duplicate loops.

Standard Pattern: Unified single-thread execution in web environments. Implementation: Microsoft Outlook strictly enforces completely segregated runtimes between Ribbon UI commands and Taskpane applications. The architecture employs a localized state messaging protocol utilizing the Office.context.roamingSettings layer. The Orchestrator Agent guarantees unified cross-runtime coordination through synchronized saveAsync() triggers, acting as an implicit distributed ledger for disjointed UI components (src/services/ribbonManager.ts).

• Zero-Trust Access Management: Specialized Agents APIs never output standard variables directly to client scopes. The AI pipeline evaluates tasks and selectively triggers "Route M" Manual User Overrides—forcing physically approved explicit requests if delegation encounters extreme ambiguity.
• Public Network Immunity: Manifest structures strictly enforce loopback shields on local networks. The development server bindings are locked to 127.0.0.1:3000 locally, shifting to 0.0.0.0:PORT fully segregated by NODE_ENV in production to prevent IP leakage.
• Watcher Lock Mechanisms: Hardened local watcher scripts lock the baseline workflow codebase via the MODWA command protocol, enforcing system integrity constraints.