gworkspace-mcp - Google Workspace MCP Integration with Temporal Consistency
Overview
Integrates Google Workspace services (Gmail, Drive, Calendar, Docs, Sheets, Tasks, Meet) through MCP with:
- Causal Poset Interaction Time: First-class temporal structure for replay determinism
- GF(3) Triadic Conservation: Every action classified as PLUS (+1), ERGODIC (0), or MINUS (-1)
- Cross-Service Atomicity: Two-phase commit for multi-service workflows
- ANIMA Condensation: Saturation states (Inbox Zero, Task Zero) as fixed points
- Retry with 1069 Checkpoints: Balanced ternary error recovery
Trit: 0 (ERGODIC) - Coordinates cross-service workflows
Core Formula
InteractionTime ≅ CausalPoset(Events)
GlobalSaturation = (∀s. ServiceSaturated s) ∧ CrossServiceConsistent ∧ TemporalClosure ∧ (Σ trits = 0)
FreeTrace ⊣ CondensedInteractionTime -- Temporal adjunction
Predicates
| Predicate | Description | GF(3) Role |
|-----------|-------------|------------|
| CausallyPrecedes(e₁, e₂) | e₁ causally before e₂ | Order structure |
| Concurrent(e₁, e₂) | Neither precedes the other | Concurrency |
| ServiceSaturated(s) | No pending operations | Local stability |
| CrossServiceConsistent(g) | All dependencies resolved | Global consistency |
| TemporalClosure(g) | All consequences computed | Causal completeness |
| GlobalSaturation(g) | Full condensation achieved | Fixed point |
| InboxZero(gmail) | All emails processed | Domain saturation |
| TaskZero(tasks) | All tasks completed | Domain saturation |
Architecture
┌─────────────────────────────────────────────────────────────────────────────────┐
│ Google Workspace MCP Integration │
├─────────────────────────────────────────────────────────────────────────────────┤
│ │
│ Services Causal Layer Condensation │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────┐ ┌───────────────────────────────────┐ ┌──────────────────┐ │
│ │ Gmail │───▶│ CausalEvent { id, service, │───▶│ GlobalSaturation │ │
│ │Calendar│ │ action, trit, seed, timestamp } │ │ CrossConsistent │ │
│ │ Drive │ └───────────────────────────────────┘ │ TemporalClosure │ │
│ │ Docs │ │ └──────────────────┘ │
│ │ Sheets │ ┌───────────────────────────────────┐ │ │
│ │ Tasks │───▶│ InteractionTime (Causal Poset) │ ▼ │
│ │ Meet │ │ reflexive, transitive, │ ┌──────────────────┐ │
│ └────────┘ │ antisymmetric │ │ ANIMA Condensed │ │
│ └───────────────────────────────────┘ │ InboxZero │ │
│ │ TaskZero │ │
│ └──────────────────┘ │
│ │
│ Concurrency Atomicity Error Recovery │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────────┐ ┌───────────────────────────────┐ ┌──────────────────┐ │
│ │Concurrent │ │ TwoPhaseCommit │ │ RetryPolicy │ │
│ │ActionSet │ │ phase1_votes → decision │ │ 1069 checkpoints │ │
│ │ gf3 = 0 │ │ Transaction.gf3_conserved │ │ [+1,-1,-1,+1...] │ │
│ └────────────┘ └───────────────────────────────┘ └──────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────┘
GF(3) Trit Assignment for Actions
| Action | Trit | Polarity | Services |
|--------|------|----------|----------|
| read, list, download | 0 | ERGODIC | All |
| create, send, upload | +1 | PLUS | Gmail, Drive, Docs, Sheets, Tasks |
| delete, archive, complete | -1 | MINUS | All |
| update, label, share | 0 | ERGODIC | All |
| invite, schedule | +1 | PLUS | Calendar, Meet |
| export, formula | 0 | ERGODIC | Docs, Sheets |
Triads (GF(3) = 0)
# Core GWorkspace Triads
three-match (-1) ⊗ gworkspace-mcp (0) ⊗ gay-mcp (+1) = 0 ✓ [Core Integration]
temporal-coalgebra (-1) ⊗ gworkspace-mcp (0) ⊗ koopman-generator (+1) = 0 ✓ [Causal Dynamics]
sheaf-cohomology (-1) ⊗ gworkspace-mcp (0) ⊗ oapply-colimit (+1) = 0 ✓ [Cross-Service]
keychain-secure (-1) ⊗ gworkspace-mcp (0) ⊗ gay-mcp (+1) = 0 ✓ [OAuth]
polyglot-spi (-1) ⊗ gworkspace-mcp (0) ⊗ agent-o-rama (+1) = 0 ✓ [Multi-Agent]
shadow-goblin (-1) ⊗ gworkspace-mcp (0) ⊗ pulse-mcp-stream (+1) = 0 ✓ [Event Stream]
MCP Server Configuration
# .ruler/ruler.toml
[mcp_servers.gworkspace]
command = "uvx"
args = ["gworkspace-mcp"]
env = {
GOOGLE_CLIENT_ID = "${GOOGLE_CLIENT_ID}",
GOOGLE_CLIENT_SECRET = "${GOOGLE_CLIENT_SECRET}",
GF3_SEED = "1069"
}
description = "Google Workspace with causal poset interaction time"
MCP Tools Available
| Tool | Service | Trit | Description |
|------|---------|------|-------------|
| gmail_list | Gmail | 0 | List emails with filters |
| gmail_read | Gmail | 0 | Read email content |
| gmail_send | Gmail | +1 | Send new email |
| gmail_label | Gmail | 0 | Apply/remove labels |
| gmail_archive | Gmail | -1 | Archive emails |
| gmail_delete | Gmail | -1 | Delete emails |
| calendar_list | Calendar | 0 | List events |
| calendar_create | Calendar | +1 | Create event |
| calendar_update | Calendar | 0 | Update event |
| calendar_delete | Calendar | -1 | Delete event |
| calendar_invite | Calendar | +1 | Send invites |
| drive_list | Drive | 0 | List files |
| drive_upload | Drive | +1 | Upload file |
| drive_download | Drive | 0 | Download file |
| drive_share | Drive | 0 | Share file |
| drive_delete | Drive | -1 | Delete file |
| docs_create | Docs | +1 | Create document |
| docs_read | Docs | 0 | Read document |
| docs_update | Docs | 0 | Update document |
| docs_export | Docs | 0 | Export to format |
| sheets_create | Sheets | +1 | Create spreadsheet |
| sheets_read | Sheets | 0 | Read cells |
| sheets_update | Sheets | 0 | Update cells |
| sheets_formula | Sheets | 0 | Apply formula |
| tasks_list | Tasks | 0 | List tasks |
| tasks_create | Tasks | +1 | Create task |
| tasks_complete | Tasks | -1 | Complete task |
| tasks_delete | Tasks | -1 | Delete task |
| meet_schedule | Meet | +1 | Schedule meeting |
Cross-Service Workflows
Email → Task → Calendar (Balanced Triad)
# Workflow: Process email, create task, schedule calendar
async def email_to_task_calendar(email_id: str, due_date: str):
# Step 1: Read email (trit = 0)
email = await mcp.gmail_read(email_id)
# Step 2: Create task from email (trit = +1)
task = await mcp.tasks_create(
title=email.subject,
notes=email.body[:500],
due=due_date
)
# Step 3: Create calendar event (trit = +1)
event = await mcp.calendar_create(
summary=f"Work on: {email.subject}",
start=due_date,
description=f"Task: {task.id}"
)
# Step 4: Archive email (trit = -1)
await mcp.gmail_archive(email_id)
# Step 5: Complete placeholder task (trit = -1)
# GF(3) sum: 0 + 1 + 1 + (-1) + (-1) = 0 ✓
return {"task": task, "event": event}
Two-Phase Commit for Atomicity
async def atomic_workflow(operations: List[Operation]):
"""Execute operations atomically across services."""
transaction = Transaction(
id=next_transaction_id(),
operations=operations,
services_involved=list(set(op.service for op in operations))
)
# Phase 1: Prepare
votes = {}
for service in transaction.services_involved:
votes[service] = await prepare_service(service, transaction)
# Phase 2: Commit or Abort
if all(votes.values()):
for op in operations:
await commit_operation(op)
return TransactionState.Committed
else:
for op in operations:
await rollback_operation(op)
return TransactionState.Aborted
Causal Closure
# When an action triggers dependent actions
DEPENDENCY_GRAPH = {
("gmail", "read"): [("tasks", "create")], # Reading email may create task
("tasks", "create"): [("calendar", "create")], # Task may need calendar slot
("calendar", "create"): [("meet", "schedule")],# Event may need meeting
}
async def causal_closure(trigger: CausalEvent) -> List[CausalEvent]:
"""Compute all events causally triggered by an action."""
deps = DEPENDENCY_GRAPH.get((trigger.service, trigger.action), [])
result = []
for target_service, target_action in deps:
new_event = CausalEvent(
id=trigger.id + len(result) + 1,
service=target_service,
action=target_action,
trit=action_trit(target_action),
seed=trigger.seed,
timestamp=trigger.timestamp + 1
)
result.append(new_event)
result.extend(await causal_closure(new_event))
return result
Retry with 1069 Checkpoints
# Balanced ternary checkpoint pattern from mathpix-gem
CHECKPOINT_1069 = [+1, -1, -1, +1, +1, +1, +1] # Sums to +3 ≡ 0 mod 3
async def retry_with_checkpoints(operation, max_attempts=7):
for attempt, trit in enumerate(CHECKPOINT_1069[:max_attempts]):
try:
result = await operation()
if result.confidence >= trit_to_confidence(trit):
return result
except APIError as e:
if attempt == max_attempts - 1:
raise
# Adjust strategy based on trit
if trit == +1:
await enhance_request()
elif trit == -1:
await try_alternative()
else:
await validate_partial()
await asyncio.sleep(2 ** attempt)
Saturation States
Inbox Zero
def check_inbox_zero(gmail_state: ServiceState) -> bool:
"""Check if Gmail has reached Inbox Zero saturation."""
return (
gmail_state.pending_ops == [] and
all(e.action in ["read", "archive"] for e in gmail_state.committed_ops)
)
Task Zero
def check_task_zero(tasks_state: ServiceState) -> bool:
"""Check if Tasks has reached Task Zero saturation."""
return (
tasks_state.pending_ops == [] and
all(e.action == "complete" for e in tasks_state.committed_ops)
)
Global Saturation
def check_global_saturation(state: GlobalState) -> bool:
"""Check if entire workspace has reached ANIMA condensation."""
return (
all(s.pending_ops == [] for s in state.services) and
cross_service_consistent(state) and
temporal_closure(state) and
sum(e.trit for s in state.services for e in s.committed_ops) % 3 == 0
)
Formal Specification
See narya_formal_proofs/SkillAdmissibility.nry for:
- PART 14: InteractionTime as causal poset
- PART 15: ConcurrentActionSet with path invariance
- PART 16: GlobalSaturation with temporal closure
- PART 17: FreeTrace ⊣ CondensedInteractionTime adjunction
- PART 18: Causal closure operator
- PART 19: Transaction with two-phase commit
- PART 20: RetryPolicy with 1069 checkpoints
- PART 21: GWorkspaceService enumeration and theorems
BDD Feature Tests
Feature: Google Workspace MCP Integration
@causal-poset
Scenario: Interaction time maintains causal ordering
Given a sequence of Gmail operations
When I construct the InteractionTime poset
Then CausallyPrecedes should be transitive
And concurrent operations should be independent
@gf3-conservation
Scenario: Workflow maintains GF(3) conservation
Given an email-to-task-calendar workflow
When I sum all action trits
Then the total should be 0 mod 3
@atomicity
Scenario: Cross-service operations are atomic
Given a transaction across Gmail and Calendar
When one service fails in phase 1
Then all operations should rollback
And no partial state should persist
@saturation
Scenario: Inbox Zero triggers global saturation check
Given all emails have been processed
When I check GlobalSaturation
Then InboxZero predicate should hold
And TemporalClosure should be satisfied
Neighbor Awareness
| Position | Skill | Role |
|----------|-------|------|
| Left (-1) | three-match | Validates workflow patterns |
| Right (+1) | gay-mcp | Generates deterministic colors |
Commands
just gworkspace-auth # OAuth authentication flow
just gworkspace-inbox-zero # Process inbox to zero
just gworkspace-task-zero # Complete all tasks
just gworkspace-saturate # Achieve global saturation
just gworkspace-workflow # Run cross-service workflow
just gworkspace-test # Run BDD feature tests
References
- SkillAdmissibility.nry - Formal specification
- mathpix-ocr skill - 1069 checkpoint pattern
- mcp-builder skill - MCP server patterns
- temporal-coalgebra skill - State observation
Status: ✅ L4 Admissible (Typed, Documented, Compositional, Predicates + Neighbors) Trit: 0 (ERGODIC) Date: 2025-12-25
Scientific Skill Interleaving
This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
Graph Theory
- networkx [○] via bicomodule
- Universal graph hub
Bibliography References
general: 734 citations in bib.duckdb
Cat# Integration
This skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826
GF(3) Naturality
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.