Integrates Google Workspace services (Gmail, Drive, Calendar, Docs, Sheets, Tasks, Meet) through MCP with:
/plugin marketplace add plurigrid/asi/plugin install asi-skills@asi-skillsThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Integrates Google Workspace services (Gmail, Drive, Calendar, Docs, Sheets, Tasks, Meet) through MCP with:
Trit: 0 (ERGODIC) - Coordinates cross-service workflows
InteractionTime ≅ CausalPoset(Events)
GlobalSaturation = (∀s. ServiceSaturated s) ∧ CrossServiceConsistent ∧ TemporalClosure ∧ (Σ trits = 0)
FreeTrace ⊣ CondensedInteractionTime -- Temporal adjunction
| 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 |
┌─────────────────────────────────────────────────────────────────────────────────┐
│ 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...] │ │
│ └────────────┘ └───────────────────────────────┘ └──────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────┘
| 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 |
# 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]
# .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"
| 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 |
# 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}
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
# 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
# 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)
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)
)
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)
)
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
)
See narya_formal_proofs/SkillAdmissibility.nry for:
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
| Position | Skill | Role |
|---|---|---|
| Left (-1) | three-match | Validates workflow patterns |
| Right (+1) | gay-mcp | Generates deterministic colors |
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
Status: ✅ L4 Admissible (Typed, Documented, Compositional, Predicates + Neighbors) Trit: 0 (ERGODIC) Date: 2025-12-25