Key User Flows

PDeck Key User Flows

This document outlines the key user flows in the PDeck system, providing a comprehensive view of how the system interacts with users and its internal components. Each flow is represented by a sequence diagram that illustrates the process step-by-step.

Table of Contents

  1. Reviewing a Task's Priority
  2. Task Generation from a Meeting
  3. Handling Real-Time Updates
  4. Integrating with Third-Party Tools
  5. Customizing Notifications and Preferences

1. Reviewing a Task's Priority

This flow demonstrates how a user reviews and adjusts the priority of a task within PDeck.

sequenceDiagram
    actor U as User
    participant UI as User Interface
    participant API as API Layer
    participant TPE as Task Prioritization Engine
    participant KGM as Knowledge Graph Module
    participant CL as Change Log
 
    U->>UI: Log in and view priority deck
    UI->>API: Request current priority deck
    API->>TPE: Get prioritized tasks
    TPE->>KGM: Fetch task contexts
    KGM-->>TPE: Return task contexts
    TPE-->>API: Return prioritized tasks
    API-->>UI: Display priority deck
 
    U->>UI: Select a task
    UI->>API: Request task details
    API->>TPE: Get task details
    TPE->>KGM: Fetch task context
    KGM-->>TPE: Return task context
    TPE-->>API: Return task details
    API-->>UI: Display task details
    UI->>U: Show Prompt 2: "Does this task have a time-sensitive deadline or significant impact on your business outcomes?"
 
    U->>UI: Review task details and context
    U->>UI: Adjust task priority
    UI->>API: Update task priority
    API->>TPE: Process priority change
    TPE->>KGM: Update task relationships
    TPE->>CL: Log priority change
    TPE-->>API: Confirm priority update
    API-->>UI: Update deck order
    UI->>U: Show Prompt 13: "You've reprioritized '[Task]'. Does this still reflect the most important task in your deck, or should something else take its place?"
 
    U->>UI: Confirm changes
    UI->>API: Finalize priority changes
    API->>TPE: Save final priorities
    TPE->>KGM: Update knowledge graph
    TPE->>CL: Log final changes
    TPE-->>API: Confirm updates
    API-->>UI: Display updated deck
    UI->>U: Show updated priority deck

2. Task Generation from a Meeting

This flow illustrates how PDeck generates tasks from a meeting and allows the user to review and prioritize them.

sequenceDiagram
    actor U as User
    participant UI as User Interface
    participant API as API Layer
    participant DIP as Data Integration/Parsing
    participant MA as Meeting Assistant
    participant TPE as Task Prioritization Engine
    participant KGM as Knowledge Graph Module
 
    U->>UI: Attend meeting
    UI->>API: Signal meeting start
    API->>MA: Start recording/transcribing
    MA-->>API: Provide real-time transcript
    API->>DIP: Process transcript
    DIP->>KGM: Update knowledge graph with meeting data
    DIP->>TPE: Generate potential tasks
    TPE->>KGM: Contextualize tasks
    KGM-->>TPE: Provide task contexts
    TPE-->>API: Return generated tasks
    API-->>UI: Notify of new tasks
    UI->>U: Show prompt: "We've generated new tasks from your meeting with [Team/Client]. Would you like to review and prioritize them now?"
 
    U->>UI: Review generated tasks
    UI->>API: Send task confirmations/edits
    API->>TPE: Process task updates
    TPE->>KGM: Update task relationships
    TPE-->>API: Return updated task list
    API-->>UI: Display updated tasks
    UI->>U: Show prompt: "These tasks have been added to your deck. Do you want to adjust their priorities based on upcoming deadlines or dependencies?"
 
    U->>UI: Adjust priorities (if needed)
    UI->>API: Send priority adjustments
    API->>TPE: Process priority changes
    TPE->>KGM: Update knowledge graph
    TPE-->>API: Confirm priority updates
    API-->>UI: Display final task deck
    UI->>U: Show updated priority deck

3. Handling Real-Time Updates

This flow shows how PDeck handles real-time updates from external sources and suggests priority changes to the user.

sequenceDiagram
    participant ES as External Source
    participant DIP as Data Integration/Parsing
    participant API as API Layer
    participant TPE as Task Prioritization Engine
    participant KGM as Knowledge Graph Module
    participant UI as User Interface
    actor U as User
 
    ES->>DIP: Send new data (email/calendar/task update)
    DIP->>KGM: Update knowledge graph
    DIP->>TPE: Notify of new data
    TPE->>KGM: Query for impact on tasks
    KGM-->>TPE: Return affected tasks
    TPE->>TPE: Recalculate priorities
    TPE->>API: Send priority update
    API->>UI: Notify of priority change
    UI->>U: Show Prompt 12: "Based on recent updates, we suggest moving '[Task]' up due to an urgent email from the client. Would you like to adjust now?"
 
    U->>UI: Review suggested changes
    UI->>API: Send user decision
    API->>TPE: Process user decision
    TPE->>KGM: Update task relationships
    TPE-->>API: Confirm updates
    API-->>UI: Update task deck
    UI->>U: Show updated priority deck
    UI->>U: Show Prompt 6: "You've moved '[Task]' up in priority. How does this align with your long-term goals or client commitments?"
 
    U->>UI: Provide feedback (optional)
    UI->>API: Send user feedback
    API->>KGM: Update knowledge graph with feedback
    KGM-->>API: Confirm update
    API-->>UI: Acknowledge feedback

4. Integrating with Third-Party Tools

This flow demonstrates the process of integrating PDeck with a third-party tool and syncing data.

sequenceDiagram
    actor U as User
    participant UI as User Interface
    participant API as API Layer
    participant IM as Integration Module
    participant TPT as Third-Party Tool
    participant DIP as Data Integration/Parsing
    participant TPE as Task Prioritization Engine
    participant KGM as Knowledge Graph Module
 
    U->>UI: Navigate to integration settings
    UI->>API: Request available integrations
    API->>IM: Get integration list
    IM-->>API: Return integration options
    API-->>UI: Display integration options
 
    U->>UI: Select tool to integrate (e.g., Gmail)
    UI->>API: Request integration
    API->>IM: Initiate integration
    IM->>TPT: Request authentication
    TPT-->>U: Prompt for authentication
    U->>TPT: Provide credentials
    TPT-->>IM: Grant access token
    IM->>DIP: Configure data sync
 
    DIP->>TPT: Initial data fetch
    TPT-->>DIP: Return data
    DIP->>KGM: Update knowledge graph
    DIP->>TPE: Process new data
    TPE-->>API: Return updated tasks
    API-->>UI: Integration complete
    UI->>U: Show prompt: "Integration with [Tool] is complete. Would you like to review any new tasks or updates that may affect your current priorities?"
 
    U->>UI: Review new tasks/updates
    UI->>API: Send user decisions
    API->>TPE: Process user input
    TPE->>KGM: Update task relationships
    TPE-->>API: Confirm updates
    API-->>UI: Display updated task deck
    UI->>U: Show updated priority deck

5. Customizing Notifications and Preferences

This flow illustrates how a user can customize their notification settings and preferences within PDeck.

sequenceDiagram
    actor U as User
    participant UI as User Interface
    participant API as API Layer
    participant PM as Preference Manager
    participant NM as Notification Manager
    participant TPE as Task Prioritization Engine
 
    U->>UI: Open settings menu
    UI->>API: Request current preferences
    API->>PM: Get user preferences
    PM-->>API: Return preferences
    API-->>UI: Display current settings
 
    U->>UI: Adjust notification settings
    UI->>U: Show prompt: "Would you like to receive end-of-day reflective prompts to help assess your daily progress?"
    U->>UI: Respond to prompt
    UI->>API: Update notification preferences
    API->>NM: Apply new notification settings
    NM-->>API: Confirm settings update
 
    U->>UI: Customize display options
    UI->>API: Update display preferences
    API->>PM: Save new preferences
    PM-->>API: Confirm preference update
    API->>TPE: Adjust task display based on new preferences
    TPE-->>API: Return updated task view
    API-->>UI: Apply new interface settings
    UI->>U: Display updated interface
 
    U->>UI: Save all changes
    UI->>API: Finalize preference updates
    API->>PM: Save final preferences
    API->>NM: Finalize notification settings
    PM-->>API: Confirm all updates
    NM-->>API: Confirm notification settings
    API-->>UI: Confirm successful update
    UI->>U: Show confirmation message

These sequence diagrams provide a detailed view of the key flows in the PDeck system, incorporating the prompting framework at relevant points. They illustrate the interactions between various components of the system and the user, showing how data flows and decisions are made throughout each process.

Front End