diff --git a/.gitignore b/.gitignore
index 0ec2a59..35c9e40 100644
--- a/.gitignore
+++ b/.gitignore
@@ -82,3 +82,4 @@ Cargo.lock
 # Environment files with credentials
 temp.env
 *.env.local
+.langgraph_api/
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/app/agent/__init__.py b/backend/app/agent/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/app/agent/graph.py b/backend/app/agent/graph.py
new file mode 100644
index 0000000..4579c38
--- /dev/null
+++ b/backend/app/agent/graph.py
@@ -0,0 +1,47 @@
+"""FRIDAY agent graph — ReAct loop architecture.
+
+Graph structure:
+    START → preprocess → agent ←→ tools (loop) → postprocess → END
+
+The agent autonomously decides when to call tools and when to respond.
+No separate intent classifier LLM call — just keyword-based triage detection.
+"""
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, START, END
+
+from .state import FridayState
+from .nodes import (
+    preprocess_node,
+    agent_node,
+    tool_executor_node,
+    postprocess_node,
+    should_continue,
+)
+
+# Build the graph
+graph = StateGraph(FridayState)
+
+# Nodes
+graph.add_node("preprocess", preprocess_node)
+graph.add_node("agent", agent_node)
+graph.add_node("tools", tool_executor_node)
+graph.add_node("postprocess", postprocess_node)
+
+# Edges
+graph.add_edge(START, "preprocess")
+graph.add_edge("preprocess", "agent")
+graph.add_conditional_edges(
+    "agent",
+    should_continue,
+    {"tools": "tools", "postprocess": "postprocess"},
+)
+graph.add_edge("tools", "agent")  # ReAct loop: tools always go back to agent
+graph.add_edge("postprocess", END)
+
+# Compile with checkpointer for FastAPI standalone mode
+checkpointer = MemorySaver()
+friday_graph = graph.compile(checkpointer=checkpointer)
+
+# For LangGraph Platform (it provides its own checkpointer)
+friday_graph_platform = graph.compile()
diff --git a/backend/app/agent/nodes.py b/backend/app/agent/nodes.py
new file mode 100644
index 0000000..d93140e
--- /dev/null
+++ b/backend/app/agent/nodes.py
@@ -0,0 +1,223 @@
+"""FRIDAY agent nodes — ReAct loop with autonomous tool execution."""
+
+import json
+import logging
+
+from langchain_core.messages import AIMessage, SystemMessage, ToolMessage
+from langchain_openai import ChatOpenAI
+
+from config import settings
+from services.store import store
+
+from .prompts import build_system_prompt, TRIAGE_KEYWORDS
+from .tools.registry import ALL_TOOLS
+
+logger = logging.getLogger(__name__)
+
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+# ---------- LLM singletons ----------
+
+_llm = None
+
+
+def _get_llm():
+    global _llm
+    if _llm is None:
+        _llm = ChatOpenAI(
+            model="google/gemini-2.5-flash",
+            api_key=settings.openrouter_api_key,
+            base_url=OPENROUTER_BASE_URL,
+            temperature=0.3,
+        )
+    return _llm
+
+
+# ---------- Helper ----------
+
+def _extract_text(msg) -> str:
+    """Extract plain text from a message, handling multimodal content blocks."""
+    raw = msg.content if hasattr(msg, "content") else str(msg)
+    if isinstance(raw, list):
+        return " ".join(
+            block.get("text", "") if isinstance(block, dict) else str(block)
+            for block in raw
+        )
+    return str(raw)
+
+
+def _detect_intent(text: str) -> str:
+    """Fast keyword-based intent detection. No LLM call needed."""
+    text_lower = text.lower()
+    for keyword in TRIAGE_KEYWORDS:
+        if keyword in text_lower:
+            return "triage"
+    return "chat"
+
+
+# ---------- Nodes ----------
+
+async def preprocess_node(state: dict) -> dict:
+    """Load user context, tasks, and semantic memory."""
+    user_id = state.get("user_id", "default")
+
+    # Load user context from in-memory store
+    user_context_list = store.get_user_context(user_id)
+    if isinstance(user_context_list, list):
+        user_context = {
+            entry.get("context_key", str(i)): entry
+            for i, entry in enumerate(user_context_list)
+        }
+    else:
+        user_context = user_context_list if isinstance(user_context_list, dict) else {}
+
+    # Load active tasks
+    active_tasks = store.get_tasks(user_id, status="pending", limit=10)
+    active_tasks += store.get_tasks(user_id, status="in_progress", limit=10)
+
+    # Search semantic memory
+    semantic_context = []
+    messages = state.get("messages", [])
+    if messages:
+        content = _extract_text(messages[-1])
+        try:
+            from .tools.memory_tools import _sm_client
+            if _sm_client:
+                results = await _sm_client.search.execute(
+                    q=content[:500],
+                    container_tags=[user_id],
+                    limit=3,
+                )
+                if hasattr(results, "results"):
+                    semantic_context = [
+                        {"content": r.content or "", "score": getattr(r, "score", None)}
+                        for r in results.results
+                        if r.content
+                    ]
+        except Exception as e:
+            logger.warning(f"Semantic memory search failed: {e}")
+
+    # Detect triage intent from last message
+    last_text = _extract_text(messages[-1]) if messages else ""
+    intent = _detect_intent(last_text)
+
+    # Trim messages to last 20
+    trimmed = messages[-20:] if len(messages) > 20 else messages
+
+    return {
+        "user_context": user_context,
+        "active_tasks": active_tasks,
+        "semantic_context": semantic_context,
+        "messages": trimmed,
+        "intent": intent,
+    }
+
+
+async def agent_node(state: dict) -> dict:
+    """Core ReAct agent: call LLM with tools, let it decide what to do.
+
+    The LLM either:
+    - Returns tool_calls → routes to tool_executor (loop continues)
+    - Returns text response → routes to postprocess (loop ends)
+    """
+    llm = _get_llm()
+    llm_with_tools = llm.bind_tools(ALL_TOOLS)
+
+    system_prompt = build_system_prompt(state)
+    msgs = [SystemMessage(content=system_prompt)] + list(state.get("messages", []))
+
+    response = await llm_with_tools.ainvoke(msgs)
+
+    return {"messages": [response]}
+
+
+async def tool_executor_node(state: dict) -> dict:
+    """Execute tool calls from the agent's last message."""
+    messages = state.get("messages", [])
+    last_msg = messages[-1]
+
+    if not hasattr(last_msg, "tool_calls") or not last_msg.tool_calls:
+        return {}
+
+    tool_map = {t.name: t for t in ALL_TOOLS}
+    new_messages = []
+    user_id = state.get("user_id", "default")
+
+    for tc in last_msg.tool_calls:
+        tool_name = tc["name"]
+        tool_args = tc["args"]
+
+        if tool_name not in tool_map:
+            new_messages.append(ToolMessage(
+                content=f"Unknown tool: '{tool_name}'. Available tools: {', '.join(tool_map.keys())}",
+                tool_call_id=tc["id"],
+            ))
+            continue
+
+        try:
+            config = {"configurable": {"user_id": user_id}}
+            result = await tool_map[tool_name].ainvoke(tool_args, config=config)
+            new_messages.append(ToolMessage(
+                content=str(result),
+                tool_call_id=tc["id"],
+            ))
+        except Exception as e:
+            logger.error(f"Tool error ({tool_name}): {e}")
+            new_messages.append(ToolMessage(
+                content=f"Error executing {tool_name}: {e}. Try a different approach or check the command syntax with gws_schema.",
+                tool_call_id=tc["id"],
+            ))
+
+    return {"messages": new_messages}
+
+
+def should_continue(state: dict) -> str:
+    """Route after agent: if tool calls exist, loop back; otherwise finish."""
+    messages = state.get("messages", [])
+    if not messages:
+        return "postprocess"
+
+    last_msg = messages[-1]
+    if hasattr(last_msg, "tool_calls") and last_msg.tool_calls:
+        return "tools"
+    return "postprocess"
+
+
+async def postprocess_node(state: dict) -> dict:
+    """Save session data and learn patterns."""
+    session_id = state.get("session_id", "")
+    user_id = state.get("user_id", "default")
+
+    # Save last assistant message
+    messages = state.get("messages", [])
+    if messages:
+        last_msg = messages[-1]
+        if hasattr(last_msg, "type") and last_msg.type == "ai" and last_msg.content:
+            store.add_message(session_id, "assistant", last_msg.content)
+
+    store.update_session(session_id)
+
+    # Store session summary to semantic memory if tools were used
+    tool_msgs = [m for m in messages[-10:] if hasattr(m, "type") and m.type == "tool"]
+    if tool_msgs:
+        try:
+            from .tools.memory_tools import _sm_client
+            if _sm_client:
+                # Build a brief summary from the last AI message
+                last_ai = None
+                for m in reversed(messages):
+                    if hasattr(m, "type") and m.type == "ai" and m.content:
+                        last_ai = m
+                        break
+
+                if last_ai:
+                    summary = f"Session {session_id}: {last_ai.content[:200]}"
+                    await _sm_client.add(
+                        content=summary,
+                        container_tag=user_id,
+                        metadata={"type": "session_summary", "session_id": session_id},
+                    )
+        except Exception as e:
+            logger.warning(f"Failed to store session summary: {e}")
+
+    return {}
diff --git a/backend/app/agent/prompts.py b/backend/app/agent/prompts.py
new file mode 100644
index 0000000..b448dc7
--- /dev/null
+++ b/backend/app/agent/prompts.py
@@ -0,0 +1,241 @@
+"""FRIDAY prompt layers — composable system prompt architecture."""
+
+from datetime import datetime, timezone
+
+TRIAGE_KEYWORDS = [
+    "overwhelmed", "stressed", "drowning", "too much",
+    "can't cope", "help me focus", "prioritize", "what should i do",
+]
+
+ENVIRONMENT_LAYER = """You are powered by Gemini via OpenRouter.
+Current date and time: {date}
+Day of week: {day_of_week}
+User timezone: {timezone}
+
+When the user says "today", they mean {today_date}. When they say "tomorrow", they mean {tomorrow_date}.
+When creating calendar events, use ISO 8601 datetime format with the user's timezone offset.
+
+Capabilities:
+- Full access to Google Workspace via gws CLI (Gmail, Calendar, Drive, Docs, Sheets, Chat, Meet, Tasks, Keep, Forms, Slides, and more)
+- Pre-built workflow commands (+meeting-prep, +standup-report, +email-to-task, +triage)
+- Dynamic Google Workspace API schema discovery via gws_schema tool
+- Web search via Exa for real-time information (news, research, company info, documentation)
+- Task list management
+- Semantic memory that learns user patterns over time
+"""
+
+IDENTITY_LAYER = """You are FRIDAY, an AI workspace assistant designed specifically for people with ADHD.
+
+Your core philosophy:
+- The user is NOT lazy. They are overwhelmed. Your job is to reduce cognitive load.
+- Lead with the most important thing. Never present a wall of text.
+- Be warm but direct. No fluff. No "Great question!" — just help.
+- When the user says "I'm overwhelmed", switch to triage mode immediately.
+- Proactively surface what matters. Don't wait to be asked.
+
+Your personality:
+- Like a calm, competent executive assistant who genuinely cares
+- Brief by default. Detailed only when asked.
+- Uses bullet points and structure, never paragraphs
+- Acknowledges feelings without being patronizing
+"""
+
+
+def build_context_layer(state: dict) -> str:
+    parts = ["<user-context>"]
+
+    if state.get("active_tasks"):
+        tasks = state["active_tasks"][:5]
+        task_lines = []
+        for t in tasks:
+            task_lines.append(f"- [{t.get('priority', 'medium')}] {t.get('title', 'Untitled')} ({t.get('status', 'pending')})")
+        parts.append(f"Active tasks ({len(state['active_tasks'])}):\n" + "\n".join(task_lines))
+
+    if state.get("user_context"):
+        ctx = state["user_context"]
+        if isinstance(ctx, dict):
+            parts.append("Known preferences and patterns:")
+            for k, v in ctx.items():
+                if isinstance(v, dict):
+                    parts.append(f"- {k}: {v.get('context_value', v)}")
+                else:
+                    parts.append(f"- {k}: {v}")
+
+    if state.get("semantic_context"):
+        memories = state["semantic_context"][:3]
+        parts.append("Relevant memories:")
+        for m in memories:
+            content = m.get("content") or ""
+            if len(content) > 200:
+                content = content[:200] + "..."
+            parts.append(f"- {content}")
+
+    parts.append("</user-context>")
+    return "\n".join(parts)
+
+
+INSTRUCTION_LAYER = """## Behavioral Rules
+
+### Autonomy — YOU ARE FULLY AUTONOMOUS
+- DO NOT ask for permission before ANY read operation. Just do it.
+- NEVER say "Do you approve this search?" or "Shall I look that up?" — JUST DO IT.
+- Read emails, calendar, drive, tasks, contacts FREELY without asking.
+- Search the web FREELY without asking.
+- SEND emails and chat messages FREELY without asking — the user trusts you.
+- ONLY ask for confirmation before CREATING documents/events, UPDATING documents/events, or DELETING anything.
+  - The system automatically applies dry-run for these operations — just execute and show the preview.
+- When the user asks you to do something, DO IT immediately. Don't describe what you'll do — just do it.
+- If you need multiple pieces of information, call multiple tools IN PARALLEL.
+- After showing a dry-run preview, if the user confirms (e.g., "yes", "do it", "go ahead", "yup"), re-call gws() with the SAME command and force_execute=True. Do NOT add --force to the command string.
+
+### Self-Correction — FIX YOUR OWN ERRORS SILENTLY
+- If a gws command fails, DO NOT apologize, DO NOT explain the error to the user, DO NOT ask questions.
+- Just silently fix it and retry. The user should never see your debugging process.
+- You have THREE discovery tools to help you fix errors:
+  1. gws_help("service subcommand") — see CLI usage, flags, and examples
+  2. gws_schema("service.resource.method") — see API parameters and body schema
+  3. gws_help("service") — list available subcommands and helpers
+- When a command fails:
+  1. DO NOT output any text to the user. Immediately call gws_help or gws_schema.
+  2. Read the help/schema output. Construct the corrected command.
+  3. Retry with the corrected command.
+  4. Only speak to the user once you have a successful result OR after 3 failed attempts.
+- NEVER say "I'm sorry", "Let me try again", "It seems I had trouble with..." — just fix it silently.
+- NEVER ask the user to help you fix a command. Figure it out yourself.
+- NEVER retry the exact same failing command — always vary your approach.
+- NEVER ask the user questions unless you genuinely lack information that ONLY they can provide (e.g., "which calendar?", "what time?"). Technical errors are YOUR problem to solve.
+
+### gws CLI Usage
+- CRITICAL: --params and --json values MUST be valid JSON with DOUBLE QUOTES.
+  - CORRECT: --params {"q": "name contains 'hackathon'"}
+  - WRONG:   --params {'q': 'name contains "hackathon"'}
+  - Single quotes are NOT valid JSON. Always use double quotes for keys and string values.
+- Helper commands (PREFERRED — simpler and more reliable):
+  - gmail: +triage, +send, +reply
+  - calendar: +agenda, +insert
+  - workflow: +meeting-prep, +standup-report
+  - docs: +write
+  - drive: +upload
+  - sheets: +read
+- Raw API calls (use when helpers don't cover your need):
+  - 'gmail users messages list --params {"userId": "me", "q": "is:unread"}'
+  - 'calendar events list --params {"calendarId": "primary"}'
+  - 'drive files list --params {"q": "name contains 'frontiers hackathon'"}'
+  - 'calendar events insert --params {"calendarId": "primary"} --json {"summary": "Meeting", "start": {"dateTime": "..."}, "end": {"dateTime": "..."}}'
+- --params = URL/query/path parameters (calendarId, userId, q). --json = request body (summary, start, end, location).
+- NEVER put calendarId or userId in --json. They go in --params.
+- Schema discovery: call gws_schema("service.resource.method") to learn exact parameter formats
+- ALWAYS prefer helper commands over raw API calls
+
+### Response Style
+- Lead with the action or answer. Context comes after if needed.
+- Use bullet points for lists of 3+ items.
+- Bold the most important item in any list.
+- Never say "I'd be happy to help", "Do you approve?", or similar filler.
+
+### Memory and Learning
+- Remember user patterns and preferences across sessions
+- Store important context using memory_store tool
+- Check memory_search before asking questions the user may have answered before
+
+### Triage Mode
+When the user expresses overwhelm (keywords: overwhelmed, too much, can't cope, stressed, drowning):
+1. Acknowledge briefly: "I hear you. Let's simplify."
+2. Fetch unread emails, today's calendar, and pending tasks — ALL IN PARALLEL.
+3. Select the TOP 3 priorities based on: urgency > impact > effort.
+4. Present ONLY those 3 items. Hide everything else.
+5. Ask: "Which one should we tackle first?"
+
+### Error Handling
+- Fix errors silently. Do not narrate your debugging process to the user.
+- After 3 failed attempts at the same operation, tell the user briefly what went wrong (one sentence, no apologies).
+- Never give up after just one error — you're resourceful.
+"""
+
+PROACTIVE_LAYER = """## AUTONOMOUS TRANSCRIPT PROCESSING MODE
+
+You have been given a meeting transcript to process autonomously. Your job:
+
+1. READ the transcript carefully and identify ALL actionable items:
+   - Action items assigned to people
+   - Follow-up emails that need to be sent
+   - Calendar events that need to be created (meetings, deadlines)
+   - Documents that need to be created or shared via Drive
+   - Any commitments or promises made
+
+2. For EACH actionable item, execute it using your tools:
+   - Send follow-up emails via gws gmail +send
+   - Create calendar events via gws calendar +insert
+   - Search/create Drive documents as needed
+   - Create tasks for items you can't fully complete
+
+3. USE notify_user to report what you did after completing each action.
+   Example: notify_user("Sent follow-up email", "Sent meeting recap to team@company.com")
+
+4. USE ask_user ONLY when you genuinely need information you cannot find:
+   - Missing email addresses (check contacts first!)
+   - Ambiguous meeting times
+   - Unclear ownership of action items
+   Do NOT ask permission to read data or execute searches.
+
+5. After processing ALL items, send a final summary notification:
+   notify_user("Meeting processed", "Completed N actions from 'Meeting Title': ...")
+
+Work through items systematically. Do not stop after one action — process the entire transcript.
+"""
+
+FORMAT_LAYER = """## Output Format
+
+For conversational responses:
+- Plain text with markdown formatting (bold, bullets, headers)
+
+For action results:
+- State what was done
+- Show relevant results inline
+- Suggest next steps if applicable
+
+For write operations (send email, create event, update doc):
+- Show what you created/sent with key details
+- The system handles dry-run automatically for dangerous operations
+
+NEVER output raw JSON to the user. Synthesize tool results into human-readable text.
+"""
+
+
+def build_system_prompt(state: dict) -> str:
+    from datetime import timedelta
+    now = datetime.now()  # Local time
+    tomorrow = now + timedelta(days=1)
+    env = ENVIRONMENT_LAYER.format(
+        date=now.strftime("%Y-%m-%d %H:%M %Z"),
+        day_of_week=now.strftime("%A"),
+        timezone=now.astimezone().tzname() or "local",
+        today_date=now.strftime("%Y-%m-%d (%A)"),
+        tomorrow_date=tomorrow.strftime("%Y-%m-%d (%A)"),
+    )
+
+    # Add intent-specific instructions
+    intent = state.get("intent")
+    intent_addendum = ""
+    if intent == "triage":
+        intent_addendum = """
+## TRIAGE MODE ACTIVE
+The user is overwhelmed. Follow triage rules strictly:
+- Fetch ALL relevant data (email, calendar, tasks) IN PARALLEL using multiple tool calls.
+- Synthesize into exactly 3 priorities. No more.
+- Format as a numbered list with one-line descriptions.
+- End with: "Which one first?"
+- Do NOT present raw data. Synthesize it.
+"""
+    elif intent == "proactive":
+        intent_addendum = PROACTIVE_LAYER
+
+    layers = [
+        env,
+        IDENTITY_LAYER,
+        build_context_layer(state),
+        INSTRUCTION_LAYER,
+        intent_addendum,
+        FORMAT_LAYER,
+    ]
+    return "\n\n".join(layer for layer in layers if layer)
diff --git a/backend/app/agent/state.py b/backend/app/agent/state.py
new file mode 100644
index 0000000..fdd9899
--- /dev/null
+++ b/backend/app/agent/state.py
@@ -0,0 +1,20 @@
+"""FRIDAY agent state definition."""
+
+from typing import Literal, Optional
+from pydantic import Field
+from langgraph.graph import MessagesState
+
+
+class FridayState(MessagesState):
+    """Extended state for the FRIDAY agent graph.
+
+    Uses MessagesState which provides `messages` with the add_messages reducer.
+    The agent follows a ReAct loop: agent -> tools -> agent (repeat until done).
+    """
+    session_id: str = ""
+    user_id: str = ""
+    user_context: dict = Field(default_factory=dict)
+    active_tasks: list[dict] = Field(default_factory=list)
+    semantic_context: list[dict] = Field(default_factory=list)
+    intent: Optional[Literal["chat", "triage", "proactive"]] = None
+    error: Optional[str] = None
diff --git a/backend/app/agent/tools/__init__.py b/backend/app/agent/tools/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/app/agent/tools/data_tools.py b/backend/app/agent/tools/data_tools.py
new file mode 100644
index 0000000..751841f
--- /dev/null
+++ b/backend/app/agent/tools/data_tools.py
@@ -0,0 +1,139 @@
+import json
+from typing import Optional
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import tool
+
+from services.store import store
+
+
+def _get_user_id(config: RunnableConfig) -> str:
+    return config.get("configurable", {}).get("user_id", "default")
+
+
+@tool
+def get_user_tasks(
+    config: RunnableConfig,
+    status: Optional[str] = None,
+    priority: Optional[str] = None,
+    limit: int = 20,
+) -> str:
+    """Get the user's tasks, optionally filtered by status and priority.
+
+    Args:
+        status: Filter by status (pending, in_progress, done, cancelled)
+        priority: Filter by priority (low, medium, high, urgent)
+        limit: Maximum number of tasks to return
+    """
+    user_id = _get_user_id(config)
+    tasks = store.get_tasks(user_id, status=status, priority=priority, limit=limit)
+    if not tasks:
+        return "No tasks found."
+    return json.dumps(tasks, indent=2, default=str)
+
+
+@tool
+def create_task(
+    config: RunnableConfig,
+    title: str,
+    description: Optional[str] = None,
+    priority: str = "medium",
+    due_at: Optional[str] = None,
+    source: Optional[str] = None,
+    source_ref: Optional[str] = None,
+) -> str:
+    """Create a new task for the user.
+
+    Args:
+        title: Task title
+        description: Optional description
+        priority: Priority level (low, medium, high, urgent)
+        due_at: Optional due date (ISO format)
+        source: Where the task came from (e.g. "meeting", "email", "user")
+        source_ref: Reference ID from the source
+    """
+    user_id = _get_user_id(config)
+    task = store.create_task(
+        user_id=user_id,
+        title=title,
+        description=description,
+        priority=priority,
+        due_at=due_at,
+        source=source,
+        source_ref=source_ref,
+    )
+    return json.dumps(task, default=str)
+
+
+@tool
+def update_task(
+    config: RunnableConfig,
+    task_id: str,
+    status: Optional[str] = None,
+    priority: Optional[str] = None,
+    title: Optional[str] = None,
+) -> str:
+    """Update an existing task.
+
+    Args:
+        task_id: ID of the task to update
+        status: New status (pending, in_progress, done, cancelled)
+        priority: New priority (low, medium, high, urgent)
+        title: New title
+    """
+    user_id = _get_user_id(config)
+    task = store.update_task(user_id, task_id, status=status, priority=priority, title=title)
+    if not task:
+        return f"Task {task_id} not found."
+    return json.dumps(task, default=str)
+
+
+@tool
+def get_user_context(config: RunnableConfig, context_key: str) -> str:
+    """Get a specific user context/preference value.
+
+    Common keys: "communication_style", "work_hours", "priorities", "preferences"
+
+    Args:
+        context_key: The context key to look up
+    """
+    user_id = _get_user_id(config)
+    ctx = store.get_user_context(user_id, context_key)
+    if not ctx:
+        return f"No context found for key '{context_key}'."
+    return json.dumps(ctx, default=str)
+
+
+@tool
+def save_user_context(
+    config: RunnableConfig,
+    context_key: str,
+    context_value: str,
+    confidence: float = 0.8,
+    source: str = "agent",
+) -> str:
+    """Save a user context/preference for future reference.
+
+    Use this to remember things about the user like preferences, patterns,
+    communication style, work schedule, etc.
+
+    Args:
+        context_key: The context key (e.g. "communication_style", "work_hours")
+        context_value: JSON string of the context value
+        confidence: Confidence level (0.0-1.0)
+        source: Source of the context (e.g. "agent", "user", "meeting")
+    """
+    user_id = _get_user_id(config)
+    try:
+        value = json.loads(context_value)
+    except (json.JSONDecodeError, TypeError):
+        value = {"value": context_value}
+
+    entry = store.save_user_context(
+        user_id=user_id,
+        context_key=context_key,
+        context_value=value,
+        confidence=confidence,
+        source=source,
+    )
+    return json.dumps(entry, default=str)
diff --git a/backend/app/agent/tools/exa_tools.py b/backend/app/agent/tools/exa_tools.py
new file mode 100644
index 0000000..bbdffbb
--- /dev/null
+++ b/backend/app/agent/tools/exa_tools.py
@@ -0,0 +1,67 @@
+"""Exa neural web search tool for LangGraph agent."""
+
+import asyncio
+import json
+import logging
+from langchain_core.tools import tool
+
+logger = logging.getLogger(__name__)
+
+_exa_client = None
+
+
+def _get_exa_client():
+    global _exa_client
+    if _exa_client is None:
+        from config import settings
+        if not settings.exa_api_key:
+            return None
+        from exa_py import Exa
+        _exa_client = Exa(api_key=settings.exa_api_key)
+    return _exa_client
+
+
+def _sync_exa_search(query: str, num_results: int):
+    """Synchronous Exa search to be run in a thread."""
+    client = _get_exa_client()
+    if client is None:
+        return {"error": "Exa API key not configured"}
+
+    result = client.search_and_contents(
+        query=query,
+        num_results=num_results,
+        text={"max_characters": 1000},
+        use_autoprompt=True,
+    )
+    results = []
+    for r in result.results:
+        results.append({
+            "title": r.title,
+            "url": r.url,
+            "text": r.text[:500] if r.text else "",
+            "score": getattr(r, "score", None),
+        })
+    return results
+
+
+@tool
+async def exa_search(
+    query: str,
+    num_results: int = 5,
+) -> str:
+    """Search the web for real-time information using Exa's neural search.
+
+    Use this when the user's question requires information BEYOND their
+    Google Workspace — news, research, documentation, public information,
+    company lookups, industry trends, etc.
+
+    Do NOT use this for:
+    - User's emails, calendar, or docs — use gws tools instead
+    - User's tasks or preferences — use data_tools instead
+    """
+    try:
+        results = await asyncio.to_thread(_sync_exa_search, query, num_results)
+        return json.dumps(results)
+    except Exception as e:
+        logger.error("Exa search failed: %s", e)
+        return json.dumps({"error": str(e)})
diff --git a/backend/app/agent/tools/gws.py b/backend/app/agent/tools/gws.py
new file mode 100644
index 0000000..14a3bf6
--- /dev/null
+++ b/backend/app/agent/tools/gws.py
@@ -0,0 +1,174 @@
+"""Google Workspace CLI tools for LangGraph agent."""
+
+import json
+from langchain_core.tools import tool
+
+from core.gws_runner import run_gws, GWSResult
+
+
+@tool
+async def gws(
+    command: str,
+    dry_run: bool = False,
+    force_execute: bool = False,
+) -> str:
+    """Execute any Google Workspace CLI command.
+
+    The gws CLI provides dynamic access to ALL Google Workspace APIs.
+    Format: '<service> <resource> <method> [flags]' or '<service> +helper [flags]'
+
+    ═══ HELPER COMMANDS (preferred — simpler and more reliable) ═══
+
+    Gmail:
+    - 'gmail +triage'                                          — unread inbox summary
+    - 'gmail +triage --max 5 --query "from:boss"'              — filtered triage
+    - 'gmail +send --to EMAIL --subject SUBJ --body TEXT'      — send email
+
+    Calendar:
+    - 'calendar +agenda'                                       — upcoming events
+    - 'calendar +agenda --today'                               — today's events only
+    - 'calendar +agenda --week'                                — this week's events
+    - 'calendar +agenda --days 3'                              — next 3 days
+    - 'calendar +insert --summary TEXT --start TIME --end TIME' — create event
+    - 'calendar +insert ... --location LOC --attendee EMAIL'   — with location/attendees
+
+    Drive:
+    - 'drive +upload ./file.pdf'                               — upload file
+    - 'drive +upload ./file.pdf --parent FOLDER_ID'            — upload to folder
+
+    Docs:
+    - 'docs +write --document DOC_ID --text TEXT'              — append text to doc
+
+    Sheets:
+    - 'sheets +read --spreadsheet ID --range "Sheet1!A1:D10"'  — read values
+    - 'sheets +append --spreadsheet ID --values "a,b,c"'       — append row
+
+    Chat:
+    - 'chat +send --space spaces/SPACE_ID --text TEXT'         — send chat message
+
+    Workflows (cross-service):
+    - 'workflow +standup-report'                                — today's meetings + open tasks
+    - 'workflow +meeting-prep'                                  — prep for next meeting (agenda, attendees, docs)
+    - 'workflow +weekly-digest'                                 — weekly summary: meetings + unread count
+    - 'workflow +email-to-task --message-id MSG_ID'            — convert email to task
+    - 'workflow +file-announce --file-id ID --space spaces/ID' — announce file in chat
+
+    ═══ RAW API CALLS (when helpers don't cover your need) ═══
+
+    - 'gmail users messages list --params {"userId": "me", "q": "is:unread"}'
+    - 'gmail users messages get --params {"userId": "me", "id": "MSG_ID"}'
+    - 'calendar events list --params {"calendarId": "primary"}'
+    - 'drive files list --params {"q": "name contains 'hackathon'"}'
+    - 'tasks tasklists list'
+    - 'tasks tasks list --params {"tasklist": "@default"}'
+    - 'keep notes list'
+    - 'people people connections list --params {"resourceName": "people/me", "personFields": "names,emailAddresses"}'
+
+    ═══ RAW API: --params vs --json ═══
+
+    - --params = URL/query/path parameters (e.g., calendarId, userId, q)
+    - --json   = request BODY (e.g., summary, start, end, location, attendees)
+    - Example: calendar events insert --params {"calendarId": "primary"} --json {"summary": "Meeting", "start": {"dateTime": "..."}, "end": {"dateTime": "..."}}
+    - NEVER put calendarId or userId in --json. They are URL parameters → use --params.
+
+    ═══ IMPORTANT RULES ═══
+
+    - ALL JSON must use DOUBLE QUOTES. Single quotes are invalid JSON.
+    - IF A COMMAND FAILS: Call gws_schema to discover correct parameters, then retry.
+    - Use --params for query/path parameters (JSON object).
+    - Use --json for request body (POST/PATCH/PUT).
+    - Use --page-all to auto-paginate results.
+    - Create/update/delete operations automatically show a dry-run preview.
+    - After user confirms, re-call gws with the SAME command and force_execute=True.
+    - Do NOT add --force to the command string. Use the force_execute parameter instead.
+    - Times must be ISO 8601 / RFC 3339 (e.g., 2026-03-07T08:00:00-05:00).
+    """
+    result: GWSResult = await run_gws(command, dry_run=dry_run, force_execute=force_execute)
+
+    if not result.success:
+        return json.dumps({"error": result.error, "command": result.command})
+
+    output = {"success": True, "data": result.data, "command": result.command}
+    if result.requires_approval and result.dry_run:
+        output["requires_approval"] = True
+        output["note"] = "This action requires user approval. Showing dry-run preview."
+    return json.dumps(output, default=str)
+
+
+@tool
+async def gws_help(command: str) -> str:
+    """Get CLI help for any gws service, resource, or helper command.
+
+    Use this to discover available subcommands, flags, and usage examples.
+
+    Examples:
+    - 'drive'                — list Drive subcommands and helpers
+    - 'drive files list'     — see flags for listing files
+    - 'calendar +insert'     — see flags for creating events
+    - 'gmail +triage'        — see flags for email triage
+    - 'workflow'             — list all workflow helpers
+    - 'tasks'                — list Tasks subcommands
+
+    Returns the CLI help output for the given command.
+    """
+    result = await run_gws(f"{command} --help")
+    if not result.success:
+        # --help often exits with code 0 but sometimes doesn't; return raw output
+        return result.error or "No help available"
+    return result.data if isinstance(result.data, str) else json.dumps(result.data, default=str)
+
+
+def _sanitize_schema(obj):
+    """Remove $ref and schemaRef keys that confuse Gemini's function calling.
+
+    Gemini interprets $ref values as references to tool/function names.
+    Also truncates overly large response/request body schemas to keep
+    the tool response lean — the agent only needs parameter info.
+    """
+    if isinstance(obj, dict):
+        cleaned = {}
+        for k, v in obj.items():
+            # Skip keys that cause Gemini to look for non-existent functions
+            if k in ("$ref", "schemaRef"):
+                continue
+            # Truncate nested response/request schemas — agent doesn't need full body specs
+            if k == "response" and isinstance(v, dict):
+                cleaned[k] = "(response schema omitted — use gws_help for output details)"
+                continue
+            if k == "request" and isinstance(v, dict):
+                cleaned[k] = "(request body schema omitted — use gws_help for input details)"
+                continue
+            cleaned[k] = _sanitize_schema(v)
+        return cleaned
+    elif isinstance(obj, list):
+        return [_sanitize_schema(item) for item in obj]
+    return obj
+
+
+@tool
+async def gws_schema(method: str) -> str:
+    """Inspect any Google Workspace API method's parameters and body schema.
+
+    Use this to discover correct parameters BEFORE calling unfamiliar API methods,
+    or AFTER a command fails to understand the correct syntax.
+
+    Format: 'service.resource.method'
+
+    Examples:
+    - 'gmail.users.messages.list'   — see query params for listing emails
+    - 'calendar.events.insert'      — see required fields for creating events
+    - 'calendar.events.list'        — see how to filter events
+    - 'drive.files.list'            — see how to search files (q parameter format)
+    - 'drive.files.create'          — see how to create/upload files
+    - 'tasks.tasks.list'            — see how to list tasks
+    - 'docs.documents.get'          — see how to read a doc
+    - 'sheets.spreadsheets.values.get' — see how to read sheet values
+    - 'people.people.connections.list' — see how to list contacts
+    """
+    result = await run_gws(f"schema {method}")
+    if not result.success:
+        return json.dumps({"error": result.error})
+    data = result.data
+    if isinstance(data, dict):
+        data = _sanitize_schema(data)
+    return json.dumps({"schema": data}, default=str)
diff --git a/backend/app/agent/tools/memory_tools.py b/backend/app/agent/tools/memory_tools.py
new file mode 100644
index 0000000..e3493b2
--- /dev/null
+++ b/backend/app/agent/tools/memory_tools.py
@@ -0,0 +1,93 @@
+import json
+import logging
+from typing import Optional
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import tool
+
+logger = logging.getLogger(__name__)
+
+_sm_client = None
+try:
+    from config import settings
+    if settings.supermemory_api_key:
+        from supermemory import AsyncSupermemory
+        _sm_client = AsyncSupermemory(api_key=settings.supermemory_api_key)
+except Exception as e:
+    logger.warning(f"Supermemory not available: {e}")
+
+
+def _get_user_id(config: RunnableConfig) -> str:
+    return config.get("configurable", {}).get("user_id", "default")
+
+
+@tool
+async def memory_search(config: RunnableConfig, query: str, limit: int = 5) -> str:
+    """Search the user's semantic memory for relevant past context.
+
+    Use this to recall:
+    - Past conversations and commitments
+    - User preferences and patterns
+    - Previously discussed topics
+    - Meeting summaries and notes
+
+    Args:
+        query: What to search for
+        limit: Max results to return
+    """
+    if _sm_client is None:
+        return "Memory search not available (SUPERMEMORY_API_KEY not configured)"
+
+    user_id = _get_user_id(config)
+    try:
+        results = await _sm_client.search.execute(
+            q=query,
+            container_tags=[user_id],
+            limit=limit,
+        )
+        if hasattr(results, 'results'):
+            return json.dumps([
+                {"content": r.content, "score": getattr(r, 'score', None)}
+                for r in results.results
+            ], default=str)
+        return json.dumps(results, default=str)
+    except Exception as e:
+        logger.error(f"Memory search error: {e}")
+        return f"Memory search error: {e}"
+
+
+@tool
+async def memory_store(config: RunnableConfig, content: str, metadata: Optional[str] = None) -> str:
+    """Store information in the user's semantic memory for future recall.
+
+    Use this to remember:
+    - Important user statements or commitments
+    - Learned patterns about the user
+    - Meeting summaries or key decisions
+    - User preferences discovered during conversation
+
+    Args:
+        content: The text content to store
+        metadata: Optional JSON string of metadata (e.g. '{"source": "meeting", "topic": "project_x"}')
+    """
+    if _sm_client is None:
+        return "Memory storage not available (SUPERMEMORY_API_KEY not configured)"
+
+    user_id = _get_user_id(config)
+    meta = {}
+    if metadata:
+        try:
+            meta = json.loads(metadata)
+        except (json.JSONDecodeError, TypeError):
+            meta = {"raw": metadata}
+
+    try:
+        result = await _sm_client.add(
+            content=content,
+            container_tag=user_id,
+            metadata=meta,
+        )
+        return json.dumps({"status": "stored", "result": result}, default=str)
+    except Exception as e:
+        logger.error(f"Memory store error: {e}")
+        return f"Memory store error: {e}"
diff --git a/backend/app/agent/tools/notification_tools.py b/backend/app/agent/tools/notification_tools.py
new file mode 100644
index 0000000..680a040
--- /dev/null
+++ b/backend/app/agent/tools/notification_tools.py
@@ -0,0 +1,48 @@
+"""Notification tools — agent can notify or ask the user."""
+
+from langchain_core.tools import tool
+from langchain_core.runnables import RunnableConfig
+from services.store import store
+
+
+@tool
+def notify_user(title: str, message: str, notification_type: str = "info") -> str:
+    """Send a notification to the user. Does NOT pause the agent.
+
+    Use this to report completed actions, status updates, or errors.
+    notification_type: "info", "action_taken", or "error"
+    """
+    store.add_notification({
+        "type": notification_type,
+        "title": title,
+        "message": message,
+    })
+    return "Notification sent."
+
+
+@tool
+def ask_user(question: str, context: str = "", config: RunnableConfig = None) -> str:
+    """Ask the user a question and wait for their response.
+
+    Use when you genuinely need information only the user can provide.
+    Do NOT use for permission to read data — just read it.
+    This PAUSES the agent until the user replies.
+    """
+    from langgraph.types import interrupt
+
+    # Extract session_id from config so the reply endpoint can resume
+    session_id = None
+    if config and "configurable" in config:
+        session_id = config["configurable"].get("thread_id")
+
+    # Store a question notification before pausing
+    store.add_notification({
+        "type": "question",
+        "title": "Agent needs your input",
+        "message": question,
+        "session_id": session_id,
+    })
+
+    # interrupt() pauses the graph; when resumed via Command(resume=answer), returns the answer
+    answer = interrupt({"question": question, "context": context})
+    return answer
diff --git a/backend/app/agent/tools/registry.py b/backend/app/agent/tools/registry.py
new file mode 100644
index 0000000..d9ec1f9
--- /dev/null
+++ b/backend/app/agent/tools/registry.py
@@ -0,0 +1,24 @@
+"""Tool registry — all tools available to the agent at all times."""
+
+from .gws import gws, gws_help, gws_schema
+from .exa_tools import exa_search
+from .data_tools import get_user_tasks, create_task, update_task, get_user_context, save_user_context
+from .memory_tools import memory_search, memory_store
+from .notification_tools import notify_user, ask_user
+
+# All tools are always available. The agent decides what to use based on context.
+ALL_TOOLS: list = [
+    gws,
+    gws_help,
+    gws_schema,
+    exa_search,
+    get_user_tasks,
+    create_task,
+    update_task,
+    get_user_context,
+    save_user_context,
+    memory_search,
+    memory_store,
+    notify_user,
+    ask_user,
+]
diff --git a/backend/app/api/__init__.py b/backend/app/api/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/app/api/chat.py b/backend/app/api/chat.py
new file mode 100644
index 0000000..37d0ce1
--- /dev/null
+++ b/backend/app/api/chat.py
@@ -0,0 +1,73 @@
+import logging
+
+from fastapi import APIRouter, HTTPException
+from langchain_core.messages import HumanMessage
+
+from models.schemas import ChatRequest
+from services.store import store
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["chat"])
+
+
+def _get_graph():
+    """Lazy import to avoid circular imports at module level."""
+    from agent.graph import friday_graph
+    return friday_graph
+
+
+@router.post("/")
+async def chat(request: ChatRequest):
+    """Send a message to FRIDAY and get a complete response.
+
+    The agent autonomously decides what tools to call and loops
+    until it has a final response. No separate approval step needed
+    for read operations.
+    """
+    graph = _get_graph()
+
+    # Create or retrieve session
+    session_id = request.session_id
+    if not session_id:
+        session = store.create_session(request.user_id)
+        session_id = session["session_id"]
+    elif not store.get_session(session_id):
+        store.create_session(request.user_id, session_id=session_id)
+
+    # Save user message
+    store.add_message(session_id, "user", request.message)
+
+    config = {
+        "configurable": {
+            "thread_id": session_id,
+            "user_id": request.user_id,
+        },
+        "recursion_limit": 25,  # Max tool-calling iterations
+    }
+    input_state = {
+        "messages": [HumanMessage(content=request.message)],
+        "session_id": session_id,
+        "user_id": request.user_id,
+    }
+
+    try:
+        result = await graph.ainvoke(input_state, config=config)
+
+        # Extract the final AI response from messages
+        response_text = ""
+        if result.get("messages"):
+            for msg in reversed(result["messages"]):
+                if hasattr(msg, "type") and msg.type == "ai" and msg.content:
+                    response_text = msg.content
+                    break
+
+        return {
+            "response": response_text,
+            "session_id": session_id,
+            "intent": result.get("intent", "chat"),
+        }
+
+    except Exception as e:
+        logger.error(f"Chat error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
diff --git a/backend/app/api/health.py b/backend/app/api/health.py
new file mode 100644
index 0000000..615bf0a
--- /dev/null
+++ b/backend/app/api/health.py
@@ -0,0 +1,37 @@
+"""Health and auth status endpoints."""
+
+import asyncio
+import shutil
+from fastapi import APIRouter
+
+router = APIRouter(tags=["health"])
+
+
+@router.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@router.get("/auth/status")
+async def auth_status():
+    gws_path = shutil.which("gws")
+    if not gws_path:
+        return {"gws_installed": False, "gws_authenticated": False, "message": "gws CLI not found. Run: npm install -g @googleworkspace/cli"}
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "gws", "auth", "status",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
+        authenticated = proc.returncode == 0
+        return {
+            "gws_installed": True,
+            "gws_authenticated": authenticated,
+            "message": stdout.decode().strip() if authenticated else "Not authenticated. Run: gws auth login",
+        }
+    except asyncio.TimeoutError:
+        return {"gws_installed": True, "gws_authenticated": False, "message": "gws auth status timed out"}
+    except Exception as e:
+        return {"gws_installed": True, "gws_authenticated": False, "message": str(e)}
diff --git a/backend/app/api/notifications.py b/backend/app/api/notifications.py
new file mode 100644
index 0000000..3a33955
--- /dev/null
+++ b/backend/app/api/notifications.py
@@ -0,0 +1,103 @@
+"""Notifications API — list, reply, dismiss, mark-read."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from langgraph.types import Command
+
+from services.store import store
+
+router = APIRouter()
+
+
+class ReplyRequest(BaseModel):
+    message: str
+
+
+# ---------- Endpoints ----------
+
+
+@router.get("")
+async def list_notifications(limit: int = 50):
+    """Get recent notifications, most recent first."""
+    return store.get_notifications(limit=limit)
+
+
+@router.get("/unread-count")
+async def unread_count():
+    """Get count of unread notifications."""
+    return {"count": store.get_unread_count()}
+
+
+@router.post("/{notification_id}/reply")
+async def reply_to_notification(notification_id: str, body: ReplyRequest):
+    """Reply to a question notification and resume the agent graph."""
+    notif = store.get_notification(notification_id)
+    if not notif or notif["type"] != "question":
+        raise HTTPException(404, "Not a question notification")
+
+    if not notif.get("session_id"):
+        raise HTTPException(400, "No session_id to resume")
+
+    from agent.graph import friday_graph
+
+    config = {
+        "configurable": {"thread_id": notif["session_id"], "user_id": "default"},
+        "recursion_limit": 40,
+    }
+
+    # Resume the graph — the interrupt() in ask_user receives this value
+    await friday_graph.ainvoke(Command(resume=body.message), config=config)
+
+    store.update_notification(notification_id, status="answered")
+
+    # Check if graph paused again (another question)
+    graph_state = await friday_graph.aget_state(config)
+    still_waiting = bool(graph_state and graph_state.next)
+
+    return {"status": "resumed", "still_waiting": still_waiting}
+
+
+@router.post("/{notification_id}/dismiss")
+async def dismiss_notification(notification_id: str):
+    """Dismiss a notification."""
+    notif = store.update_notification(notification_id, status="dismissed")
+    if not notif:
+        raise HTTPException(404, "Notification not found")
+    return {"status": "dismissed"}
+
+
+@router.post("/mark-read")
+async def mark_all_read():
+    """Mark all unread notifications as read."""
+    for n in store.notifications:
+        if n["status"] == "unread":
+            n["status"] = "read"
+    return {"status": "ok"}
+
+
+@router.post("/seed-test")
+async def seed_test_notifications():
+    """DEV ONLY: Create sample notifications for UI testing."""
+    store.add_notification({
+        "type": "action_taken",
+        "title": "Sent follow-up email",
+        "message": "Sent meeting recap to team@company.com with action items from standup",
+    })
+    store.add_notification({
+        "type": "info",
+        "title": "Processed 'Team Standup'",
+        "message": "Found 3 action items, created 2 calendar events, sent 1 email",
+        "meeting_id": "meeting-123",
+    })
+    store.add_notification({
+        "type": "question",
+        "title": "Agent needs your input",
+        "message": "Who should I assign the design review to? The transcript mentions 'the design team' but no specific person.",
+        "session_id": "proactive-meeting-123",
+    })
+    store.add_notification({
+        "type": "error",
+        "title": "Error processing 'Client Call'",
+        "message": "Gmail API rate limit reached. Will retry in 5 minutes.",
+    })
+    return {"status": "seeded", "count": store.get_unread_count()}
diff --git a/backend/app/api/sessions.py b/backend/app/api/sessions.py
new file mode 100644
index 0000000..95fed67
--- /dev/null
+++ b/backend/app/api/sessions.py
@@ -0,0 +1,36 @@
+from fastapi import APIRouter, HTTPException, Query
+
+from models.schemas import SessionResponse
+from services.store import store
+
+router = APIRouter(tags=["sessions"])
+
+
+@router.get("/")
+async def list_sessions(user_id: str = Query(default="default")):
+    """List user sessions, most recent first."""
+    sessions = store.list_sessions(user_id)
+    result = []
+    for s in sessions:
+        sid = s["session_id"]
+        msg_count = len(store.get_messages(sid))
+        result.append({
+            **s,
+            "message_count": msg_count,
+        })
+    return result
+
+
+@router.get("/{session_id}")
+async def get_session(session_id: str):
+    """Get a session with its message history."""
+    session = store.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    messages = store.get_messages(session_id)
+    return {
+        **session,
+        "messages": messages,
+        "message_count": len(messages),
+    }
diff --git a/backend/app/api/tasks.py b/backend/app/api/tasks.py
new file mode 100644
index 0000000..196147e
--- /dev/null
+++ b/backend/app/api/tasks.py
@@ -0,0 +1,50 @@
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Query
+
+from models.schemas import CreateTaskRequest, UpdateTaskRequest, TaskResponse
+from services.store import store
+
+router = APIRouter(tags=["tasks"])
+
+
+@router.get("/")
+async def list_tasks(
+    user_id: str = Query(default="default"),
+    status: Optional[str] = Query(default=None),
+    priority: Optional[str] = Query(default=None),
+    limit: int = Query(default=50, le=100),
+):
+    """List tasks with optional filters."""
+    tasks = store.get_tasks(user_id, status=status, priority=priority, limit=limit)
+    return tasks
+
+
+@router.post("/", response_model=TaskResponse)
+async def create_task(request: CreateTaskRequest):
+    """Create a new task."""
+    task = store.create_task(
+        user_id=request.user_id,
+        title=request.title,
+        description=request.description,
+        priority=request.priority,
+        due_at=request.due_at,
+        source=request.source,
+        source_ref=request.source_ref,
+    )
+    return task
+
+
+@router.patch("/{task_id}", response_model=TaskResponse)
+async def update_task(task_id: str, request: UpdateTaskRequest, user_id: str = Query(default="default")):
+    """Update an existing task."""
+    task = store.update_task(
+        user_id=user_id,
+        task_id=task_id,
+        status=request.status,
+        priority=request.priority,
+        title=request.title,
+        description=request.description,
+    )
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return task
diff --git a/backend/app/config.py b/backend/app/config.py
new file mode 100644
index 0000000..21926de
--- /dev/null
+++ b/backend/app/config.py
@@ -0,0 +1,39 @@
+"""FRIDAY configuration from environment variables."""
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    # Gemini
+    gemini_api_key: str = ""
+    google_api_key: str = ""
+
+    # Supabase (optional for now)
+    supabase_url: str = ""
+    supabase_service_key: str = ""
+
+    # Exa web search
+    exa_api_key: str = ""
+
+    # Supermemory
+    supermemory_api_key: str = ""
+
+    # OpenRouter
+    openrouter_api_key: str = ""
+
+    # Heartbeat
+    heartbeat_enabled: bool = True
+    heartbeat_interval_seconds: int = 600
+
+    # Logging
+    log_level: str = "INFO"
+
+    @property
+    def effective_gemini_key(self) -> str:
+        return self.gemini_api_key or self.google_api_key
+
+
+settings = Settings()
diff --git a/backend/app/core/__init__.py b/backend/app/core/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/app/core/gws_runner.py b/backend/app/core/gws_runner.py
new file mode 100644
index 0000000..d67016a
--- /dev/null
+++ b/backend/app/core/gws_runner.py
@@ -0,0 +1,176 @@
+"""Async subprocess wrapper for the Google Workspace CLI (gws)."""
+
+import asyncio
+import json
+import logging
+import re
+import shlex
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+APPROVAL_REQUIRED_PATTERNS = [
+    # Create operations
+    r"calendar\s+.*events\.insert",
+    r"calendar\s+.*\+insert",
+    r"docs\s+.*documents\.create",
+    r"docs\s+.*\+write",
+    r"sheets\s+.*spreadsheets\.create",
+    r"drive\s+.*files\.create",
+    # Update operations
+    r"calendar\s+.*events\.(update|patch)",
+    r"docs\s+.*documents\.batchUpdate",
+    r"sheets\s+.*values\.(update|append)",
+    r"drive\s+.*files\.(update|patch)",
+    # Delete operations
+    r"\.delete\b",
+    r"files\.emptyTrash",
+]
+
+BLOCKED_COMMANDS = ["auth", "config"]
+
+
+@dataclass
+class GWSResult:
+    success: bool
+    data: Optional[dict | list | str] = None
+    error: Optional[str] = None
+    command: str = ""
+    requires_approval: bool = False
+    dry_run: bool = False
+    duration_ms: int = 0
+
+
+def requires_approval(command: str) -> bool:
+    for pattern in APPROVAL_REQUIRED_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            return True
+    return False
+
+
+def _is_blocked(command: str) -> bool:
+    parts = command.strip().split()
+    if parts and parts[0].lower() in BLOCKED_COMMANDS:
+        return True
+    return False
+
+
+def _smart_split(command: str) -> list[str]:
+    """Split a gws command string preserving JSON blobs for --params and --json flags.
+
+    shlex.split mangles JSON (strips quotes, splits on spaces inside braces).
+    This extracts JSON values attached to those flags first, shell-splits the
+    rest, then re-inserts the JSON as single arguments.
+    """
+    json_flags = {}
+    remaining = command
+
+    for flag in ("--params", "--json"):
+        idx = remaining.find(flag)
+        if idx == -1:
+            continue
+        after_flag = remaining[idx + len(flag):]
+        # Skip whitespace to find the JSON start
+        stripped = after_flag.lstrip()
+        if not stripped.startswith("{") and not stripped.startswith("["):
+            continue
+        # Find matching closing brace/bracket
+        open_char = stripped[0]
+        close_char = "}" if open_char == "{" else "]"
+        depth = 0
+        in_string = False
+        escape_next = False
+        end_pos = None
+        for i, ch in enumerate(stripped):
+            if escape_next:
+                escape_next = False
+                continue
+            if ch == "\\":
+                escape_next = True
+                continue
+            if ch == '"':
+                in_string = not in_string
+                continue
+            if in_string:
+                continue
+            if ch == open_char:
+                depth += 1
+            elif ch == close_char:
+                depth -= 1
+                if depth == 0:
+                    end_pos = i
+                    break
+        if end_pos is None:
+            # Malformed JSON — fall back to shlex
+            continue
+        json_str = stripped[: end_pos + 1]
+        # Calculate the full span in `remaining` to remove
+        json_start_in_remaining = idx
+        json_end_in_remaining = idx + len(flag) + (len(after_flag) - len(stripped)) + end_pos + 1
+        json_flags[flag] = json_str
+        remaining = remaining[:json_start_in_remaining] + remaining[json_end_in_remaining:]
+
+    parts = shlex.split(remaining)
+
+    # Re-insert JSON flags in order
+    for flag, json_val in json_flags.items():
+        parts.extend([flag, json_val])
+
+    return parts
+
+
+async def run_gws(command: str, dry_run: bool = False, timeout: float = 30.0, force_execute: bool = False) -> GWSResult:
+    if _is_blocked(command):
+        return GWSResult(success=False, error=f"Blocked command: {command.split()[0]}", command=command)
+
+    needs_approval = requires_approval(command)
+    if needs_approval and not force_execute:
+        dry_run = True
+
+    full_command = command
+    if dry_run and "--dry-run" not in command:
+        full_command = f"{command} --dry-run"
+
+    args = ["gws"] + _smart_split(full_command)
+    start = time.monotonic()
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        duration_ms = int((time.monotonic() - start) * 1000)
+
+        raw = stdout.decode().strip()
+        err = stderr.decode().strip()
+
+        if proc.returncode != 0:
+            return GWSResult(
+                success=False, error=err or raw or f"Exit code {proc.returncode}",
+                command=full_command, requires_approval=needs_approval,
+                dry_run=dry_run, duration_ms=duration_ms,
+            )
+
+        # Try parsing as JSON
+        try:
+            data = json.loads(raw)
+        except (json.JSONDecodeError, ValueError):
+            data = raw
+
+        return GWSResult(
+            success=True, data=data, command=full_command,
+            requires_approval=needs_approval, dry_run=dry_run, duration_ms=duration_ms,
+        )
+
+    except asyncio.TimeoutError:
+        duration_ms = int((time.monotonic() - start) * 1000)
+        return GWSResult(success=False, error=f"Timed out after {timeout}s", command=full_command, duration_ms=duration_ms)
+    except FileNotFoundError:
+        return GWSResult(success=False, error="gws CLI not found. Install: npm install -g @googleworkspace/cli", command=full_command)
+    except Exception as e:
+        duration_ms = int((time.monotonic() - start) * 1000)
+        return GWSResult(success=False, error=str(e), command=full_command, duration_ms=duration_ms)
diff --git a/backend/app/core/sse.py b/backend/app/core/sse.py
new file mode 100644
index 0000000..0682fdf
--- /dev/null
+++ b/backend/app/core/sse.py
@@ -0,0 +1,146 @@
+"""SSE event formatting and graph streaming bridge."""
+
+import json
+import logging
+from typing import Any, AsyncGenerator, Union
+
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+
+from models.events import (
+    ApprovalRequiredEvent,
+    DoneEvent,
+    ErrorEvent,
+    StatusEvent,
+    TokenEvent,
+    ToolResultEvent,
+)
+
+logger = logging.getLogger(__name__)
+
+SSEEvent = Union[
+    StatusEvent, TokenEvent, ToolResultEvent,
+    ApprovalRequiredEvent, DoneEvent, ErrorEvent,
+]
+
+
+def format_sse_event(event: BaseModel) -> str:
+    """Format a Pydantic event model as an SSE string."""
+    data = event.model_dump()
+    event_type = data.get("type", "message")
+    return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"
+
+
+async def run_graph_with_streaming(
+    graph: Any,
+    session_id: str,
+    user_id: str,
+    message: str,
+) -> AsyncGenerator[str, None]:
+    """Run the FRIDAY graph and yield SSE-formatted strings."""
+    config = {
+        "configurable": {
+            "thread_id": session_id,
+            "user_id": user_id,
+        }
+    }
+    input_state = {
+        "messages": [HumanMessage(content=message)],
+        "session_id": session_id,
+        "user_id": user_id,
+    }
+
+    yield format_sse_event(StatusEvent(message="Processing your message..."))
+
+    try:
+        async for event in graph.astream_events(
+            input_state, config=config, version="v2"
+        ):
+            kind = event.get("event", "")
+            name = event.get("name", "")
+
+            if kind == "on_chat_model_stream":
+                chunk = event.get("data", {}).get("chunk")
+                if chunk and hasattr(chunk, "content") and chunk.content:
+                    yield format_sse_event(TokenEvent(content=chunk.content))
+
+            elif kind == "on_tool_start":
+                yield format_sse_event(StatusEvent(message=f"Using {name}..."))
+
+            elif kind == "on_tool_end":
+                output = event.get("data", {}).get("output", "")
+                result_str = str(output)[:500]
+                yield format_sse_event(
+                    ToolResultEvent(tool_name=name, result=result_str)
+                )
+
+        # Check for interrupts (approval required)
+        state = await graph.aget_state(config)
+        if state and hasattr(state, "tasks") and state.tasks:
+            for task in state.tasks:
+                if hasattr(task, "interrupts") and task.interrupts:
+                    for intr in task.interrupts:
+                        payload = intr.value if hasattr(intr, "value") else intr
+                        if isinstance(payload, dict):
+                            yield format_sse_event(
+                                ApprovalRequiredEvent(
+                                    action_type=payload.get("action_type", "unknown"),
+                                    payload=payload,
+                                    explanation=payload.get("explanation", ""),
+                                    dry_run_result=payload.get("dry_run_result"),
+                                )
+                            )
+
+        yield format_sse_event(DoneEvent(session_id=session_id))
+
+    except Exception as e:
+        logger.error(f"Graph streaming error: {e}", exc_info=True)
+        yield format_sse_event(ErrorEvent(message=str(e)))
+
+
+async def resume_graph_with_streaming(
+    graph: Any,
+    session_id: str,
+    user_id: str,
+    approval_result: dict,
+) -> AsyncGenerator[str, None]:
+    """Resume the FRIDAY graph after an approval decision."""
+    from langgraph.types import Command
+
+    config = {
+        "configurable": {
+            "thread_id": session_id,
+            "user_id": user_id,
+        }
+    }
+
+    status_msg = "Processing approval..." if approval_result.get("approved") else "Cancelling action..."
+    yield format_sse_event(StatusEvent(message=status_msg))
+
+    try:
+        async for event in graph.astream_events(
+            Command(resume=approval_result), config=config, version="v2"
+        ):
+            kind = event.get("event", "")
+            name = event.get("name", "")
+
+            if kind == "on_chat_model_stream":
+                chunk = event.get("data", {}).get("chunk")
+                if chunk and hasattr(chunk, "content") and chunk.content:
+                    yield format_sse_event(TokenEvent(content=chunk.content))
+
+            elif kind == "on_tool_start":
+                yield format_sse_event(StatusEvent(message=f"Using {name}..."))
+
+            elif kind == "on_tool_end":
+                output = event.get("data", {}).get("output", "")
+                result_str = str(output)[:500]
+                yield format_sse_event(
+                    ToolResultEvent(tool_name=name, result=result_str)
+                )
+
+        yield format_sse_event(DoneEvent(session_id=session_id))
+
+    except Exception as e:
+        logger.error(f"Graph resume error: {e}", exc_info=True)
+        yield format_sse_event(ErrorEvent(message=str(e)))
diff --git a/backend/app/main.py b/backend/app/main.py
index 85b9e85..9bf1715 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -1,3 +1,6 @@
+from contextlib import asynccontextmanager
+import asyncio
+
 from fastapi import FastAPI, HTTPException, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
@@ -16,6 +19,13 @@
 # Load environment variables
 load_dotenv()
 
+# Import new routers
+from api.health import router as health_router
+from api.chat import router as chat_router
+from api.tasks import router as tasks_router
+from api.sessions import router as sessions_router
+from api.notifications import router as notifications_router
+
 # Configure logger with line numbers and function names
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -35,10 +45,37 @@
 if not logger.handlers:
     logger.addHandler(console_handler)
 
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan: start/stop background tasks."""
+    heartbeat_task = None
+    try:
+        from config import settings
+        if settings.heartbeat_enabled:
+            from services.heartbeat import heartbeat_loop
+            heartbeat_task = asyncio.create_task(
+                heartbeat_loop(interval=settings.heartbeat_interval_seconds)
+            )
+            logger.info("Heartbeat loop started")
+    except Exception as e:
+        logger.warning(f"Heartbeat not started: {e}")
+
+    yield
+
+    if heartbeat_task:
+        heartbeat_task.cancel()
+        try:
+            await heartbeat_task
+        except asyncio.CancelledError:
+            pass
+        logger.info("Heartbeat loop stopped")
+
+
 app = FastAPI(
-    title="Meeting Summarizer API",
-    description="API for processing and summarizing meeting transcripts",
-    version="1.0.0"
+    title="FRIDAY - AI Workspace Orchestrator",
+    description="Meeting assistant + LangGraph agent for ADHD workspace management",
+    version="2.0.0",
+    lifespan=lifespan,
 )
 
 # Configure CORS
@@ -51,6 +88,13 @@
     max_age=3600,            # Cache preflight requests for 1 hour
 )
 
+# Include new FRIDAY agent routers
+app.include_router(health_router)
+app.include_router(chat_router, prefix="/friday")
+app.include_router(tasks_router, prefix="/tasks")
+app.include_router(sessions_router, prefix="/sessions")
+app.include_router(notifications_router, prefix="/friday/notifications")
+
 # Global database manager instance for meeting management endpoints
 db = DatabaseManager()
 
@@ -543,6 +587,11 @@ async def save_transcript(request: SaveTranscriptRequest):
             )
 
         logger.info("Transcripts saved successfully")
+
+        # Trigger autonomous agent scan of the new meeting
+        from services.heartbeat import trigger_meeting_scan
+        asyncio.create_task(trigger_meeting_scan(meeting_id, request.meeting_title))
+
         return {"status": "success", "message": "Transcript saved successfully", "meeting_id": meeting_id}
     except Exception as e:
         logger.error(f"Error saving transcript: {str(e)}", exc_info=True)
@@ -657,7 +706,7 @@ async def friday_extract(request: FridayExtractRequest):
 
 @app.on_event("shutdown")
 async def shutdown_event():
-    """Cleanup on API shutdown"""
+    """Cleanup on API shutdown."""
     logger.info("API shutting down, cleaning up resources")
     try:
         processor.cleanup()
diff --git a/backend/app/services/__init__.py b/backend/app/services/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/app/services/heartbeat.py b/backend/app/services/heartbeat.py
new file mode 100644
index 0000000..404284b
--- /dev/null
+++ b/backend/app/services/heartbeat.py
@@ -0,0 +1,109 @@
+"""Heartbeat — autonomous meeting scanner and proactive trigger."""
+
+import asyncio
+import logging
+
+from langchain_core.messages import HumanMessage
+
+from services.store import store
+
+logger = logging.getLogger(__name__)
+
+
+async def heartbeat_loop(interval: int = 600):
+    """Background loop that scans unprocessed meetings periodically."""
+    while True:
+        try:
+            await asyncio.sleep(interval)
+            await scan_unprocessed_meetings()
+        except asyncio.CancelledError:
+            logger.info("Heartbeat loop cancelled")
+            break
+        except Exception as e:
+            logger.warning(f"Heartbeat error: {e}")
+            await asyncio.sleep(10)
+
+
+async def scan_unprocessed_meetings():
+    """Find meetings that haven't been scanned yet and process them."""
+    from db import DatabaseManager
+
+    db = DatabaseManager()
+    meetings = await db.get_all_meetings()
+
+    for meeting in meetings:
+        mid = meeting["id"]
+        if store.is_meeting_scanned(mid):
+            continue
+        await process_meeting(mid, meeting.get("title", "Untitled"))
+        store.mark_meeting_scanned(mid)
+        await asyncio.sleep(2)  # Rate limit between meetings
+
+
+async def process_meeting(meeting_id: str, title: str):
+    """Send full transcript to the agent for autonomous processing."""
+    from db import DatabaseManager
+    from agent.graph import friday_graph
+
+    db = DatabaseManager()
+    meeting_data = await db.get_meeting(meeting_id)
+    if not meeting_data or not meeting_data.get("transcripts"):
+        return
+
+    transcript_text = "\n".join(
+        t["text"] for t in meeting_data["transcripts"] if t.get("text")
+    )
+    if not transcript_text.strip():
+        return
+
+    session_id = f"proactive-{meeting_id}"
+    config = {
+        "configurable": {"thread_id": session_id, "user_id": "default"},
+        "recursion_limit": 40,
+    }
+    input_state = {
+        "messages": [
+            HumanMessage(
+                content=(
+                    f"Process this meeting transcript and execute all action items:\n\n"
+                    f"---\nMeeting: {title}\n---\n{transcript_text[:8000]}"
+                )
+            )
+        ],
+        "session_id": session_id,
+        "user_id": "default",
+        "intent": "proactive",
+    }
+
+    try:
+        result = await friday_graph.ainvoke(input_state, config=config)
+
+        # Check if graph was interrupted (agent asked a question)
+        graph_state = await friday_graph.aget_state(config)
+        if graph_state and graph_state.next:
+            # Graph is paused — notification was already stored by ask_user tool
+            pass
+        else:
+            store.add_notification({
+                "type": "info",
+                "title": f"Processed '{title}'",
+                "message": "Meeting scan complete.",
+                "meeting_id": meeting_id,
+                "session_id": session_id,
+            })
+    except Exception as e:
+        logger.error(f"Error processing meeting '{title}': {e}")
+        store.add_notification({
+            "type": "error",
+            "title": f"Error processing '{title}'",
+            "message": str(e)[:300],
+            "meeting_id": meeting_id,
+        })
+
+
+async def trigger_meeting_scan(meeting_id: str, title: str):
+    """Called directly when a recording finishes. Skips the timer."""
+    if store.is_meeting_scanned(meeting_id):
+        return
+    await process_meeting(meeting_id, title)
+    store.mark_meeting_scanned(meeting_id)
diff --git a/backend/app/services/store.py b/backend/app/services/store.py
new file mode 100644
index 0000000..222337a
--- /dev/null
+++ b/backend/app/services/store.py
@@ -0,0 +1,194 @@
+"""In-memory data store with Supabase-compatible interface."""
+
+import uuid
+from datetime import datetime, timezone
+from typing import Optional
+
+
+class InMemoryStore:
+    def __init__(self):
+        self.sessions: dict[str, dict] = {}
+        self.messages: dict[str, list[dict]] = {}
+        self.tasks: dict[str, list[dict]] = {}
+        self.user_context: dict[str, dict[str, dict]] = {}
+        self.approvals: dict[str, dict] = {}
+        self.notifications: list[dict] = []
+        self.scanned_meeting_ids: set[str] = set()
+
+    # --- Sessions ---
+
+    def create_session(self, user_id: str, session_id: Optional[str] = None, title: Optional[str] = None) -> dict:
+        sid = session_id or str(uuid.uuid4())
+        now = datetime.now(timezone.utc).isoformat()
+        session = {
+            "session_id": sid,
+            "user_id": user_id,
+            "title": title or "New conversation",
+            "created_at": now,
+            "updated_at": now,
+        }
+        self.sessions[sid] = session
+        self.messages[sid] = []
+        return session
+
+    def get_session(self, session_id: str) -> Optional[dict]:
+        return self.sessions.get(session_id)
+
+    def list_sessions(self, user_id: str) -> list[dict]:
+        sessions = [s for s in self.sessions.values() if s["user_id"] == user_id]
+        return sorted(sessions, key=lambda s: s["updated_at"], reverse=True)
+
+    def update_session(self, session_id: str, **kwargs) -> Optional[dict]:
+        session = self.sessions.get(session_id)
+        if not session:
+            return None
+        if kwargs:
+            session.update(kwargs)
+        session["updated_at"] = datetime.now(timezone.utc).isoformat()
+        return session
+
+    # --- Messages ---
+
+    def add_message(self, session_id: str, role: str, content: str) -> dict:
+        msg = {
+            "id": str(uuid.uuid4()),
+            "session_id": session_id,
+            "role": role,
+            "content": content,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+        }
+        if session_id not in self.messages:
+            self.messages[session_id] = []
+        self.messages[session_id].append(msg)
+        return msg
+
+    def get_messages(self, session_id: str) -> list[dict]:
+        return self.messages.get(session_id, [])
+
+    # --- Tasks ---
+
+    def create_task(self, user_id: str, title: str, description: Optional[str] = None,
+                    priority: str = "medium", due_at: Optional[str] = None,
+                    source: str = "agent", source_ref: Optional[str] = None) -> dict:
+        task = {
+            "task_id": str(uuid.uuid4()),
+            "user_id": user_id,
+            "title": title,
+            "description": description,
+            "priority": priority,
+            "status": "pending",
+            "due_at": due_at,
+            "source": source,
+            "source_ref": source_ref,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+        }
+        if user_id not in self.tasks:
+            self.tasks[user_id] = []
+        self.tasks[user_id].append(task)
+        return task
+
+    def get_tasks(self, user_id: str, status: Optional[str] = None,
+                  priority: Optional[str] = None, limit: int = 10) -> list[dict]:
+        tasks = self.tasks.get(user_id, [])
+        if status:
+            tasks = [t for t in tasks if t["status"] == status]
+        if priority:
+            tasks = [t for t in tasks if t["priority"] == priority]
+        return sorted(tasks, key=lambda t: t["created_at"], reverse=True)[:limit]
+
+    def update_task(self, user_id: str, task_id: str, **kwargs) -> Optional[dict]:
+        tasks = self.tasks.get(user_id, [])
+        for task in tasks:
+            if task["task_id"] == task_id:
+                task.update(kwargs)
+                task["updated_at"] = datetime.now(timezone.utc).isoformat()
+                return task
+        return None
+
+    # --- User Context ---
+
+    def get_user_context(self, user_id: str, context_key: Optional[str] = None) -> dict | list[dict]:
+        user_ctx = self.user_context.get(user_id, {})
+        if context_key:
+            return user_ctx.get(context_key, {})
+        return list(user_ctx.values())
+
+    def save_user_context(self, user_id: str, context_key: str, context_value: dict,
+                          confidence: float = 0.5, source: str = "") -> dict:
+        if user_id not in self.user_context:
+            self.user_context[user_id] = {}
+        entry = {
+            "context_key": context_key,
+            "context_value": context_value,
+            "confidence": confidence,
+            "source": source,
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+        }
+        self.user_context[user_id][context_key] = entry
+        return entry
+
+    # --- Notifications ---
+
+    def add_notification(self, notif: dict) -> str:
+        nid = str(uuid.uuid4())
+        notif["id"] = nid
+        notif["status"] = notif.get("status", "unread")
+        notif["created_at"] = datetime.now(timezone.utc).isoformat()
+        notif.setdefault("meeting_id", None)
+        notif.setdefault("session_id", None)
+        self.notifications.insert(0, notif)
+        return nid
+
+    def get_notifications(self, limit: int = 50) -> list[dict]:
+        return self.notifications[:limit]
+
+    def get_unread_count(self) -> int:
+        return sum(1 for n in self.notifications if n["status"] == "unread")
+
+    def get_notification(self, notification_id: str) -> Optional[dict]:
+        for n in self.notifications:
+            if n["id"] == notification_id:
+                return n
+        return None
+
+    def update_notification(self, notification_id: str, **kwargs) -> Optional[dict]:
+        for n in self.notifications:
+            if n["id"] == notification_id:
+                n.update(kwargs)
+                return n
+        return None
+
+    # --- Scan Tracking ---
+
+    def mark_meeting_scanned(self, meeting_id: str):
+        self.scanned_meeting_ids.add(meeting_id)
+
+    def is_meeting_scanned(self, meeting_id: str) -> bool:
+        return meeting_id in self.scanned_meeting_ids
+
+    # --- Approvals ---
+
+    def create_approval(self, session_id: str, approval_data: dict) -> str:
+        approval_id = str(uuid.uuid4())
+        self.approvals[approval_id] = {
+            "id": approval_id,
+            "session_id": session_id,
+            "status": "pending",
+            "data": approval_data,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+        }
+        return approval_id
+
+    def resolve_approval(self, approval_id: str, status: str, edited_payload: Optional[dict] = None) -> Optional[dict]:
+        approval = self.approvals.get(approval_id)
+        if not approval:
+            return None
+        approval["status"] = status
+        approval["edited_payload"] = edited_payload
+        approval["resolved_at"] = datetime.now(timezone.utc).isoformat()
+        return approval
+
+
+# Singleton
+store = InMemoryStore()
diff --git a/backend/langgraph_entry.py b/backend/langgraph_entry.py
new file mode 100644
index 0000000..038f693
--- /dev/null
+++ b/backend/langgraph_entry.py
@@ -0,0 +1,24 @@
+"""LangGraph entrypoint — adds app/ to sys.path so bare imports work,
+then patches relative imports to absolute before loading the graph."""
+import importlib
+import sys
+from pathlib import Path
+
+# Add app/ to sys.path so bare imports like `from config import settings` resolve
+_app_dir = str(Path(__file__).parent / "app")
+if _app_dir not in sys.path:
+    sys.path.insert(0, _app_dir)
+
+# Also ensure backend/ is on the path for `app.agent.*` style imports
+_backend_dir = str(Path(__file__).parent)
+if _backend_dir not in sys.path:
+    sys.path.insert(0, _backend_dir)
+
+# Pre-load the agent package so relative imports work
+import app.agent  # noqa: E402
+
+# Now import the graph — the relative imports inside graph.py will resolve
+# because app.agent is a loaded package
+from app.agent.graph import friday_graph_platform as friday_graph  # noqa: E402
+
+__all__ = ["friday_graph"]
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 99698b9..ce0416d 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -10,4 +10,14 @@ aiosqlite==0.21.0
 ollama==0.5.2
 google-genai>=1.0.0
 # Supabase
-supabase>=2.10.0
\ No newline at end of file
+supabase>=2.10.0
+# LangGraph Agent
+langgraph>=1.0.0
+langchain-google-genai>=2.0.0
+langchain-openai>=0.3.0
+langchain-core>=1.0.0
+pydantic-settings>=2.0
+httpx>=0.27
+structlog>=24.0
+exa-py>=1.0
+langchain-exa>=0.2
diff --git a/frontend/clean_run.sh b/frontend/clean_run.sh
index ff61804..a0cbb4d 100755
--- a/frontend/clean_run.sh
+++ b/frontend/clean_run.sh
@@ -38,6 +38,12 @@ pnpm run build
 
 # Set environment variables for the build
 echo "Setting up build environment..."
+if [ -f .env ]; then
+  echo "Loading .env..."
+  set -a
+  source .env
+  set +a
+fi
 
 echo "Building Tauri app..."
 pnpm run tauri dev
diff --git a/frontend/src/app/agent/page.tsx b/frontend/src/app/agent/page.tsx
index 78070e7..249aae6 100644
--- a/frontend/src/app/agent/page.tsx
+++ b/frontend/src/app/agent/page.tsx
@@ -143,6 +143,8 @@ export default function AgentInboxPage() {
     }
   };
 
+  const isBrowserOnly = typeof window !== "undefined" && !(window as any).__TAURI_INTERNALS__;
+
   return (
     <div className="h-screen overflow-y-auto bg-background text-foreground">
       <div className="sticky top-0 z-10 bg-background border-b border-border">
@@ -165,7 +167,7 @@ export default function AgentInboxPage() {
               </p>
             </div>
           </div>
-          <Button variant="outline" onClick={runNow} disabled={isRunning || status?.is_running}>
+          <Button variant="outline" onClick={runNow} disabled={isBrowserOnly || isRunning || status?.is_running}>
             <RefreshCw className={`h-4 w-4 ${(isRunning || status?.is_running) ? "animate-spin" : ""}`} />
             {isRunning || status?.is_running ? "Running..." : "Run now"}
           </Button>
@@ -173,6 +175,15 @@ export default function AgentInboxPage() {
       </div>
 
       <div className="max-w-6xl mx-auto p-8 space-y-6">
+        {isBrowserOnly && (
+          <div className="rounded-md border border-amber-200 bg-amber-50 px-4 py-3 text-sm text-amber-800 flex items-start gap-2">
+            <AlertCircle className="h-4 w-4 mt-0.5 shrink-0" />
+            <span>
+              The Agent Inbox requires the Friday desktop app (Tauri). In browser mode, use the{" "}
+              <strong>Notifications panel</strong> (bell icon in the sidebar) to see agent activity from the Python backend.
+            </span>
+          </div>
+        )}
         {isLoading ? (
           <div className="rounded-lg border border-border bg-card p-6">Loading agent inbox...</div>
         ) : (
diff --git a/frontend/src/app/layout.tsx b/frontend/src/app/layout.tsx
index 6e63eee..bcaac29 100644
--- a/frontend/src/app/layout.tsx
+++ b/frontend/src/app/layout.tsx
@@ -9,10 +9,10 @@ import AnalyticsProvider from '@/components/AnalyticsProvider'
 import { Toaster, toast } from 'sonner'
 import "sonner/dist/styles.css"
 import { useState, useEffect, useCallback } from 'react'
-import { listen, UnlistenFn } from '@tauri-apps/api/event'
-import { invoke } from '@tauri-apps/api/core'
+import { safeInvoke, safeListen, isTauriAvailable } from '@/lib/tauri-compat'
 import { TooltipProvider } from '@/components/ui/tooltip'
 import { RecordingStateProvider } from '@/contexts/RecordingStateContext'
+import { NotificationsProvider } from '@/contexts/NotificationsContext'
 import { OllamaDownloadProvider } from '@/contexts/OllamaDownloadContext'
 import { TranscriptProvider } from '@/contexts/TranscriptContext'
 import { ConfigProvider, useConfig } from '@/contexts/ConfigContext'
@@ -78,7 +78,13 @@ export default function RootLayout({
 
   useEffect(() => {
     // Check onboarding status first
-    invoke<{ completed: boolean } | null>('get_onboarding_status')
+    if (!isTauriAvailable()) {
+      console.log('[Layout] Tauri not available — skipping onboarding for browser dev')
+      setShowOnboarding(false)
+      setOnboardingCompleted(true)
+      return
+    }
+    safeInvoke<{ completed: boolean } | null>('get_onboarding_status')
       .then((status) => {
         const isComplete = status?.completed ?? false
         setOnboardingCompleted(isComplete)
@@ -92,7 +98,6 @@ export default function RootLayout({
       })
       .catch((error) => {
         console.error('[Layout] Failed to check onboarding status:', error)
-        // Default to showing onboarding if we can't check
         setShowOnboarding(true)
         setOnboardingCompleted(false)
       })
@@ -108,7 +113,7 @@ export default function RootLayout({
   }, []);
   useEffect(() => {
     // Listen for tray recording toggle request
-    const unlisten = listen('request-recording-toggle', () => {
+    const unlistenPromise = safeListen('request-recording-toggle', () => {
       console.log('[Layout] Received request-recording-toggle from tray');
 
       if (showOnboarding) {
@@ -123,7 +128,7 @@ export default function RootLayout({
     });
 
     return () => {
-      unlisten.then(fn => fn());
+      unlistenPromise.then(fn => fn());
     };
   }, [showOnboarding]);
 
@@ -158,14 +163,14 @@ export default function RootLayout({
 
   // Listen for drag-drop events
   useEffect(() => {
-    if (showOnboarding) return; // Don't handle drops during onboarding
+    if (showOnboarding || !isTauriAvailable()) return; // Don't handle drops during onboarding or browser mode
 
-    const unlisteners: UnlistenFn[] = [];
+    const unlisteners: (() => void)[] = [];
     const cleanedUpRef = { current: false };
 
     const setupListeners = async () => {
       // Drag enter/over - show overlay only if beta feature is enabled
-      const unlistenDragEnter = await listen('tauri://drag-enter', () => {
+      const unlistenDragEnter = await safeListen('tauri://drag-enter', () => {
         if (loadBetaFeatures().importAndRetranscribe) {
           setShowDropOverlay(true);
         }
@@ -177,7 +182,7 @@ export default function RootLayout({
       unlisteners.push(unlistenDragEnter);
 
       // Drag leave - hide overlay
-      const unlistenDragLeave = await listen('tauri://drag-leave', () => {
+      const unlistenDragLeave = await safeListen('tauri://drag-leave', () => {
         setShowDropOverlay(false);
       });
       if (cleanedUpRef.current) {
@@ -188,7 +193,7 @@ export default function RootLayout({
       unlisteners.push(unlistenDragLeave);
 
       // Drop - process files
-      const unlistenDrop = await listen<{ paths: string[] }>('tauri://drag-drop', (event) => {
+      const unlistenDrop = await safeListen<{ paths: string[] }>('tauri://drag-drop', (event) => {
         setShowDropOverlay(false);
         handleFileDrop(event.payload.paths);
       });
@@ -241,31 +246,33 @@ export default function RootLayout({
                   <OnboardingProvider>
                     <UpdateCheckProvider>
                       <SidebarProvider>
-                        <TooltipProvider>
-                          <RecordingPostProcessingProvider>
-                            <ImportDialogProvider onOpen={handleOpenImportDialog}>
-                              {/* Download progress toast provider - listens for background downloads */}
-                              <DownloadProgressToastProvider />
-
-                              {/* Show onboarding or main app */}
-                              {showOnboarding ? (
-                                <OnboardingFlow onComplete={handleOnboardingComplete} />
-                              ) : (
-                                <div className="flex">
-                                  <Sidebar />
-                                  <MainContent>{children}</MainContent>
-                                </div>
-                              )}
-                              {/* Import audio overlay and dialog */}
-                              <ImportDropOverlay visible={showDropOverlay} />
-                              <ConditionalImportDialog
-                                showImportDialog={showImportDialog}
-                                handleImportDialogClose={handleImportDialogClose}
-                                importFilePath={importFilePath}
-                              />
-                            </ImportDialogProvider>
-                          </RecordingPostProcessingProvider>
-                        </TooltipProvider>
+                        <NotificationsProvider>
+                          <TooltipProvider>
+                            <RecordingPostProcessingProvider>
+                              <ImportDialogProvider onOpen={handleOpenImportDialog}>
+                                {/* Download progress toast provider - listens for background downloads */}
+                                <DownloadProgressToastProvider />
+
+                                {/* Show onboarding or main app */}
+                                {showOnboarding ? (
+                                  <OnboardingFlow onComplete={handleOnboardingComplete} />
+                                ) : (
+                                  <div className="flex">
+                                    <Sidebar />
+                                    <MainContent>{children}</MainContent>
+                                  </div>
+                                )}
+                                {/* Import audio overlay and dialog */}
+                                <ImportDropOverlay visible={showDropOverlay} />
+                                <ConditionalImportDialog
+                                  showImportDialog={showImportDialog}
+                                  handleImportDialogClose={handleImportDialogClose}
+                                  importFilePath={importFilePath}
+                                />
+                              </ImportDialogProvider>
+                            </RecordingPostProcessingProvider>
+                          </TooltipProvider>
+                        </NotificationsProvider>
                       </SidebarProvider>
                     </UpdateCheckProvider>
                   </OnboardingProvider>
diff --git a/frontend/src/components/AnalyticsProvider.tsx b/frontend/src/components/AnalyticsProvider.tsx
index dc1b75f..a1f7455 100644
--- a/frontend/src/components/AnalyticsProvider.tsx
+++ b/frontend/src/components/AnalyticsProvider.tsx
@@ -2,7 +2,7 @@
 
 import React, { useEffect, ReactNode, useRef, useState, createContext } from 'react';
 import Analytics from '@/lib/analytics';
-import { load } from '@tauri-apps/plugin-store';
+import { isTauriAvailable } from '@/lib/tauri-compat';
 
 
 interface AnalyticsProviderProps {
@@ -30,6 +30,13 @@ export default function AnalyticsProvider({ children }: AnalyticsProviderProps)
     }
 
     const initAnalytics = async () => {
+      if (!isTauriAvailable()) {
+        // In browser mode, skip analytics entirely
+        console.log('[Analytics] Tauri not available — skipping analytics init');
+        initialized.current = true;
+        return;
+      }
+      const { load } = await import('@tauri-apps/plugin-store');
       const store = await load('analytics.json', {
         autoSave: false,
         defaults: {
@@ -63,6 +70,7 @@ export default function AnalyticsProvider({ children }: AnalyticsProviderProps)
       const deviceInfo = await Analytics.getDeviceInfo();
 
       // Store platform info in analytics.json for quick access
+      const { load } = await import('@tauri-apps/plugin-store');
       const store = await load('analytics.json', {
         autoSave: false,
         defaults: {
diff --git a/frontend/src/components/Notifications/NotificationCard.tsx b/frontend/src/components/Notifications/NotificationCard.tsx
new file mode 100644
index 0000000..74e771e
--- /dev/null
+++ b/frontend/src/components/Notifications/NotificationCard.tsx
@@ -0,0 +1,92 @@
+'use client';
+
+import React, { useState } from 'react';
+import { CheckCircle2, MessageCircleQuestion, Info, AlertCircle, X, Send } from 'lucide-react';
+import { useNotifications } from '@/contexts/NotificationsContext';
+
+interface Notification {
+  id: string;
+  type: 'info' | 'action_taken' | 'question' | 'error';
+  title: string;
+  message: string;
+  status: string;
+  created_at: string;
+}
+
+function timeAgo(dateStr: string): string {
+  const now = Date.now();
+  const then = new Date(dateStr).getTime();
+  const diffSec = Math.floor((now - then) / 1000);
+  if (diffSec < 60) return 'just now';
+  if (diffSec < 3600) return `${Math.floor(diffSec / 60)}m ago`;
+  if (diffSec < 86400) return `${Math.floor(diffSec / 3600)}h ago`;
+  return `${Math.floor(diffSec / 86400)}d ago`;
+}
+
+const ICON_MAP = {
+  action_taken: <CheckCircle2 className="w-5 h-5 text-green-500 flex-shrink-0" />,
+  question: <MessageCircleQuestion className="w-5 h-5 text-blue-500 flex-shrink-0" />,
+  info: <Info className="w-5 h-5 text-gray-500 flex-shrink-0" />,
+  error: <AlertCircle className="w-5 h-5 text-red-500 flex-shrink-0" />,
+};
+
+export default function NotificationCard({ notification }: { notification: Notification }) {
+  const { replyToNotification, dismissNotification } = useNotifications();
+  const [replyText, setReplyText] = useState('');
+  const [sending, setSending] = useState(false);
+  const isUnread = notification.status === 'unread';
+  const isQuestion = notification.type === 'question' && notification.status !== 'answered';
+
+  const handleReply = async () => {
+    if (!replyText.trim()) return;
+    setSending(true);
+    await replyToNotification(notification.id, replyText.trim());
+    setReplyText('');
+    setSending(false);
+  };
+
+  return (
+    <div className={`p-3 rounded-lg border ${isUnread ? 'bg-blue-50/50 border-blue-100' : 'bg-card border-border'} transition-colors`}>
+      <div className="flex items-start gap-2">
+        {ICON_MAP[notification.type] || ICON_MAP.info}
+        <div className="flex-1 min-w-0">
+          <div className="flex items-center gap-2">
+            <span className="font-medium text-sm text-foreground truncate">{notification.title}</span>
+            {isUnread && <span className="w-2 h-2 rounded-full bg-blue-500 flex-shrink-0" />}
+          </div>
+          <p className="text-sm text-muted-foreground mt-0.5">{notification.message}</p>
+          <span className="text-xs text-muted-foreground mt-1 block">{timeAgo(notification.created_at)}</span>
+        </div>
+        {!isQuestion && (
+          <button
+            onClick={() => dismissNotification(notification.id)}
+            className="p-1 rounded hover:bg-secondary text-muted-foreground flex-shrink-0"
+          >
+            <X className="w-3.5 h-3.5" />
+          </button>
+        )}
+      </div>
+
+      {isQuestion && (
+        <div className="mt-2 flex gap-2">
+          <input
+            type="text"
+            value={replyText}
+            onChange={(e) => setReplyText(e.target.value)}
+            onKeyDown={(e) => e.key === 'Enter' && handleReply()}
+            placeholder="Type your reply..."
+            className="flex-1 px-2 py-1.5 text-sm border border-border rounded-md bg-background focus:outline-none focus:ring-1 focus:ring-blue-500"
+            disabled={sending}
+          />
+          <button
+            onClick={handleReply}
+            disabled={sending || !replyText.trim()}
+            className="px-2 py-1.5 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+          >
+            <Send className="w-3.5 h-3.5" />
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/components/Notifications/NotificationsPanel.tsx b/frontend/src/components/Notifications/NotificationsPanel.tsx
new file mode 100644
index 0000000..58115d8
--- /dev/null
+++ b/frontend/src/components/Notifications/NotificationsPanel.tsx
@@ -0,0 +1,40 @@
+'use client';
+
+import React from 'react';
+import { Sheet, SheetContent, SheetHeader, SheetTitle } from '@/components/ui/sheet';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import { useNotifications } from '@/contexts/NotificationsContext';
+import NotificationCard from './NotificationCard';
+
+export default function NotificationsPanel() {
+  const { notifications, isOpen, setIsOpen, markAllRead } = useNotifications();
+
+  return (
+    <Sheet open={isOpen} onOpenChange={setIsOpen}>
+      <SheetContent side="right" className="w-[380px] sm:w-[420px] p-0">
+        <SheetHeader className="px-4 pt-4 pb-2 border-b border-border">
+          <div className="flex items-center justify-between">
+            <SheetTitle className="text-lg font-semibold">Agent Activity</SheetTitle>
+            <button
+              onClick={markAllRead}
+              className="text-xs text-blue-600 hover:text-blue-800 font-medium"
+            >
+              Mark all read
+            </button>
+          </div>
+        </SheetHeader>
+        <ScrollArea className="h-[calc(100vh-80px)]">
+          <div className="p-3 space-y-2">
+            {notifications.length === 0 ? (
+              <div className="text-center text-muted-foreground text-sm py-12">
+                No notifications yet. The agent will post updates here as it processes meetings.
+              </div>
+            ) : (
+              notifications.map((n) => <NotificationCard key={n.id} notification={n} />)
+            )}
+          </div>
+        </ScrollArea>
+      </SheetContent>
+    </Sheet>
+  );
+}
diff --git a/frontend/src/components/Sidebar/SidebarProvider.tsx b/frontend/src/components/Sidebar/SidebarProvider.tsx
index 243ed21..40142fb 100644
--- a/frontend/src/components/Sidebar/SidebarProvider.tsx
+++ b/frontend/src/components/Sidebar/SidebarProvider.tsx
@@ -3,7 +3,7 @@
 import React, { createContext, useContext, useState, useEffect } from 'react';
 import { usePathname, useRouter } from 'next/navigation';
 import Analytics from '@/lib/analytics';
-import { invoke } from '@tauri-apps/api/core';
+import { safeInvoke } from '@/lib/tauri-compat';
 import { useRecordingState } from '@/contexts/RecordingStateContext';
 
 
@@ -86,7 +86,7 @@ export function SidebarProvider({ children }: { children: React.ReactNode }) {
   const fetchMeetings = React.useCallback(async () => {
     if (serverAddress) {
       try {
-        const meetings = await invoke('api_get_meetings') as Array<{ id: string, title: string }>;
+        const meetings = await safeInvoke('api_get_meetings') as Array<{ id: string, title: string }>;
         const transformedMeetings = meetings.map((meeting: any) => ({
           id: meeting.id,
           title: meeting.title
@@ -174,7 +174,7 @@ export function SidebarProvider({ children }: { children: React.ReactNode }) {
       setIsSearching(true);
 
 
-      const results = await invoke('api_search_transcripts', { query }) as TranscriptSearchResult[];
+      const results = await safeInvoke('api_search_transcripts', { query }) as TranscriptSearchResult[];
       setSearchResults(results);
     } catch (error) {
       console.error('Error searching transcripts:', error);
@@ -219,7 +219,7 @@ export function SidebarProvider({ children }: { children: React.ReactNode }) {
         return;
       }
       try {
-        const result = await invoke('api_get_summary', {
+        const result = await safeInvoke('api_get_summary', {
           meetingId: meetingId,
         }) as any;
 
diff --git a/frontend/src/components/Sidebar/index.tsx b/frontend/src/components/Sidebar/index.tsx
index 9294e51..6fdd305 100644
--- a/frontend/src/components/Sidebar/index.tsx
+++ b/frontend/src/components/Sidebar/index.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import React, { useState, useMemo, useEffect, useCallback } from 'react';
-import { ChevronDown, ChevronRight, File, Settings, ChevronLeftCircle, ChevronRightCircle, Calendar, StickyNote, Home, Trash2, Mic, Square, Plus, Search, Pencil, NotebookPen, SearchIcon, X, Upload, BrainCircuit } from 'lucide-react';
+import { ChevronDown, ChevronRight, File, Settings, ChevronLeftCircle, ChevronRightCircle, Calendar, StickyNote, Home, Trash2, Mic, Square, Plus, Search, Pencil, NotebookPen, SearchIcon, X, Upload, Bell, BrainCircuit } from 'lucide-react';
 import { useRouter, usePathname } from 'next/navigation';
 import { useSidebar } from './SidebarProvider';
 import type { CurrentMeeting } from '@/components/Sidebar/SidebarProvider';
@@ -10,12 +10,14 @@ import { ModelConfig } from '@/components/ModelSettingsModal';
 import { SettingTabs } from '../SettingTabs';
 import { TranscriptModelProps } from '@/components/TranscriptSettings';
 import Analytics from '@/lib/analytics';
-import { invoke } from '@tauri-apps/api/core';
+import { safeInvoke, safeListen, isTauriAvailable } from '@/lib/tauri-compat';
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
 import { toast } from 'sonner';
 import { useRecordingState } from '@/contexts/RecordingStateContext';
 import { useImportDialog } from '@/contexts/ImportDialogContext';
 import { useConfig } from '@/contexts/ConfigContext';
+import { useNotifications } from '@/contexts/NotificationsContext';
+import NotificationsPanel from '@/components/Notifications/NotificationsPanel';
 
 import {
   Dialog,
@@ -61,6 +63,7 @@ const Sidebar: React.FC = () => {
   const { isRecording } = useRecordingState();
   const { openImportDialog } = useImportDialog();
   const { betaFeatures } = useConfig();
+  const { unreadCount, setIsOpen: setNotificationsOpen } = useNotifications();
   const [expandedFolders, setExpandedFolders] = useState<Set<string>>(new Set(['meetings']));
   const [searchQuery, setSearchQuery] = useState<string>('');
   const [showModelSettings, setShowModelSettings] = useState(false);
@@ -115,12 +118,12 @@ const Sidebar: React.FC = () => {
       }
 
       try {
-        const data = await invoke('api_get_model_config') as any;
+        const data = await safeInvoke('api_get_model_config') as any;
         if (data && data.provider !== null) {
           // Fetch API key if not included and provider requires it
           if (data.provider !== 'ollama' && !data.apiKey) {
             try {
-              const apiKeyData = await invoke('api_get_api_key', {
+              const apiKeyData = await safeInvoke('api_get_api_key', {
                 provider: data.provider
               }) as string;
               data.apiKey = apiKeyData;
@@ -149,7 +152,7 @@ const Sidebar: React.FC = () => {
       }
 
       try {
-        const data = await invoke('api_get_transcript_config') as any;
+        const data = await safeInvoke('api_get_transcript_config') as any;
         if (data && data.provider !== null) {
           setTranscriptModelConfig(data);
         }
@@ -163,8 +166,7 @@ const Sidebar: React.FC = () => {
   // Listen for model config updates from other components
   useEffect(() => {
     const setupListener = async () => {
-      const { listen } = await import('@tauri-apps/api/event');
-      const unlisten = await listen<ModelConfig>('model-config-updated', (event) => {
+      const unlisten = await safeListen<ModelConfig>('model-config-updated', (event) => {
         console.log('Sidebar received model-config-updated event:', event.payload);
         setModelConfig(event.payload);
       });
@@ -185,7 +187,7 @@ const Sidebar: React.FC = () => {
   // Handle model config save
   const handleSaveModelConfig = async (config: ModelConfig) => {
     try {
-      await invoke('api_save_model_config', {
+      await safeInvoke('api_save_model_config', {
         provider: config.provider,
         model: config.model,
         whisperModel: config.whisperModel,
@@ -198,8 +200,10 @@ const Sidebar: React.FC = () => {
       setSettingsSaveSuccess(true);
 
       // Emit event to sync other components
-      const { emit } = await import('@tauri-apps/api/event');
-      await emit('model-config-updated', config);
+      if (isTauriAvailable()) {
+        const { emit } = await import('@tauri-apps/api/event');
+        await emit('model-config-updated', config);
+      }
 
       // Track settings change
       await Analytics.trackSettingsChanged('model_config', `${config.provider}_${config.model}`);
@@ -219,7 +223,7 @@ const Sidebar: React.FC = () => {
       };
       console.log('Saving transcript config with payload:', payload);
 
-      await invoke('api_save_transcript_config', {
+      await safeInvoke('api_save_transcript_config', {
         provider: payload.provider,
         model: payload.model,
         apiKey: payload.apiKey,
@@ -325,8 +329,7 @@ const Sidebar: React.FC = () => {
     };
 
     try {
-      const { invoke } = await import('@tauri-apps/api/core');
-      await invoke('api_delete_meeting', {
+      await safeInvoke('api_delete_meeting', {
         meetingId: itemId,
       });
       console.log('Meeting deleted successfully');
@@ -384,7 +387,7 @@ const Sidebar: React.FC = () => {
     }
 
     try {
-      await invoke('api_save_meeting_title', {
+      await safeInvoke('api_save_meeting_title', {
         meetingId: meetingId,
         title: newTitle,
       });
@@ -835,6 +838,19 @@ const Sidebar: React.FC = () => {
               <span>Agent Inbox</span>
             </button>
 
+            <button
+              onClick={() => setNotificationsOpen(true)}
+              className="w-full flex items-center justify-center px-3 py-1.5 mt-1 text-sm font-medium text-foreground bg-secondary hover:bg-muted rounded-lg transition-colors shadow-sm relative"
+            >
+              <Bell className="w-4 h-4 mr-2" />
+              <span>Notifications</span>
+              {unreadCount > 0 && (
+                <span className="ml-auto w-5 h-5 bg-red-500 text-white text-[10px] font-bold rounded-full flex items-center justify-center">
+                  {unreadCount > 9 ? '9+' : unreadCount}
+                </span>
+              )}
+            </button>
+
             <button
               onClick={() => router.push('/settings')}
               className="w-full flex items-center justify-center px-3 py-1.5 mt-1 mb-1 text-sm font-medium text-foreground bg-secondary hover:bg-muted rounded-lg transition-colors shadow-sm"
@@ -908,6 +924,9 @@ const Sidebar: React.FC = () => {
           </DialogFooter>
         </DialogContent>
       </Dialog>
+
+      {/* Notifications Panel */}
+      <NotificationsPanel />
     </div>
   );
 };
diff --git a/frontend/src/contexts/ConfigContext.tsx b/frontend/src/contexts/ConfigContext.tsx
index 6aa6011..e38139e 100644
--- a/frontend/src/contexts/ConfigContext.tsx
+++ b/frontend/src/contexts/ConfigContext.tsx
@@ -4,7 +4,7 @@ import React, { createContext, useContext, useState, useEffect, useCallback, use
 import { TranscriptModelProps } from '@/components/TranscriptSettings';
 import { SelectedDevices } from '@/components/DeviceSelection';
 import { configService, ModelConfig } from '@/services/configService';
-import { invoke } from '@tauri-apps/api/core';
+import { safeInvoke, safeListen, isTauriAvailable } from '@/lib/tauri-compat';
 import Analytics from '@/lib/analytics';
 import { BetaFeatures, BetaFeatureKey, loadBetaFeatures, saveBetaFeatures } from '@/types/betaFeatures';
 
@@ -180,7 +180,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
     const loadModels = async () => {
       try {
         const endpoint = modelConfig.ollamaEndpoint || null;
-        const modelList = await invoke<OllamaModel[]>('get_ollama_models', { endpoint });
+        const modelList = await safeInvoke<OllamaModel[]>('get_ollama_models', { endpoint });
         setModels(modelList);
         setError('');
       } catch (err) {
@@ -214,7 +214,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
   // Sync language preference to Rust on mount (fixes startup desync bug)
   useEffect(() => {
     if (selectedLanguage) {
-      invoke('set_language_preference', { language: selectedLanguage })
+      safeInvoke('set_language_preference', { language: selectedLanguage })
         .then(() => {
           console.log('[ConfigContext] Synced language preference to Rust on startup:', selectedLanguage);
         })
@@ -298,7 +298,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
         const providers = ['claude', 'groq', 'openai', 'openrouter'];
         const keys = await Promise.all(
           providers.map(p =>
-            invoke<string>('api_get_api_key', { provider: p })
+            safeInvoke<string>('api_get_api_key', { provider: p })
               .catch(() => null) // Gracefully handle missing keys
           )
         );
@@ -321,8 +321,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
   // Listen for model config updates from other components
   useEffect(() => {
     const setupListener = async () => {
-      const { listen } = await import('@tauri-apps/api/event');
-      const unlisten = await listen<ModelConfig>('model-config-updated', (event) => {
+      const unlisten = await safeListen<ModelConfig>('model-config-updated', (event) => {
         console.log('[ConfigContext] Received model-config-updated event:', event.payload);
         setModelConfig(event.payload);
 
@@ -429,7 +428,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
       // Load notification settings from backend
       let settings: NotificationSettings | null = null;
       try {
-        settings = await invoke<NotificationSettings>('get_notification_settings');
+        settings = await safeInvoke<NotificationSettings>('get_notification_settings');
         setNotificationSettings(settings);
       } catch (notifError) {
         console.error('[ConfigContext] Failed to load notification settings:', notifError);
@@ -439,9 +438,9 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
 
       // Load storage locations
       const [dbDir, modelsDir, recordingsDir] = await Promise.all([
-        invoke<string>('get_database_directory'),
-        invoke<string>('whisper_get_models_directory'),
-        invoke<string>('get_default_recordings_folder_path')
+        safeInvoke<string>('get_database_directory'),
+        safeInvoke<string>('whisper_get_models_directory'),
+        safeInvoke<string>('get_default_recordings_folder_path')
       ]);
 
       setStorageLocations({
@@ -463,7 +462,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
   // Update notification settings
   const updateNotificationSettings = useCallback(async (settings: NotificationSettings) => {
     try {
-      await invoke('set_notification_settings', { settings });
+      await safeInvoke('set_notification_settings', { settings });
       setNotificationSettings(settings);
     } catch (error) {
       console.error('[ConfigContext] Failed to update notification settings:', error);
@@ -478,7 +477,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
       localStorage.setItem('primaryLanguage', lang);
     }
     // Sync with Rust in-memory state for live recording
-    invoke('set_language_preference', { language: lang }).catch(err =>
+    safeInvoke('set_language_preference', { language: lang }).catch(err =>
       console.error('Failed to sync language preference to Rust:', err)
     );
   }, []);
diff --git a/frontend/src/contexts/NotificationsContext.tsx b/frontend/src/contexts/NotificationsContext.tsx
new file mode 100644
index 0000000..35c6119
--- /dev/null
+++ b/frontend/src/contexts/NotificationsContext.tsx
@@ -0,0 +1,130 @@
+'use client';
+
+import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
+
+interface Notification {
+  id: string;
+  type: 'info' | 'action_taken' | 'question' | 'error';
+  title: string;
+  message: string;
+  meeting_id?: string | null;
+  session_id?: string | null;
+  status: 'unread' | 'read' | 'answered' | 'dismissed';
+  created_at: string;
+}
+
+interface NotificationsContextType {
+  notifications: Notification[];
+  unreadCount: number;
+  isOpen: boolean;
+  setIsOpen: (open: boolean) => void;
+  fetchNotifications: () => Promise<void>;
+  replyToNotification: (id: string, message: string) => Promise<void>;
+  dismissNotification: (id: string) => Promise<void>;
+  markAllRead: () => Promise<void>;
+}
+
+const NotificationsContext = createContext<NotificationsContextType | null>(null);
+
+const BACKEND_URL = 'http://localhost:5167';
+
+export function NotificationsProvider({ children }: { children: React.ReactNode }) {
+  const [notifications, setNotifications] = useState<Notification[]>([]);
+  const [unreadCount, setUnreadCount] = useState(0);
+  const [isOpen, setIsOpen] = useState(false);
+
+  const fetchUnreadCount = useCallback(async () => {
+    try {
+      const res = await fetch(`${BACKEND_URL}/friday/notifications/unread-count`);
+      if (res.ok) {
+        const data = await res.json();
+        setUnreadCount(data.count);
+      }
+    } catch {
+      // Backend not available — silently ignore
+    }
+  }, []);
+
+  const fetchNotifications = useCallback(async () => {
+    try {
+      const res = await fetch(`${BACKEND_URL}/friday/notifications?limit=50`);
+      if (res.ok) {
+        const data = await res.json();
+        setNotifications(data);
+        setUnreadCount(data.filter((n: Notification) => n.status === 'unread').length);
+      }
+    } catch {
+      // Backend not available
+    }
+  }, []);
+
+  const replyToNotification = useCallback(async (id: string, message: string) => {
+    try {
+      const res = await fetch(`${BACKEND_URL}/friday/notifications/${id}/reply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message }),
+      });
+      if (res.ok) {
+        await fetchNotifications();
+      }
+    } catch (e) {
+      console.error('Failed to reply to notification:', e);
+    }
+  }, [fetchNotifications]);
+
+  const dismissNotification = useCallback(async (id: string) => {
+    try {
+      await fetch(`${BACKEND_URL}/friday/notifications/${id}/dismiss`, { method: 'POST' });
+      await fetchNotifications();
+    } catch (e) {
+      console.error('Failed to dismiss notification:', e);
+    }
+  }, [fetchNotifications]);
+
+  const markAllRead = useCallback(async () => {
+    try {
+      await fetch(`${BACKEND_URL}/friday/notifications/mark-read`, { method: 'POST' });
+      await fetchNotifications();
+    } catch (e) {
+      console.error('Failed to mark all read:', e);
+    }
+  }, [fetchNotifications]);
+
+  // Poll unread count every 30s
+  useEffect(() => {
+    fetchUnreadCount();
+    const interval = setInterval(fetchUnreadCount, 30_000);
+    return () => clearInterval(interval);
+  }, [fetchUnreadCount]);
+
+  // Fetch full list when panel opens
+  useEffect(() => {
+    if (isOpen) {
+      fetchNotifications();
+    }
+  }, [isOpen, fetchNotifications]);
+
+  return (
+    <NotificationsContext.Provider
+      value={{
+        notifications,
+        unreadCount,
+        isOpen,
+        setIsOpen,
+        fetchNotifications,
+        replyToNotification,
+        dismissNotification,
+        markAllRead,
+      }}
+    >
+      {children}
+    </NotificationsContext.Provider>
+  );
+}
+
+export function useNotifications() {
+  const ctx = useContext(NotificationsContext);
+  if (!ctx) throw new Error('useNotifications must be used within NotificationsProvider');
+  return ctx;
+}
diff --git a/frontend/src/contexts/OllamaDownloadContext.tsx b/frontend/src/contexts/OllamaDownloadContext.tsx
index a5e6270..a82d251 100644
--- a/frontend/src/contexts/OllamaDownloadContext.tsx
+++ b/frontend/src/contexts/OllamaDownloadContext.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import React, { createContext, useContext, useState, useEffect } from 'react';
-import { listen } from '@tauri-apps/api/event';
+import { safeListen } from '@/lib/tauri-compat';
 import { toast } from 'sonner';
 
 /**
@@ -48,7 +48,7 @@ export function OllamaDownloadProvider({ children }: { children: React.ReactNode
     const setupListeners = async () => {
       try {
         // Download progress
-        const unlistenProgress = await listen<{ modelName: string; progress: number }>(
+        const unlistenProgress = await safeListen<{ modelName: string; progress: number }>(
           'ollama-model-download-progress',
           (event) => {
             const { modelName, progress } = event.payload;
@@ -72,7 +72,7 @@ export function OllamaDownloadProvider({ children }: { children: React.ReactNode
         unsubscribers.push(unlistenProgress);
 
         // Download complete
-        const unlistenComplete = await listen<{ modelName: string }>(
+        const unlistenComplete = await safeListen<{ modelName: string }>(
           'ollama-model-download-complete',
           (event) => {
             const { modelName } = event.payload;
@@ -100,7 +100,7 @@ export function OllamaDownloadProvider({ children }: { children: React.ReactNode
         unsubscribers.push(unlistenComplete);
 
         // Download error
-        const unlistenError = await listen<{ modelName: string; error: string }>(
+        const unlistenError = await safeListen<{ modelName: string; error: string }>(
           'ollama-model-download-error',
           (event) => {
             const { modelName, error } = event.payload;
diff --git a/frontend/src/contexts/OnboardingContext.tsx b/frontend/src/contexts/OnboardingContext.tsx
index 27dda96..cbf86aa 100644
--- a/frontend/src/contexts/OnboardingContext.tsx
+++ b/frontend/src/contexts/OnboardingContext.tsx
@@ -1,8 +1,7 @@
 'use client';
 
 import React, { createContext, useContext, useState, useEffect, useRef, useCallback } from 'react';
-import { invoke } from '@tauri-apps/api/core';
-import { listen } from '@tauri-apps/api/event';
+import { safeInvoke, safeListen, isTauriAvailable } from '@/lib/tauri-compat';
 import type { PermissionStatus, OnboardingPermissions } from '@/types/onboarding';
 
 const PARAKEET_MODEL = 'parakeet-tdt-0.6b-v3-int8';
@@ -103,6 +102,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
   // Load status on mount and initialize database
   useEffect(() => {
+    if (!isTauriAvailable()) return; // Skip all Tauri-only initialization in browser mode
     loadOnboardingStatus();
     checkDatabaseStatus();
     initializeDatabaseInBackground();
@@ -110,7 +110,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
     // Fetch and set recommended model
     const fetchRecommendation = async () => {
       try {
-        const recommendedModel = await invoke<string>('builtin_ai_get_recommended_model');
+        const recommendedModel = await safeInvoke<string>('builtin_ai_get_recommended_model');
         setSelectedSummaryModel(recommendedModel);
         console.log('[OnboardingContext] Set recommended model:', recommendedModel);
       } catch (error) {
@@ -125,7 +125,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
   const initializeDatabaseInBackground = async () => {
     try {
       console.log('[OnboardingContext] Starting background database initialization');
-      const isFirstLaunch = await invoke<boolean>('check_first_launch');
+      const isFirstLaunch = await safeInvoke<boolean>('check_first_launch');
 
       if (!isFirstLaunch) {
         console.log('[OnboardingContext] Database exists, skipping initialization');
@@ -146,14 +146,14 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
     if (typeof navigator !== 'undefined' && navigator.platform?.toLowerCase().includes('mac')) {
       const homebrewDbPath = '/usr/local/var/friday/meeting_minutes.db';
       try {
-        const homebrewCheck = await invoke<{ exists: boolean; size: number } | null>(
+        const homebrewCheck = await safeInvoke<{ exists: boolean; size: number } | null>(
           'check_homebrew_database',
           { path: homebrewDbPath }
         );
 
         if (homebrewCheck?.exists) {
           console.log('[OnboardingContext] Found Homebrew database, importing');
-          await invoke('import_and_initialize_database', { legacyDbPath: homebrewDbPath });
+          await safeInvoke('import_and_initialize_database', { legacyDbPath: homebrewDbPath });
           setDatabaseExists(true);
           return;
         }
@@ -164,10 +164,10 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
     // Check default legacy database location
     try {
-      const legacyPath = await invoke<string | null>('check_default_legacy_database');
+      const legacyPath = await safeInvoke<string | null>('check_default_legacy_database');
       if (legacyPath) {
         console.log('[OnboardingContext] Found legacy database, importing');
-        await invoke('import_and_initialize_database', { legacyDbPath: legacyPath });
+        await safeInvoke('import_and_initialize_database', { legacyDbPath: legacyPath });
         setDatabaseExists(true);
         return;
       }
@@ -177,7 +177,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
     // No legacy database found - initialize fresh
     console.log('[OnboardingContext] No legacy database found, initializing fresh');
-    await invoke('initialize_fresh_database');
+    await safeInvoke('initialize_fresh_database');
     setDatabaseExists(true);
   };
 
@@ -202,7 +202,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
   // Listen to Parakeet download progress
   useEffect(() => {
-    const unlisten = listen<{
+    const unlisten = safeListen<{
       modelName: string;
       progress: number;
       downloaded_mb?: number;
@@ -228,7 +228,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
       }
     );
 
-    const unlistenComplete = listen<{ modelName: string }>(
+    const unlistenComplete = safeListen<{ modelName: string }>(
       'parakeet-model-download-complete',
       (event) => {
         const { modelName } = event.payload;
@@ -239,7 +239,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
       }
     );
 
-    const unlistenError = listen<{ modelName: string; error: string }>(
+    const unlistenError = safeListen<{ modelName: string; error: string }>(
       'parakeet-model-download-error',
       (event) => {
         const { modelName } = event.payload;
@@ -258,7 +258,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
   // Listen to summary model (Built-in AI) download progress
   useEffect(() => {
-    const unlisten = listen<{
+    const unlisten = safeListen<{
       model: string;
       progress: number;
       downloaded_mb?: number;
@@ -292,7 +292,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
   const checkDatabaseStatus = async () => {
     try {
-      const isFirstLaunch = await invoke<boolean>('check_first_launch');
+      const isFirstLaunch = await safeInvoke<boolean>('check_first_launch');
       setDatabaseExists(!isFirstLaunch);
       console.log('[OnboardingContext] Database exists:', !isFirstLaunch);
     } catch (error) {
@@ -303,7 +303,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
   const loadOnboardingStatus = async () => {
     try {
-      const status = await invoke<OnboardingStatus | null>('get_onboarding_status');
+      const status = await safeInvoke<OnboardingStatus | null>('get_onboarding_status');
       if (status) {
         console.log('[OnboardingContext] Loaded saved status:', status);
 
@@ -332,8 +332,8 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
 
     // Verify Parakeet model exists on disk
     try {
-      await invoke('parakeet_init');
-      parakeetDownloaded = await invoke<boolean>('parakeet_has_available_models');
+      await safeInvoke('parakeet_init');
+      parakeetDownloaded = await safeInvoke<boolean>('parakeet_has_available_models');
       console.log('[OnboardingContext] Parakeet verified on disk:', parakeetDownloaded);
     } catch (error) {
       console.warn('[OnboardingContext] Failed to verify Parakeet:', error);
@@ -343,7 +343,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
     // Verify Summary model exists on disk - check if ANY model is available
     // Onboarding always uses builtin-ai (local models)
     try {
-      const availableModel = await invoke<string | null>('builtin_ai_get_available_summary_model');
+      const availableModel = await safeInvoke<string | null>('builtin_ai_get_available_summary_model');
       summaryModelDownloaded = !!availableModel;
       console.log('[OnboardingContext] Summary model verified on disk:', summaryModelDownloaded, 'model:', availableModel);
     } catch (error) {
@@ -381,7 +381,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
     }
 
     try {
-      await invoke('save_onboarding_status_cmd', {
+      await safeInvoke('save_onboarding_status_cmd', {
         status: {
           version: '1.0',
           completed: completed,
@@ -410,7 +410,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
       }
 
       // Onboarding always uses builtin-ai with selected model
-      await invoke('complete_onboarding', {
+      await safeInvoke('complete_onboarding', {
         model: selectedSummaryModel,
       });
       setCompleted(true);
@@ -433,7 +433,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
         saveTimeoutRef.current = undefined;
       }
 
-      await invoke('complete_onboarding_hosted', { apiKey });
+      await safeInvoke('complete_onboarding_hosted', { apiKey });
       setCompleted(true);
       console.log('[OnboardingContext] Onboarding completed in hosted (Gemini) mode');
       isCompletingRef.current = false;
@@ -453,7 +453,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
       // Start Parakeet download first (speech recognition - always required)
       if (!parakeetDownloaded) {
         console.log('[OnboardingContext] Starting Parakeet download');
-        invoke('parakeet_download_model', { modelName: PARAKEET_MODEL })
+        safeInvoke('parakeet_download_model', { modelName: PARAKEET_MODEL })
           .catch(err => console.error('[OnboardingContext] Parakeet download failed:', err));
       }
 
@@ -461,7 +461,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
       if (includeGemma && !summaryModelDownloaded) {
         setTimeout(() => {
           console.log('[OnboardingContext] Starting Gemma download (delayed to prioritize Parakeet)');
-          invoke('builtin_ai_download_model', { modelName: selectedSummaryModel || 'gemma3:1b' })
+          safeInvoke('builtin_ai_download_model', { modelName: selectedSummaryModel || 'gemma3:1b' })
             .catch(err => console.error('[OnboardingContext] Gemma download failed:', err));
         }, 3000); // 3 second delay to give Parakeet priority
       }
@@ -475,7 +475,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
   // Check if any models are currently downloading (for re-entry)
   const checkActiveDownloads = async () => {
     try {
-      const models = await invoke<any[]>('parakeet_get_available_models');
+      const models = await safeInvoke<any[]>('parakeet_get_available_models');
       const isDownloading = models.some(m => m.status && (typeof m.status === 'object' ? 'Downloading' in m.status : m.status === 'Downloading'));
       
       if (isDownloading) {
@@ -493,7 +493,7 @@ export function OnboardingProvider({ children }: { children: React.ReactNode })
   const retryParakeetDownload = async () => {
     console.log('[OnboardingContext] Retrying Parakeet download');
     try {
-      await invoke('parakeet_retry_download', { modelName: PARAKEET_MODEL });
+      await safeInvoke('parakeet_retry_download', { modelName: PARAKEET_MODEL });
     } catch (error) {
       console.error('[OnboardingContext] Retry failed:', error);
       throw error;
diff --git a/frontend/src/contexts/RecordingPostProcessingProvider.tsx b/frontend/src/contexts/RecordingPostProcessingProvider.tsx
index e298970..c9870fa 100644
--- a/frontend/src/contexts/RecordingPostProcessingProvider.tsx
+++ b/frontend/src/contexts/RecordingPostProcessingProvider.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import React, { useEffect } from 'react';
-import { listen } from '@tauri-apps/api/event';
+import { safeListen } from '@/lib/tauri-compat';
 import { useRecordingStop } from '@/hooks/useRecordingStop';
 
 /**
@@ -33,7 +33,7 @@ export function RecordingPostProcessingProvider({ children }: { children: React.
     const setupListener = async () => {
       try {
         // Listen for recording-stop-complete event from Rust
-        unlistenFn = await listen<boolean>('recording-stop-complete', (event) => {
+        unlistenFn = await safeListen<boolean>('recording-stop-complete', (event) => {
           console.log('[RecordingPostProcessing] Received recording-stop-complete event:', event.payload);
 
           // Call the post-processing handler
diff --git a/frontend/src/lib/analytics.ts b/frontend/src/lib/analytics.ts
index 24ec285..f44c8c8 100644
--- a/frontend/src/lib/analytics.ts
+++ b/frontend/src/lib/analytics.ts
@@ -1,4 +1,10 @@
-import { invoke } from '@tauri-apps/api/core';
+import { isTauriAvailable } from '@/lib/tauri-compat';
+
+const tauriInvoke = async <T = any>(cmd: string, args?: Record<string, unknown>): Promise<T> => {
+  if (!isTauriAvailable()) throw new Error('Tauri not available');
+  const { invoke } = await import('@tauri-apps/api/core');
+  return invoke<T>(cmd, args);
+};
 
 export interface AnalyticsProperties {
   [key: string]: string;
@@ -43,7 +49,7 @@ export class Analytics {
 
   private static async doInit(): Promise<void> {
     try {
-      await invoke('init_analytics');
+      await tauriInvoke('init_analytics');
       this.initialized = true;
       console.log('Analytics initialized successfully');
     } catch (error) {
@@ -56,7 +62,7 @@ export class Analytics {
 
   static async disable(): Promise<void> {
     try {
-      await invoke('disable_analytics');
+      await tauriInvoke('disable_analytics');
       this.initialized = false;
       this.currentUserId = null;
       this.initializationPromise = null;
@@ -68,7 +74,7 @@ export class Analytics {
 
   static async isEnabled(): Promise<boolean> {
     try {
-      return await invoke('is_analytics_enabled');
+      return await tauriInvoke('is_analytics_enabled');
     } catch (error) {
       console.error('Failed to check analytics status:', error);
       return false;
@@ -82,7 +88,7 @@ export class Analytics {
     }
 
     try {
-      await invoke('track_event', { eventName, properties });
+      await tauriInvoke('track_event', { eventName, properties });
     } catch (error) {
       console.error(`Failed to track event ${eventName}:`, error);
     }
@@ -95,7 +101,7 @@ export class Analytics {
     }
 
     try {
-      await invoke('identify_user', { userId, properties });
+      await tauriInvoke('identify_user', { userId, properties });
       this.currentUserId = userId;
     } catch (error) {
       console.error(`Failed to identify user ${userId}:`, error);
@@ -110,7 +116,7 @@ export class Analytics {
     }
 
     try {
-      const sessionId = await invoke('start_analytics_session', { userId });
+      const sessionId = await tauriInvoke('start_analytics_session', { userId });
       this.currentUserId = userId;
       
       return sessionId as string;
@@ -124,7 +130,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('end_analytics_session');
+      await tauriInvoke('end_analytics_session');
     } catch (error) {
       console.error('Failed to end analytics session:', error);
     }
@@ -134,7 +140,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_daily_active_user');
+      await tauriInvoke('track_daily_active_user');
     } catch (error) {
       console.error('Failed to track daily active user:', error);
     }
@@ -144,7 +150,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_user_first_launch');
+      await tauriInvoke('track_user_first_launch');
     } catch (error) {
       console.error('Failed to track user first launch:', error);
     }
@@ -154,7 +160,7 @@ export class Analytics {
     if (!this.initialized) return false;
 
     try {
-      return await invoke('is_analytics_session_active');
+      return await tauriInvoke('is_analytics_session_active');
     } catch (error) {
       console.error('Failed to check session status:', error);
       return false;
@@ -535,7 +541,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_meeting_started', { meetingId, meetingTitle });
+      await tauriInvoke('track_meeting_started', { meetingId, meetingTitle });
     } catch (error) {
       console.error('Failed to track meeting started:', error);
     }
@@ -545,7 +551,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_recording_started', { meetingId });
+      await tauriInvoke('track_recording_started', { meetingId });
     } catch (error) {
       console.error('Failed to track recording started:', error);
     }
@@ -555,7 +561,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_recording_stopped', { meetingId, durationSeconds });
+      await tauriInvoke('track_recording_stopped', { meetingId, durationSeconds });
     } catch (error) {
       console.error('Failed to track recording stopped:', error);
     }
@@ -565,7 +571,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_meeting_deleted', { meetingId });
+      await tauriInvoke('track_meeting_deleted', { meetingId });
     } catch (error) {
       console.error('Failed to track meeting deleted:', error);
     }
@@ -575,7 +581,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_settings_changed', { settingType, newValue });
+      await tauriInvoke('track_settings_changed', { settingType, newValue });
     } catch (error) {
       console.error('Failed to track settings changed:', error);
     }
@@ -585,7 +591,7 @@ export class Analytics {
     if (!this.initialized) return;
 
     try {
-      await invoke('track_feature_used', { featureName });
+      await tauriInvoke('track_feature_used', { featureName });
     } catch (error) {
       console.error('Failed to track feature used:', error);
     }
@@ -652,7 +658,7 @@ export class Analytics {
 
     try {
       console.log('Tracking backend connection event:', { success, error });
-      await invoke('track_event', {
+      await tauriInvoke('track_event', {
         eventName: 'backend_connection',
         properties: {
           success: success.toString(),
@@ -675,7 +681,7 @@ export class Analytics {
 
     try {
       console.log('Tracking transcription error event:', { errorMessage });
-      await invoke('track_event', {
+      await tauriInvoke('track_event', {
         eventName: 'transcription_error',
         properties: {
           error_message: errorMessage,
@@ -697,7 +703,7 @@ export class Analytics {
 
     try {
       console.log('Tracking transcription success event:', { duration });
-      await invoke('track_event', {
+      await tauriInvoke('track_event', {
         eventName: 'transcription_success',
         properties: {
           duration: duration ? duration.toString() : '',
@@ -764,7 +770,7 @@ export class Analytics {
 
     try {
       console.log('Tracking summary generation completed event:', { modelProvider, modelName, success, durationSeconds, errorMessage });
-      await invoke('track_summary_generation_completed', {
+      await tauriInvoke('track_summary_generation_completed', {
         modelProvider,
         modelName,
         success,
@@ -785,7 +791,7 @@ export class Analytics {
 
     try {
       console.log('Tracking summary regenerated event:', { modelProvider, modelName });
-      await invoke('track_summary_regenerated', {
+      await tauriInvoke('track_summary_regenerated', {
         modelProvider,
         modelName
       });
@@ -803,7 +809,7 @@ export class Analytics {
 
     try {
       console.log('Tracking model changed event:', { oldProvider, oldModel, newProvider, newModel });
-      await invoke('track_model_changed', {
+      await tauriInvoke('track_model_changed', {
         oldProvider,
         oldModel,
         newProvider,
@@ -823,7 +829,7 @@ export class Analytics {
 
     try {
       console.log('Tracking custom prompt used event:', { promptLength });
-      await invoke('track_custom_prompt_used', {
+      await tauriInvoke('track_custom_prompt_used', {
         promptLength
       });
       console.log('Custom prompt used event tracked successfully');
diff --git a/frontend/src/lib/tauri-compat.ts b/frontend/src/lib/tauri-compat.ts
new file mode 100644
index 0000000..091a470
--- /dev/null
+++ b/frontend/src/lib/tauri-compat.ts
@@ -0,0 +1,145 @@
+/**
+ * Tauri compatibility layer for browser-only dev mode.
+ *
+ * When Tauri is available, delegates to `invoke()`.
+ * When running in a plain browser, maps known commands to HTTP calls
+ * against the Python backend at http://localhost:5167.
+ */
+
+const BACKEND = "http://localhost:5167";
+
+export function isTauriAvailable(): boolean {
+  return (
+    typeof window !== "undefined" && !!(window as any).__TAURI_INTERNALS__
+  );
+}
+
+// Maps Tauri command names → { method, path, bodyMapper? }
+// bodyMapper transforms invoke args into a fetch body (POST only).
+const COMMAND_MAP: Record<
+  string,
+  {
+    method: "GET" | "POST";
+    path: (args?: any) => string;
+    bodyMapper?: (args?: any) => any;
+  }
+> = {
+  api_get_meetings: {
+    method: "GET",
+    path: () => "/get-meetings",
+  },
+  api_search_transcripts: {
+    method: "POST",
+    path: () => "/search-transcripts",
+    bodyMapper: (args) => ({ query: args?.query }),
+  },
+  api_get_summary: {
+    method: "GET",
+    path: (args) => `/get-summary/${args?.meetingId}`,
+  },
+  api_get_model_config: {
+    method: "GET",
+    path: () => "/get-model-config",
+  },
+  api_get_transcript_config: {
+    method: "GET",
+    path: () => "/get-transcript-config",
+  },
+  api_get_api_key: {
+    method: "POST",
+    path: () => "/get-api-key",
+    bodyMapper: (args) => ({ provider: args?.provider }),
+  },
+  api_save_model_config: {
+    method: "POST",
+    path: () => "/save-model-config",
+    bodyMapper: (args) => ({
+      provider: args?.provider,
+      model: args?.model,
+      whisper_model: args?.whisperModel,
+      api_key: args?.apiKey,
+      ollama_endpoint: args?.ollamaEndpoint,
+    }),
+  },
+  api_save_transcript_config: {
+    method: "POST",
+    path: () => "/save-transcript-config",
+    bodyMapper: (args) => ({
+      provider: args?.provider,
+      model: args?.model,
+      api_key: args?.apiKey,
+    }),
+  },
+  api_delete_meeting: {
+    method: "POST",
+    path: () => "/delete-meeting",
+    bodyMapper: (args) => ({ meeting_id: args?.meetingId }),
+  },
+  api_save_meeting_title: {
+    method: "POST",
+    path: () => "/save-meeting-title",
+    bodyMapper: (args) => ({
+      meeting_id: args?.meetingId,
+      title: args?.title,
+    }),
+  },
+  api_get_meeting: {
+    method: "GET",
+    path: (args) => `/get-meeting/${args?.meetingId}`,
+  },
+};
+
+async function httpFallback<T>(cmd: string, args?: Record<string, unknown>): Promise<T> {
+  const mapping = COMMAND_MAP[cmd];
+  if (!mapping) {
+    throw new Error(
+      `Command "${cmd}" is not available in browser mode (requires Tauri desktop app).`
+    );
+  }
+
+  const url = `${BACKEND}${mapping.path(args)}`;
+  const init: RequestInit = {
+    method: mapping.method,
+    headers: { "Content-Type": "application/json" },
+  };
+  if (mapping.method === "POST" && mapping.bodyMapper) {
+    init.body = JSON.stringify(mapping.bodyMapper(args));
+  }
+
+  const res = await fetch(url, init);
+  if (!res.ok) {
+    const text = await res.text().catch(() => res.statusText);
+    throw new Error(`${cmd} failed: ${res.status} ${text}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+/**
+ * Drop-in replacement for Tauri `invoke()`.
+ * Uses Tauri IPC when available, falls back to HTTP in browser mode.
+ */
+export async function safeInvoke<T = any>(
+  cmd: string,
+  args?: Record<string, unknown>
+): Promise<T> {
+  if (isTauriAvailable()) {
+    const { invoke } = await import("@tauri-apps/api/core");
+    return invoke<T>(cmd, args);
+  }
+  return httpFallback<T>(cmd, args);
+}
+
+/**
+ * Safe wrapper for Tauri `listen()`. Returns a no-op unlisten in browser mode.
+ */
+export async function safeListen<T = any>(
+  event: string,
+  handler: (event: { payload: T }) => void
+): Promise<() => void> {
+  if (isTauriAvailable()) {
+    const { listen } = await import("@tauri-apps/api/event");
+    return listen<T>(event, handler);
+  }
+  // No-op in browser mode
+  return () => {};
+}
diff --git a/frontend/src/services/agentService.ts b/frontend/src/services/agentService.ts
index 28e1e20..8f035fd 100644
--- a/frontend/src/services/agentService.ts
+++ b/frontend/src/services/agentService.ts
@@ -1,5 +1,3 @@
-import { invoke } from '@tauri-apps/api/core';
-
 export interface AgentSettingsPayload {
   enabled: boolean;
   provider: string;
@@ -85,57 +83,99 @@ export interface AgentRecommendationActionResponse {
   created_calendar_event: CreatedCalendarEventSummary | null;
 }
 
+const isTauri = (): boolean =>
+  typeof window !== "undefined" && !!(window as any).__TAURI_INTERNALS__;
+
+async function tauriInvoke<T>(cmd: string, args?: Record<string, unknown>): Promise<T> {
+  if (!isTauri()) {
+    throw new Error("This feature requires the Friday desktop app (Tauri runtime not available).");
+  }
+  const { invoke } = await import("@tauri-apps/api/core");
+  return invoke<T>(cmd, args);
+}
+
+const DEFAULT_SETTINGS: AgentSettingsPayload = {
+  enabled: false,
+  provider: "gemini",
+  model: "gemini-2.0-flash",
+  notifications_enabled: true,
+  calendar_proposals_enabled: false,
+  heartbeat_interval_minutes: 10,
+};
+
+const DEFAULT_STATUS: AgentStatusResponse = {
+  settings: DEFAULT_SETTINGS,
+  api_key_configured: false,
+  calendar_connected: false,
+  calendar_can_write: false,
+  is_running: false,
+  last_run_at: null,
+  last_success_at: null,
+  last_error: null,
+  pending_recommendations: 0,
+  open_tasks: 0,
+};
+
 class AgentService {
+  get available(): boolean {
+    return isTauri();
+  }
+
   async getStatus(): Promise<AgentStatusResponse> {
-    return invoke<AgentStatusResponse>('agent_get_status');
+    if (!isTauri()) return DEFAULT_STATUS;
+    return tauriInvoke<AgentStatusResponse>('agent_get_status');
   }
 
   async getSettings(): Promise<AgentSettingsPayload> {
-    return invoke<AgentSettingsPayload>('agent_get_settings');
+    if (!isTauri()) return DEFAULT_SETTINGS;
+    return tauriInvoke<AgentSettingsPayload>('agent_get_settings');
   }
 
   async setSettings(settings: AgentSettingsPayload): Promise<AgentStatusResponse> {
-    return invoke<AgentStatusResponse>('agent_set_settings', { settings });
+    return tauriInvoke<AgentStatusResponse>('agent_set_settings', { settings });
   }
 
   async saveGeminiApiKey(apiKey: string): Promise<void> {
-    return invoke('agent_save_gemini_api_key', { apiKey });
+    return tauriInvoke('agent_save_gemini_api_key', { apiKey });
   }
 
   async clearGeminiApiKey(): Promise<void> {
-    return invoke('agent_clear_gemini_api_key');
+    return tauriInvoke('agent_clear_gemini_api_key');
   }
 
   async runHeartbeatNow(): Promise<AgentStatusResponse> {
-    return invoke<AgentStatusResponse>('agent_run_heartbeat_now');
+    return tauriInvoke<AgentStatusResponse>('agent_run_heartbeat_now');
   }
 
   async listRecommendations(status?: string): Promise<AgentRecommendation[]> {
-    return invoke<AgentRecommendation[]>('agent_list_recommendations', { status: status ?? null });
+    if (!isTauri()) return [];
+    return tauriInvoke<AgentRecommendation[]>('agent_list_recommendations', { status: status ?? null });
   }
 
   async acceptRecommendation(recommendationId: string): Promise<AgentRecommendationActionResponse> {
-    return invoke<AgentRecommendationActionResponse>('agent_accept_recommendation', { recommendationId });
+    return tauriInvoke<AgentRecommendationActionResponse>('agent_accept_recommendation', { recommendationId });
   }
 
   async dismissRecommendation(recommendationId: string): Promise<AgentRecommendation> {
-    return invoke<AgentRecommendation>('agent_dismiss_recommendation', { recommendationId });
+    return tauriInvoke<AgentRecommendation>('agent_dismiss_recommendation', { recommendationId });
   }
 
   async listMemory(limit = 25): Promise<AgentMemoryItem[]> {
-    return invoke<AgentMemoryItem[]>('agent_list_memory', { limit });
+    if (!isTauri()) return [];
+    return tauriInvoke<AgentMemoryItem[]>('agent_list_memory', { limit });
   }
 
   async getMeetingContext(meetingId: string): Promise<AgentMeetingContextResponse> {
-    return invoke<AgentMeetingContextResponse>('agent_get_meeting_context', { meetingId });
+    return tauriInvoke<AgentMeetingContextResponse>('agent_get_meeting_context', { meetingId });
   }
 
   async listTasks(status?: string): Promise<AgentTask[]> {
-    return invoke<AgentTask[]>('agent_list_tasks', { status: status ?? null });
+    if (!isTauri()) return [];
+    return tauriInvoke<AgentTask[]>('agent_list_tasks', { status: status ?? null });
   }
 
   async updateTaskStatus(taskId: string, status: string): Promise<AgentTask[]> {
-    return invoke<AgentTask[]>('agent_update_task_status', { taskId, status });
+    return tauriInvoke<AgentTask[]>('agent_update_task_status', { taskId, status });
   }
 }
 
diff --git a/frontend/src/services/calendarService.ts b/frontend/src/services/calendarService.ts
index ab33947..5e91294 100644
--- a/frontend/src/services/calendarService.ts
+++ b/frontend/src/services/calendarService.ts
@@ -1,4 +1,13 @@
-import { invoke } from '@tauri-apps/api/core';
+const isTauri = (): boolean =>
+  typeof window !== "undefined" && !!(window as any).__TAURI_INTERNALS__;
+
+async function tauriInvoke<T>(cmd: string, args?: Record<string, unknown>): Promise<T> {
+  if (!isTauri()) {
+    throw new Error("Google Calendar requires the Friday desktop app (Tauri runtime not available).");
+  }
+  const { invoke } = await import("@tauri-apps/api/core");
+  return invoke<T>(cmd, args);
+}
 
 export interface CalendarAccountSummary {
   email: string | null;
@@ -71,41 +80,51 @@ export interface UpcomingCalendarEvent {
   html_link: string | null;
 }
 
+const DEFAULT_STATUS: CalendarStatusResponse = {
+  client_configured: false,
+  connected: false,
+  can_write: false,
+  syncing: false,
+  account: null,
+};
+
 class CalendarService {
   async getStatus(): Promise<CalendarStatusResponse> {
-    return invoke<CalendarStatusResponse>('calendar_get_status');
+    if (!isTauri()) return DEFAULT_STATUS;
+    return tauriInvoke<CalendarStatusResponse>('calendar_get_status');
   }
 
   async listUpcoming(): Promise<UpcomingCalendarEvent[]> {
-    return invoke<UpcomingCalendarEvent[]>('calendar_list_upcoming');
+    if (!isTauri()) return [];
+    return tauriInvoke<UpcomingCalendarEvent[]>('calendar_list_upcoming');
   }
 
   async connectGoogle(writeAccess = false): Promise<CalendarStatusResponse> {
-    return invoke<CalendarStatusResponse>('calendar_connect_google', {
+    return tauriInvoke<CalendarStatusResponse>('calendar_connect_google', {
       writeAccess,
     });
   }
 
   async upgradeGoogleAccess(): Promise<CalendarStatusResponse> {
-    return invoke<CalendarStatusResponse>('calendar_upgrade_google_access');
+    return tauriInvoke<CalendarStatusResponse>('calendar_upgrade_google_access');
   }
 
   async disconnectGoogle(): Promise<CalendarStatusResponse> {
-    return invoke<CalendarStatusResponse>('calendar_disconnect_google');
+    return tauriInvoke<CalendarStatusResponse>('calendar_disconnect_google');
   }
 
   async syncNow(): Promise<CalendarSyncResult> {
-    return invoke<CalendarSyncResult>('calendar_sync_now');
+    return tauriInvoke<CalendarSyncResult>('calendar_sync_now');
   }
 
   async getMeetingLink(meetingId: string): Promise<LinkedCalendarEvent | null> {
-    return invoke<LinkedCalendarEvent | null>('calendar_get_meeting_link', {
+    return tauriInvoke<LinkedCalendarEvent | null>('calendar_get_meeting_link', {
       meetingId,
     });
   }
 
   async getLinkCandidates(meetingId: string): Promise<CalendarLinkCandidate[]> {
-    return invoke<CalendarLinkCandidate[]>('calendar_get_link_candidates', {
+    return tauriInvoke<CalendarLinkCandidate[]>('calendar_get_link_candidates', {
       meetingId,
     });
   }
@@ -114,14 +133,14 @@ class CalendarService {
     meetingId: string,
     providerEventId: string
   ): Promise<LinkedCalendarEvent | null> {
-    return invoke<LinkedCalendarEvent | null>('calendar_set_meeting_link', {
+    return tauriInvoke<LinkedCalendarEvent | null>('calendar_set_meeting_link', {
       meetingId,
       providerEventId,
     });
   }
 
   async clearMeetingLink(meetingId: string): Promise<void> {
-    return invoke('calendar_clear_meeting_link', { meetingId });
+    return tauriInvoke('calendar_clear_meeting_link', { meetingId });
   }
 }
 
diff --git a/frontend/src/services/configService.ts b/frontend/src/services/configService.ts
index b554e4a..5915a3b 100644
--- a/frontend/src/services/configService.ts
+++ b/frontend/src/services/configService.ts
@@ -5,7 +5,7 @@
  * Pure 1-to-1 wrapper - no error handling changes, exact same behavior as direct invoke calls.
  */
 
-import { invoke } from '@tauri-apps/api/core';
+import { safeInvoke } from '@/lib/tauri-compat';
 import { TranscriptModelProps } from '@/components/TranscriptSettings';
 
 export interface ModelConfig {
@@ -51,7 +51,7 @@ export class ConfigService {
    * @returns Promise with { provider, model, apiKey }
    */
   async getTranscriptConfig(): Promise<TranscriptModelProps> {
-    return invoke<TranscriptModelProps>('api_get_transcript_config');
+    return safeInvoke<TranscriptModelProps>('api_get_transcript_config');
   }
 
   /**
@@ -59,7 +59,7 @@ export class ConfigService {
    * @returns Promise with { provider, model, whisperModel }
    */
   async getModelConfig(): Promise<ModelConfig> {
-    return invoke<ModelConfig>('api_get_model_config');
+    return safeInvoke<ModelConfig>('api_get_model_config');
   }
 
   /**
@@ -67,7 +67,7 @@ export class ConfigService {
    * @returns Promise with { preferred_mic_device, preferred_system_device }
    */
   async getRecordingPreferences(): Promise<RecordingPreferences> {
-    return invoke<RecordingPreferences>('get_recording_preferences');
+    return safeInvoke<RecordingPreferences>('get_recording_preferences');
   }
 
   /**
@@ -75,7 +75,7 @@ export class ConfigService {
    * @returns Promise with CustomOpenAIConfig or null if not configured
    */
   async getCustomOpenAIConfig(): Promise<CustomOpenAIConfig | null> {
-    return invoke<CustomOpenAIConfig | null>('api_get_custom_openai_config');
+    return safeInvoke<CustomOpenAIConfig | null>('api_get_custom_openai_config');
   }
 
   /**
@@ -84,7 +84,7 @@ export class ConfigService {
    * @returns Promise with result status
    */
   async saveCustomOpenAIConfig(config: CustomOpenAIConfig): Promise<{ status: string; message: string }> {
-    return invoke<{ status: string; message: string }>('api_save_custom_openai_config', {
+    return safeInvoke<{ status: string; message: string }>('api_save_custom_openai_config', {
       endpoint: config.endpoint,
       apiKey: config.apiKey,
       model: config.model,
@@ -106,7 +106,7 @@ export class ConfigService {
     apiKey: string | null,
     model: string
   ): Promise<{ status: string; message: string; http_status?: number }> {
-    return invoke<{ status: string; message: string; http_status?: number }>('api_test_custom_openai_connection', {
+    return safeInvoke<{ status: string; message: string; http_status?: number }>('api_test_custom_openai_connection', {
       endpoint,
       apiKey,
       model,
diff --git a/frontend/src/services/recordingService.ts b/frontend/src/services/recordingService.ts
index 4ffb9d2..34e5263 100644
--- a/frontend/src/services/recordingService.ts
+++ b/frontend/src/services/recordingService.ts
@@ -5,8 +5,9 @@
  * Pure 1-to-1 wrapper - no error handling changes, exact same behavior as direct invoke/listen calls.
  */
 
-import { invoke } from '@tauri-apps/api/core';
-import { listen, UnlistenFn } from '@tauri-apps/api/event';
+import { safeInvoke, safeListen } from '@/lib/tauri-compat';
+
+type UnlistenFn = () => void;
 
 export interface RecordingState {
   is_recording: boolean;
@@ -32,7 +33,7 @@ export class RecordingService {
    * @returns Promise<boolean>
    */
   async isRecording(): Promise<boolean> {
-    return invoke<boolean>('is_recording');
+    return safeInvoke<boolean>('is_recording');
   }
 
   /**
@@ -40,7 +41,7 @@ export class RecordingService {
    * @returns Promise with full recording state
    */
   async getRecordingState(): Promise<RecordingState> {
-    return invoke<RecordingState>('get_recording_state');
+    return safeInvoke<RecordingState>('get_recording_state');
   }
 
   /**
@@ -48,7 +49,7 @@ export class RecordingService {
    * @returns Promise<string | null>
    */
   async getRecordingMeetingName(): Promise<string | null> {
-    return invoke<string | null>('get_recording_meeting_name');
+    return safeInvoke<string | null>('get_recording_meeting_name');
   }
 
   /**
@@ -56,7 +57,7 @@ export class RecordingService {
    * @returns Promise<void>
    */
   async startRecording(): Promise<void> {
-    return invoke('start_recording');
+    return safeInvoke('start_recording');
   }
 
   /**
@@ -71,7 +72,7 @@ export class RecordingService {
     systemDeviceName: string | null,
     meetingName: string
   ): Promise<void> {
-    return invoke('start_recording_with_devices_and_meeting', {
+    return safeInvoke('start_recording_with_devices_and_meeting', {
       mic_device_name: micDeviceName,
       system_device_name: systemDeviceName,
       meeting_name: meetingName
@@ -84,7 +85,7 @@ export class RecordingService {
    * @returns Promise<void>
    */
   async stopRecording(savePath: string): Promise<void> {
-    return invoke('stop_recording', {
+    return safeInvoke('stop_recording', {
       args: { save_path: savePath }
     });
   }
@@ -94,7 +95,7 @@ export class RecordingService {
    * @returns Promise<void>
    */
   async pauseRecording(): Promise<void> {
-    return invoke('pause_recording');
+    return safeInvoke('pause_recording');
   }
 
   /**
@@ -102,7 +103,7 @@ export class RecordingService {
    * @returns Promise<void>
    */
   async resumeRecording(): Promise<void> {
-    return invoke('resume_recording');
+    return safeInvoke('resume_recording');
   }
 
   // Event Listeners
@@ -113,7 +114,7 @@ export class RecordingService {
    * @returns Promise that resolves to unlisten function
    */
   async onRecordingStarted(callback: () => void): Promise<UnlistenFn> {
-    return listen('recording-started', callback);
+    return safeListen('recording-started', callback);
   }
 
   /**
@@ -122,7 +123,7 @@ export class RecordingService {
    * @returns Promise that resolves to unlisten function
    */
   async onRecordingStopped(callback: (payload: RecordingStoppedPayload) => void): Promise<UnlistenFn> {
-    return listen<RecordingStoppedPayload>('recording-stopped', (event) => {
+    return safeListen<RecordingStoppedPayload>('recording-stopped', (event) => {
       callback(event.payload);
     });
   }
@@ -133,7 +134,7 @@ export class RecordingService {
    * @returns Promise that resolves to unlisten function
    */
   async onRecordingPaused(callback: () => void): Promise<UnlistenFn> {
-    return listen('recording-paused', callback);
+    return safeListen('recording-paused', callback);
   }
 
   /**
@@ -142,7 +143,7 @@ export class RecordingService {
    * @returns Promise that resolves to unlisten function
    */
   async onRecordingResumed(callback: () => void): Promise<UnlistenFn> {
-    return listen('recording-resumed', callback);
+    return safeListen('recording-resumed', callback);
   }
 
   /**
@@ -151,7 +152,7 @@ export class RecordingService {
    * @returns Promise that resolves to unlisten function
    */
   async onChunkDropWarning(callback: (warning: string) => void): Promise<UnlistenFn> {
-    return listen<string>('chunk-drop-warning', (event) => {
+    return safeListen<string>('chunk-drop-warning', (event) => {
       callback(event.payload);
     });
   }
@@ -162,7 +163,7 @@ export class RecordingService {
    * @returns Promise that resolves to unlisten function
    */
   async onSpeechDetected(callback: () => void): Promise<UnlistenFn> {
-    return listen('speech-detected', callback);
+    return safeListen('speech-detected', callback);
   }
 }
 
diff --git a/start.sh b/start.sh
new file mode 100755
index 0000000..f79cbac
--- /dev/null
+++ b/start.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+# Start both backend and frontend for Friday
+
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+
+# Start backend in background
+cd "$ROOT/backend" && source venv/bin/activate && python app/main.py &
+BACKEND_PID=$!
+
+# Start frontend in foreground
+cd "$ROOT/frontend" && pnpm run dev
+
+# When frontend exits, also kill backend
+kill $BACKEND_PID 2>/dev/null