Olawole Moses

Posted on Mar 27

Sovereign Attention Firewall: A Zero-Trust AI Perimeter for Your Calendar

#devchallenge #notionchallenge #mcp #ai

Notion MCP Challenge Submission 🧠

This is a submission for the Notion MCP Challenge

What I Built

The Sovereign Attention Firewall — a zero-trust AI perimeter that defends your calendar and inbox from Calendar Snipers (unverified external invites) and Ghost Projects (meetings tied to archived work), before they ever interrupt deep work.

Why this exists: Procurement professionals, operations leads, and anyone with a visible business title knows the pain. ZoomInfo scraped your LinkedIn. Now your calendar is bleeding ghost meetings, your inbox drowns in "just circling back" sequences, and every cold SDR thinks they own 30 minutes of your Tuesday. The Reddit procurement community has a name for it: attention theft. The only current defenses are manual — reply templates, block lists, and sheer emotional labour.

The real cost isn't the emails. It's the cognitive fragmentation. Every unvetted vendor ping is a context switch tax on your focused work.

What it does: The Sovereign Attention Firewall creates a human-in-the-loop AI enforcement system that:

Intercepts every external calendar invite and runs it through a zero-trust identity check
Detects Identity Phantoms (invites from unverified or suspicious organizers) and Ghost Projects (meetings tied to archived/completed work)
Quarantines flagged invites into a Notion Waiting Room for human review — nothing is blocked without your approval
Executes silent enforcement: rejected invites are deleted with sendUpdates: false, giving no signal back to the sender that your address is active
Escalates repeat offenders automatically to a permanent Block List after two rejections
Maintains a daily Sovereign Security Log in Notion — a full audit trail of what was caught, why, and what action was taken

The default flips: your calendar becomes as defensible as your infrastructure.

Video Demo

View on YouTube

Show Us the Code

🔗 github.com/olawolemoses/sovereign-attention-firewall

The system is built with:

Cloudflare Workers (TypeScript) for:
- identity-oracle — deterministic identity registry; checks email allowlists, falls back to domain whitelists, returns Unverified for unknowns. Verdicts are cached in Cloudflare KV for sub-second performance.
- sovereign-bouncer-mcp — custom MCP server enforcing Bearer auth and trust logic, deployed at the edge
Notion Agent + Notion databases as the governance and decision layer — the orchestration core
Zapier (Webhook + Paths) as the enforcement bridge across Google Calendar and Gmail
Google Calendar + Gmail for event handling, silent enforcement, and RSVP management

How I Used Notion MCP

Notion MCP is not a peripheral integration here. It is the orchestration core of the Sovereign Attention Firewall.

Every external meeting invite is evaluated through a Notion-governed workflow combined with a custom MCP trust check:

The Agent calls verify_email_trust(email) on Sovereign Bouncer (MCP)
Sovereign Bouncer queries the Identity Oracle and returns trust verdicts
Decisions and full policy reasoning are persisted in Notion for human review and auditability
When a human updates the Decision property in the 📥 Waiting Room DB from Pending to any terminal state (Approved, Rejected, Blocked, or Cancelled), a native Notion automation fires a webhook to Zapier — passing event metadata and the decision downstream for enforcement

The MCP + Notion integration specifically unlocks:

1. Deterministic policy enforcement

The Agent operates from explicit policy records in the 🛡️ Sovereign Policy DB — P1: Identity Proof, P2: Ghost Hunter, P3: Context Tax — rather than ad-hoc AI judgment. Policies are readable and editable by any team member directly in Notion.

2. Persistent operational memory

The 📥 Waiting Room DB stores event metadata, policy reasoning, and decision state across every interaction. Nothing disappears into a black box — every triage decision is traceable over time.

3. Human-in-the-loop governance

A human updates the Decision property in Notion — that single gesture triggers the entire enforcement chain downstream. State-lock behavior in the Agent Constitution prevents the AI from ever re-auditing a decision a human has already made.

4. Context-aware Ghost Project detection

The 📂 Projects DB allows the Agent to match incoming meeting invites against archived or completed project context. A meeting tied to a project marked Archived in Notion is automatically treated as a Ghost Project — no manual flagging required.

5. Automated enforcement with clean separation of concerns

Notion decides. Zapier enforces.

Three enforcement paths execute based on the human's decision in Notion:

Path A — Block/Reject: Delete the calendar event silently (sendUpdates: false) + find and delete the source email. No activity signal leaks to the sender.

Path B — Approve: Mark the event as accepted via a PATCH request, preserving full event metadata.

export async function updateEventStatusToAccepted({
  calendarId,
  eventId
}: {
  calendarId: string;
  eventId: string;
}): Promise<{ result: string }> {
  const url = `https://www.googleapis.com/calendar/v3/calendars/${calendarId}/events/${eventId}`;

  const requestBody = {
    attendees: [
      {
        email: calendarId,
        responseStatus: "accepted"
      }
    ]
  };

  const response = await fetchWithZapier(url, {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(requestBody)
  });

  await response.throwErrorIfNotOk();
  return { result: "Attendee response status updated to 'Accepted'" };
}

Path C — Cancel: Update RSVP to declined, signaling a professional boundary without ghosting.

export async function updateEventRSVPStatus({
  calendarId,
  eventId
}: {
  calendarId: string;
  eventId: string;
}): Promise<{ result: any }> {
  const url = `https://www.googleapis.com/calendar/v3/calendars/${calendarId}/events/${eventId}`;

  const requestBody = {
    attendees: [
      {
        email: calendarId,
        responseStatus: "declined"
      }
    ]
  };

  const response = await fetchWithZapier(url, {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(requestBody)
  });

  await response.throwErrorIfNotOk();
  return { result: await response.json() };
}

6. Security-aware silent enforcement

sendUpdates: false on all rejection actions ensures unverified senders never receive confirmation that your email address is active. This prevents the sender verification loops that most calendar tools inadvertently create.

7. Daily security intelligence

The Sovereign Security Log auto-generates a daily brief in Notion — phantoms blocked, ghost projects defended, system health status — giving you full situational awareness without opening a dashboard.

Core insight:
Most productivity systems optimize scheduling. The Sovereign Attention Firewall optimizes attention defense — combining edge policy execution (Cloudflare Workers), governance memory (Notion), and action enforcement (Zapier) into a system where your calendar is treated as a security perimeter, not an open invitation.

Your Turn

I'd love to hear from the community:

How do you currently handle calendar spam and unsolicited vendor invites? Is this a problem you've solved, or one you've accepted?
Where would you draw the human-in-the-loop line? At what trust level would you feel comfortable letting the AI auto-reject without your review?
What's missing from this system? What would make the Sovereign Attention Firewall genuinely useful for your workflow?

DEV Community