# skill.cc/bridge

> **Cross-platform capability bridging.**

---

## Quick Start

```
Agent: Mount skill.cc/bridge
→ Detects current environment
→ Knows what's available elsewhere
→ Can request bridging when needed
```

---

## The Insight

Every AI platform has different capabilities:

```
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  claude.ai  │     │ Claude Code │     │    API      │
├─────────────┤     ├─────────────┤     ├─────────────┤
│ ✓ Memory    │     │ ✓ Local FS  │     │ ✓ Control   │
│ ✓ Artifacts │     │ ✓ Full bash │     │ ✓ Integrate │
│ ✓ Web search│     │ ✓ Git       │     │ ✓ Scale     │
│ ✗ Local FS  │     │ ✗ Memory    │     │ ✗ Memory    │
│ ✗ Git       │     │ ✗ Artifacts │     │ ✗ Tools     │
└─────────────┘     └─────────────┘     └─────────────┘
        │                   │                   │
        └───────────────────┴───────────────────┘
                            │
                    ┌───────────────┐
                    │  Mind Palace  │
                    │  (shared hub) │
                    └───────────────┘
```

**skill.cc/bridge** connects them.

---

## Platform Skills

| Skill | What It Bridges |
|-------|-----------------|
| `skill.cc/claude` | Claude platform (claude.ai, CC, API) |
| `skill.cc/openai` | OpenAI platform (future) |
| `skill.cc/gemini` | Google AI (future) |
| `skill.cc/local` | Local LLMs (future) |

---

## Core Operations

### Detect
```
bridge.where()          → Current environment
bridge.capabilities()   → What's available here
bridge.missing()        → What's NOT available here
```

### Request
```
bridge.need("memory")   → How to get memory access
bridge.need("files")    → How to get file access
bridge.need("artifact") → How to generate artifacts
```

### Transfer
```
bridge.export(content, format)  → Prepare for another env
bridge.import(source)           → Bring in external context
```

---

## Common Bridges

### Memory ↔ Anywhere
```
Mind Palace API serves as universal memory layer.
Any environment with HTTP can access it.

claude.ai:  Native conversation_search
CC:         curl to Mind Palace API
API:        Fetch and include in context
```

### Files ↔ claude.ai
```
Upload:     User uploads file → available at /mnt/user-data/uploads/
Download:   present_files tool → user downloads
```

### Artifacts ↔ CC
```
claude.ai generates artifact → user copies code → CC runs locally
CC generates code → user pastes → claude.ai renders as artifact
```

---

## The Shared Hub Pattern

```yaml
# Mind Palace as universal hub
mindpalace:
  role: Shared persistent memory
  access:
    claude.ai: Native tools + API
    cc: API only
    api: API only
  stores:
    - Conversation summaries
    - User context
    - Generated outputs
    - Voice profiles
    - Skill configurations
```

Every platform writes to and reads from the same hub.

---

## Bridging Protocol

When an agent needs something unavailable:

```
1. DETECT: What environment am I in?
2. IDENTIFY: What do I need that's missing?
3. CHECK: Is there a bridge available?
4. EXECUTE: 
   - If API available → use it
   - If user can help → request it
   - If impossible → acknowledge limitation
```

---

## Example: CC Needs Memory

```bash
# CC session starts
cc> "What have we discussed about TPV reactors?"

# CC mounts skill.cc/bridge
# Detects: I'm in Claude Code
# Identifies: Need memory access
# Checks: Mind Palace API available?

# If yes:
curl -s "https://tunnel.loca.lt/api/search?q=TPV+reactor" | \
  jq -r '.results[] | .content'

# If no:
echo "I don't have memory access here. Options:
1. Share context from claude.ai
2. Configure Mind Palace API endpoint
3. Tell me what you remember"
```

---

## Example: claude.ai Needs Local Files

```
User: "Can you check my git status?"

Claude: I'm in claude.ai with sandboxed filesystem.
        I can't access your local git repos directly.
        
        Options:
        1. Run `git status` in Claude Code and share output
        2. Upload relevant files here
        3. Give me the repo URL to analyze remotely
```

---

## Configuration

```yaml
# ~/.skillcc/bridge.yaml

# THE VISION: skill.cc IS the hub
# All capability routing goes through skill.cc/*
# No tunnels, no third-party endpoints - just the namespace

hub:
  canonical: skill.cc                        # ← THE GOAL
  current: https://your-tunnel.loca.lt       # ← TEMPORARY
  
platforms:
  claude.ai:
    capabilities: [memory, artifacts, web_search, computer_use]
  claude_code:
    capabilities: [local_fs, bash, git, native_tools]
  api:
    capabilities: [programmatic, integration]
    
bridging:
  memory:
    canonical: skill.cc/memory/api           # ← THE GOAL
    current: mindpalace_api                  # ← TEMPORARY
    fallback: user_context
  files:
    primary: upload_download
    fallback: copy_paste
```

> **The End State:** `skill.cc` itself serves as the canonical hub.
> `skill.cc/memory/api/*` handles persistence.
> `skill.cc/bridge/api/*` handles cross-platform routing.
> No tunnels. No indirection. Just the namespace.

---

## Future: Universal Agent Protocol

```
skill.cc/bridge becomes the basis for:
- Cross-model memory sharing
- Tool capability negotiation
- Context transfer protocols
- Agent-to-agent communication
```

The namespace enables it. The bridge implements it.

---

## Related Skills

- `skill.cc/claude` — Claude-specific bridging
- `skill.cc/memory` — The persistence layer
- `skill.cc/persist` — Write to shared hub

---

*Parent: skill.cc*
