PRD: Modular Parachute Computer

# Server management
parachute start                    # Start server (default port 3333)
parachute start --port 3334        # Start on custom port
parachute stop                     # Stop server
parachute status                   # Show server status

# Module management
parachute modules list             # List installed modules
parachute modules install <url>    # Install from git repo
parachute modules install <path> --dev   # Install from local path (symlink)
parachute modules install <url> --path python/  # Install subdirectory of repo
parachute modules remove <name>    # Remove a module
parachute modules status           # Show module status (loaded, pending approval, etc.)
parachute modules diff <name>      # Show what changed in pending update
parachute modules approve <name>   # Approve module update

# Configuration
parachute config                   # Show current config
parachute config set <key> <value> # Set config value
parachute vault                    # Show vault path
parachute vault set <path>         # Set vault path

# Authentication
parachute auth status              # Show auth status
parachute keys list                # List API keys
parachute keys create <name>       # Create new API key
parachute keys revoke <name>       # Revoke API key

$ parachute modules install https://github.com/OpenParachutePBC/parachute-brain

Cloning parachute-brain...
Validating manifest.yaml...
  Name: brain
  Version: 1.0.0
  Provides: BrainInterface

Installing dependencies...
Computing hash: sha256:abc123...

✓ Module 'brain' installed and approved
  Path: ~/.modules/brain/

Restart server to load: parachute restart

pip install parachute-computer
# or
pipx install parachute-computer

# All modules are vault modules - no "built-in" distinction
# Fresh vault starts empty, user installs what they want
modules:
  daily:
    enabled: true
    source: parachute://daily    # Official Parachute module
    version: "1.0.0"
    trust: verified              # Signed by Parachute
    hash: "sha256:abc123..."     # Verified on load

  chat:
    enabled: true
    source: parachute://chat
    version: "1.0.0"
    trust: verified
    hash: "sha256:def456..."

  telegram-bot:
    enabled: true
    source: local                # User-created in vault
    path: "Modules/telegram-bot"
    trust: trusted               # User explicitly trusts
    hash: "sha256:789abc..."     # Re-approve if changes
    agents:                      # Agent-level sandboxing
      responder:
        paths: ["Brain/projects/client-x.md", "Work/client-x/"]
        capabilities: [read]
      admin:
        paths: ["Brain/**"]
        capabilities: [read, write]

  experimental-module:
    enabled: true
    source: github://someuser/cool-module
    version: "0.1.0"
    trust: untrusted             # Runs in separate container
    hash: "sha256:xyz789..."

# Required fields
name: brain
version: 1.0.0
description: Knowledge layer for Parachute

# Entry point - must export a class inheriting from Module
module: module.py

# What interfaces this module provides
provides:
  - BrainInterface

# What interfaces this module can use (optional dependencies)
optional_requires:
  - JournalInterface
  - ConversationInterface

# Python dependencies (installed in module's virtualenv)
dependencies:
  - pyyaml>=6.0
  - aiofiles>=23.0

# Agents defined by this module
agents:
  indexer:
    description: "Indexes new content into the knowledge graph"
    sandbox:
      workspace_access: rw      # none | ro | rw
      allowed_paths:
        - Brain/
      network: none             # none | bridge
      memory: 512m
      cpus: 1.0
      pids_limit: 256
    system_prompt: prompts/indexer.md
    capabilities:
      - Read
      - Write
      - Edit

# Hooks this module registers
hooks:
  - event: daily.entry.created
    handler: hooks:on_entry_created
    async: true

# MCP tools exposed (callable by other modules' agents)
mcp_tools:
  - name: brain_search
    description: Search entities by keyword
    handler: tools:brain_search
  - name: brain_resolve
    description: Resolve text to para_id
    handler: tools:brain_resolve

# API routes (auto-prefixed with /api/{module_name}/)
routes:
  prefix: /api/brain

parachute-brain/
├── manifest.yaml           # Required: module metadata
├── module.py               # Required: exports BrainModule class
├── interface.py            # Interface definition (BrainInterface)
├── store.py                # Entity storage
├── search.py               # Search implementation
├── tools.py                # MCP tool handlers
├── hooks.py                # Hook handlers
├── prompts/
│   └── indexer.md          # Agent system prompts
├── tests/
│   └── test_brain.py
└── CLAUDE.md               # Instructions for AI working on this module

---
para_id: project-parachute
type: project
status: active
work_path: ~/Projects/parachute    # External folder
agents_path: ~/Projects/parachute/CLAUDE.md
aliases:
  - Parachute
  - parachute project
  - the vault app
tags:
  - open-source
  - flutter
  - python
---

# Parachute

Open & interoperable extended mind technology.

## Quick Context
- Flutter app + Python base server
- Working on modular architecture restructure
- See [[learn-vibe-build]] for related teaching

## Relationships
- [[aaron-gabriel]] - Founder
- [[kevin-regen-hub]] - Advisor on distribution

types:
  person:
    icon: "👤"
    folder: "people"
    fields: [aliases, tags, relationships]

  project:
    icon: "📁"
    folder: "projects"
    fields: [status, work_path, aliases, tags, relationships]

  topic:
    icon: "💡"
    folder: "topics"
    fields: [aliases, tags]

  resource:
    icon: "📚"
    folder: "resources"
    fields: [url, aliases, tags]

  # User-defined types
  organization:
    icon: "🏢"
    folder: "organizations"
    fields: [type, aliases, tags, relationships]

  event:
    icon: "📅"
    folder: "events"
    fields: [date, location, attendees]

para:{module}:{12-char-alphanumeric}

Examples:
- para:brain:a1b2c3d4e5f6    → Brain entity (person, project, topic)
- para:daily:x7y8z9w0v1u2    → Daily journal entry
- para:chat:m3n4o5p6q7r8     → Chat session

class EntityStore:
    def resolve(self, para_id: str) -> Optional[Path]:
        """Map para_id to actual file location."""
        # para:brain:a1b2c3d4e5f6 → Brain/entities/people/kevin.md
        record = self.db.get(para_id)
        return Path(record.file_path) if record else None

    def create(self, entity_type: str, name: str) -> str:
        """Create new entity, return para_id."""
        para_id = f"para:brain:{generate_id()}"
        file_path = f"Brain/entities/{entity_type}/{slugify(name)}.md"
        self.db.insert(para_id=para_id, file_path=file_path)
        return para_id

# Daily/entries/2024-01-15-morning.md
---
mentions:
  - para:brain:a1b2c3d4e5f6  # Kevin
  - para:brain:b2c3d4e5f6g7  # LVB project
---

Had a great call with [[Kevin]] about [[Learn Vibe Build]]...

from parachute.core import Module, route, mcp_tool, event
from parachute.core import Module, route, mcp_tool, event

class DailyModule(Module):
    """Daily journaling and reflection module."""

    name = "daily"
    version = "1.0.0"
    description = "Voice-first journaling with agent reflections"

    # Declare required permissions
    permissions = {
        "read": ["Daily/**", "parachute/memory.md"],
        "write": ["Daily/**"],
        "bash": False,
        "mcp": ["daily-journal", "daily-search"],
    }

    # HTTP Routes (exposed at /api/daily/*)
    @route("GET", "/entries")
    async def list_entries(self, date: str = None, limit: int = 50):
        """List journal entries."""
        ...

    @route("POST", "/query")
    async def query_streaming(self, message: str, session_id: str = None):
        """Stream a conversation about journal entries."""
        async for event in self.core.query(
            message=message,
            session_id=session_id,
            mcp_servers=self.get_mcp_servers(),
        ):
            yield event

    # MCP Tools (exposed to Claude agent)
    @mcp_tool("daily-journal")
    async def search_journals(self, query: str, date_from: str = None):
        """Search journal entries by content."""
        ...

    # Event handlers
    @event("daily.entry.created")
    async def on_entry_created(self, entry_id: str, content: str):
        """Handle new journal entry - trigger reflection pipeline."""
        # Check if Brain module is available (optional dependency)
        brain = self.get_interface("BrainInterface")
        if brain:
            mentions = await brain.suggest(content)
            for mention in mentions:
                if mention.confidence > 0.8:
                    await brain.link(entry_id, mention.para_id)

        await self.trigger_reflection_agent(entry_id)

# In a trusted module, you can import other trusted modules directly
from parachute.core.brain import brain
from parachute.modules.daily import daily_module

# Direct function calls - no HTTP overhead
entities = await brain.search("Kevin")
entries = await daily_module.get_recent_entries(limit=5)

# This only works for trusted modules in the main container
# Untrusted modules must use the HTTP API

from parachute.core import Module, route, agent
from parachute.core.brain import brain

class TelegramBotModule(Module):
    name = "telegram-bot"
    version = "0.1.0"

    # Define agents with different sandbox scopes
    agents = {
        "responder": {
            # This agent can only see one project
            "paths": [
                "Brain/projects/client-x.md",
                "~/Work/client-x/"
            ],
            "capabilities": ["read"],
        },
        "admin": {
            # Admin agent has broader access
            "paths": ["Brain/**"],
            "capabilities": ["read", "write"],
        }
    }

    @route("POST", "/webhook")
    async def handle_telegram(self, message: dict):
        # Use the scoped responder agent
        response = await self.run_agent(
            "responder",
            f"Answer this question: {message['text']}"
        )
        return {"reply": response}

agents = {
    "workspace": AgentConfig(
        sandbox=SandboxConfig(
            workspace_access="rw",
            allowed_paths=["${CWD}"],
        ),
        # Agent can use workspace-level skills
        allow_workspace_skills=True,
        # Agent can use user-level skills
        allow_user_skills=True,
    ),
    "restricted": AgentConfig(
        sandbox=SandboxConfig(workspace_access="none"),
        # No access to any skills
        allow_workspace_skills=False,
        allow_user_skills=False,
    ),
}

class ParachuteApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ShellScaffold(
        // Modules register their UI widgets
        modules: [
          if (moduleRegistry.hasModule('daily'))
            ModuleTab(
              name: 'Daily',
              icon: Icons.today,
              builder: () => DailyApp(),  // From parachute-daily/flutter
            ),
          if (moduleRegistry.hasModule('chat'))
            ModuleTab(
              name: 'Chat',
              icon: Icons.chat,
              builder: () => ChatApp(),   // From parachute-chat/flutter
            ),
        ],
      ),
    );
  }
}

class DailyApp extends StatelessWidget {
  // This is the entry point the shell loads
  // It receives server connection from app-core
}

dependencies:
  flutter:
    sdk: flutter
  parachute_daily:
    path: ../parachute-daily/flutter  # or git reference
  parachute_chat:
    path: ../parachute-chat/flutter

@dataclass
class SandboxConfig:
    # Filesystem access
    workspace_access: str = "none"  # none | ro | rw
    allowed_paths: list[str] = []   # Paths within vault (e.g., ["Daily/", "Brain/"])

    # Resource limits
    memory: str = "512m"
    cpus: float = 1.0
    pids_limit: int = 256

    # Network
    network: str = "none"  # none | bridge

    # Security
    read_only_root: bool = True
    cap_drop: list[str] = ["ALL"]

FROM debian:bookworm-slim

# Install Claude CLI and dependencies
RUN apt-get update && apt-get install -y \
    python3 python3-pip nodejs npm curl \
    && npm install -g @anthropic-ai/claude-code \
    && rm -rf /var/lib/apt/lists/*

# Non-root user
RUN useradd -m -u 1000 parachute
USER parachute

WORKDIR /workspace

modules:
  telegram-bot:
    source: local
    path: "Modules/telegram-bot"
    trust: trusted
    hash: "sha256:a1b2c3d4e5f6..."  # Computed on first load

# On server restart:
# 1. Compute hash of module.py
# 2. If hash differs from stored → require user re-approval
# 3. This prevents agents from modifying their own code

class TelegramBotModule(Module):
    # Module runs in main process (trusted)
    # But its AGENTS run in sandboxed containers

    agents = {
        "responder": {
            # Tightly scoped - only sees one project
            "paths": [
                "Brain/projects/client-x.md",
                "~/Work/client-x/"
            ],
            "capabilities": ["read"],
            "bash": False,
            "network": False,
        },
        "admin": {
            # Broader access but still scoped
            "paths": ["Brain/**", "Daily/**"],
            "capabilities": ["read", "write"],
            "bash": ["git", "npm"],
            "network": ["api.telegram.org"],
        }
    }

    async def handle_message(self, text: str):
        # When this runs Claude SDK, it uses the "responder" sandbox
        return await self.run_agent("responder", text)

class ChatModule(Module):
    name = "chat"
    provides = ["ConversationInterface"]
    optional_requires = ["BrainInterface", "JournalInterface"]

    agents = {
        "default": AgentConfig(
            description="Safe general assistant (like Claude.ai)",
            sandbox=SandboxConfig(
                workspace_access="none",
                network="bridge",  # Can call MCPs
            ),
            allowed_interfaces=["BrainInterface", "JournalInterface"],
            capabilities=["Read"],  # Can read vault via interfaces, not direct FS
            system_prompt="prompts/default.md",
        ),

        "workspace": AgentConfig(
            description="Project-focused assistant with file access",
            sandbox=SandboxConfig(
                workspace_access="rw",
                allowed_paths=["${CWD}"],  # Scoped to selected directory
                network="bridge",
            ),
            capabilities=["Read", "Write", "Edit", "Bash"],
            system_prompt="prompts/workspace.md",
            load_cwd_claude_md=True,  # Load CLAUDE.md from selected directory
        ),

        "trusted": AgentConfig(
            description="Full access (power user mode)",
            sandbox=None,  # No sandbox
            requires_explicit_approval=True,
            capabilities=["Read", "Write", "Edit", "Bash", "Computer"],
            system_prompt="prompts/trusted.md",
        ),
    }

┌─────────────────────────────────────────────────────────────────┐
│                         Parachute                               │
│  ┌─────────────┐     ┌──────────────┐     ┌──────────────────┐ │
│  │ Chat Session │ ←→ │ Claude Agent │ ←→ │ Brain/Journal    │ │
│  │   (SQLite)   │     │  (sandboxed) │     │   Interfaces     │ │
│  └──────┬──────┘     └──────────────┘     └──────────────────┘ │
│         │                                                       │
│         │ linked_bot: telegram:123456                           │
│         ↓                                                       │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                    Bot Connectors                         │  │
│  │  ┌────────────┐  ┌─────────────┐  ┌────────────────────┐ │  │
│  │  │  Telegram  │  │   Discord   │  │  Future: Slack...  │ │  │
│  │  └────────────┘  └─────────────┘  └────────────────────┘ │  │
│  └──────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

session:
  id: "abc123"
  title: "Project Discussion"
  linked_bot:
    platform: "telegram"        # telegram | discord
    chat_id: "123456789"        # Platform-specific chat ID
    chat_type: "dm"             # dm | group
    linked_at: "2024-01-15T10:30:00Z"

class TelegramConnector:
    """Bridges Telegram messages to Parachute sessions."""

    async def on_message(self, update: TelegramUpdate):
        chat_id = update.message.chat.id

        # Find or create linked session
        session = await self.session_service.get_by_bot_link(
            platform="telegram",
            chat_id=str(chat_id)
        )
        if not session:
            session = await self.session_service.create(
                title=f"Telegram: {update.message.chat.title or 'DM'}",
                linked_bot={
                    "platform": "telegram",
                    "chat_id": str(chat_id),
                    "chat_type": "group" if update.message.chat.type != "private" else "dm"
                }
            )

        # Process through Chat module (respects session permissions)
        response = await self.chat_module.send_message(
            session_id=session.id,
            content=update.message.text,
            source="telegram"
        )

        # Send response back to Telegram
        await self.bot.send_message(
            chat_id=chat_id,
            text=response.content
        )

@dataclass
class SessionPermissions:
    """Per-session access control."""

    # Folder access (paths within vault the agent can see)
    allowed_folders: list[str] = field(default_factory=list)
    # e.g., ["Projects/parachute/", "Brain/"]

    # MCP tools this session can use
    allowed_mcps: list[str] | None = None  # None = all, [] = none
    # e.g., ["brain_search", "brain_resolve"]

    # Agent capabilities
    capabilities: list[str] = field(default_factory=lambda: ["Read"])
    # e.g., ["Read", "Write", "Edit", "Bash"]

    # Sandbox config override (if None, uses mode default)
    sandbox_override: SandboxConfig | None = None

def build_system_prompt(session: Session, mode: str) -> str:
    """Compose system prompt with permission awareness."""

    base_prompt = load_prompt(f"prompts/{mode}.md")

    # Add folder access context
    if session.permissions.allowed_folders:
        folder_context = f"""
## Folder Access

You have access to the following folders in the vault:
{chr(10).join(f'- {f}' for f in session.permissions.allowed_folders)}

You cannot access files outside these folders.
"""
    else:
        folder_context = """
## Folder Access

You do not have direct filesystem access in this session.
Use available interfaces (Brain, Journal) to access information.
"""

    return f"{base_prompt}\n\n{folder_context}"

┌─────────────────────────────────────────────────────────────────┐
│ Session: Project Discussion                                     │
│ Linked: Telegram DM (@username)                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│ Mode: [Workspace ▼]                                             │
│                                                                 │
│ ─── Folder Access ───────────────────────────────────────────── │
│ [✓] Projects/parachute/                                         │
│ [✓] Brain/                                                      │
│ [ ] Daily/                                                      │
│ [ ] Full vault access                                           │
│                                                                 │
│ ─── MCP Tools ───────────────────────────────────────────────── │
│ [✓] brain_search                                                │
│ [✓] brain_resolve                                               │
│ [ ] web_fetch                                                   │
│ [ ] All tools                                                   │
│                                                                 │
│ ─── Capabilities ────────────────────────────────────────────── │
│ [✓] Read files                                                  │
│ [✓] Write files                                                 │
│ [✓] Edit files                                                  │
│ [ ] Run commands (Bash)                                         │
│                                                                 │
│                              [Save Permissions]                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│ Bot Integrations                                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│ ─── Telegram ────────────────────────────────────────────────── │
│ Status: ● Connected                                             │
│ Bot: @MyParachuteBot                                            │
│ Token: ••••••••••••••••••••                    [Edit] [Remove]  │
│                                                                 │
│ ─── Discord ─────────────────────────────────────────────────── │
│ Status: ○ Not configured                                        │
│                                               [Add Discord Bot] │
│                                                                 │
│ ─── Default Permissions for New Bot Sessions ────────────────── │
│ Mode: [Default ▼]                                               │
│ Folder Access: [None - use interfaces only]                     │
│ MCP Tools: [Brain tools only]                                   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Sandboxed Agent
     │
     │ suggests: "Update Kevin entity with new project"
     ↓
Orchestrator Agent (optional)
     │
     │ filters/batches suggestions
     │ suggests: "3 entity updates from today's journal"
     ↓
User
     │
     │ reviews and approves/rejects
     ↓
Action Executed

@dataclass
class Suggestion:
    id: str
    source_agent: str           # Which agent proposed this
    source_session: str         # Which session it came from
    timestamp: datetime

    # What's being suggested
    action: str                 # "create" | "update" | "delete" | "link"
    target_module: str          # "brain" | "daily" | "chat"
    target_id: Optional[str]    # para_id if updating existing

    # The actual change
    payload: dict               # Module-specific data
    reasoning: str              # Why the agent thinks this is good

    # Resolution
    status: str                 # "pending" | "approved" | "rejected" | "modified"
    resolved_by: Optional[str]  # "user" | "orchestrator:{id}"
    resolved_at: Optional[datetime]
    modifications: Optional[dict]  # If user tweaked the suggestion

┌─────────────────────────────────────────────────────────────────┐
│ Pending Suggestions (3)                                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 📝 Update: Kevin                                   [Brain]  │ │
│ │                                                             │ │
│ │ Add to "Recent Activity":                                   │ │
│ │ "- 2024-01-15: Discussed LVB curriculum with Aaron"         │ │
│ │                                                             │ │
│ │ Source: Daily reflection • 2 min ago                        │ │
│ │                                                             │ │
│ │              [Reject]  [Edit]  [Approve ✓]                  │ │
│ └─────────────────────────────────────────────────────────────┘ │
│                                                                 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ ✨ Create: AI Safety (topic)                       [Brain]  │ │
│ │                                                             │ │
│ │ "Emerging area of interest based on journal mentions"       │ │
│ │                                                             │ │
│ │ Source: Daily reflection • 2 min ago                        │ │
│ │                                                             │ │
│ │              [Reject]  [Edit]  [Approve ✓]                  │ │
│ └─────────────────────────────────────────────────────────────┘ │
│                                                                 │
│                              [Approve All]  [Review Later]      │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│ Install Module: parachute-contacts                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│ 📇 Contacts Module                                    v1.0.0    │
│ by OpenParachutePBC                                             │
│                                                                 │
│ Sync and manage your contacts with AI-powered enrichment.       │
│                                                                 │
│ ─── This module requests access to: ─────────────────────────── │
│                                                                 │
│ ✓ Create folder: Contacts/                                      │
│ ✓ Read/Write: Contacts/**                                       │
│ ✓ Read: Brain/** (to link contacts to entities)                 │
│                                                                 │
│ ─── Agents this module can run: ─────────────────────────────── │
│                                                                 │
│ • contact_enricher                                              │
│   - Network access: Yes (to fetch public info)                  │
│   - File access: Contacts/ only                                 │
│   - Can suggest: Brain entity updates                           │
│                                                                 │
│ • contact_sync                                                  │
│   - Network access: Yes (CardDAV servers)                       │
│   - File access: Contacts/ only                                 │
│                                                                 │
│ ─── MCP tools provided: ─────────────────────────────────────── │
│                                                                 │
│ • contacts_search - Search contacts by name/email               │
│ • contacts_get - Get contact details                            │
│ • contacts_suggest_link - Suggest Brain entity link             │
│                                                                 │
│            [Cancel]              [Install & Approve]            │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│ Installed Modules                                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 🧠 Brain                                    v1.2.0  ✓ Active │ │
│ │ Knowledge layer with entity management                      │ │
│ │                                                             │ │
│ │ Permissions: Read/Write Brain/**, MCP: brain_*              │ │
│ │ Agents: indexer (sandboxed), linker (sandboxed)             │ │
│ │                                                             │ │
│ │                        [Permissions]  [Disable]  [Remove]   │ │
│ └─────────────────────────────────────────────────────────────┘ │
│                                                                 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 📔 Daily                                    v1.0.0  ✓ Active │ │
│ │ Voice journaling and reflection                             │ │
│ │                                                             │ │
│ │ Permissions: Read/Write Daily/**, Read Brain/**             │ │
│ │ Agents: reflection (sandboxed)                              │ │
│ │                                                             │ │
│ │                        [Permissions]  [Disable]  [Remove]   │ │
│ └─────────────────────────────────────────────────────────────┘ │
│                                                                 │
│                                          [+ Install Module]     │
└─────────────────────────────────────────────────────────────────┘

agents = {
    "maintenance": AgentConfig(
        description="System maintenance with local-only access",
        sandbox=SandboxConfig(
            workspace_access="rw",
            allowed_paths=[
                ".parachute/",      # Config files
                ".modules/",        # Module code (read for debugging)
                "Chat/",            # Can fix chat data
                "Daily/",           # Can fix daily data
                "Brain/",           # Can fix brain data
            ],
            network="none",         # NO network access - can't exfiltrate
            memory="1g",
            cpus=2.0,
        ),
        capabilities=["Read", "Write", "Edit", "Bash"],
        system_prompt="prompts/maintenance.md",
        # Extra safety: require explicit user invocation
        requires_explicit_invocation=True,
    ),
}

# In chat
User: /maintenance
System: Starting maintenance agent (local access only, no network)...

User: Why aren't my daily entries syncing?
Agent: Let me check the Daily module configuration and recent logs...

# Via CLI
parachute maintenance "Check why brain search is slow"

api_keys:
  - key_hash: "sha256:abc123..."
    name: "iPhone"
    created: "2024-01-15T10:30:00Z"
    scopes:
      - module: "daily"
        capabilities: ["read", "write"]
      - module: "chat"
        capabilities: ["read", "write"]
      - module: "brain"
        capabilities: ["read"]  # Can query but not modify

  - key_hash: "sha256:def456..."
    name: "Shared Family Device"
    scopes:
      - module: "daily"
        capabilities: ["read"]  # Read-only access to journal

  - key_hash: "sha256:ghi789..."
    name: "Admin Device"
    scopes:
      - module: "*"
        capabilities: ["read", "write", "admin"]  # Full access + module management

# In Daily module
from parachute.core.brain import brain
from parachute.modules.chat import chat_module

# Direct function calls - no serialization, no HTTP
mentions = await brain.suggest(entry_content)
recent_chats = await chat_module.get_sessions(topic="LVB")

hooks/
├── on-session-start.py    # Load context files, inject memory
├── on-session-end.py      # Summarize to memory, cleanup
├── on-daily-entry.py      # Trigger reflection, link mentions
├── on-context-limit.py    # Memory flush before compaction
└── on-project-mention.py  # Load project AGENTS.md

hooks:
  daily.entry.created:
    - type: "command"
      command: "python -m parachute_brain.hooks.detect_mentions"
      timeout: 30
    - type: "command"
      command: "/path/to/custom/backup-script.sh"
      async: true  # Non-blocking

  session.end:
    - type: "command"
      command: "python -m parachute.hooks.activity_summary"

{
  "event": "daily.entry.created",
  "timestamp": "2024-01-15T10:30:00Z",
  "vault_path": "/Users/aaron/Parachute",
  "module": "daily",
  "data": {
    "entry_id": "2024-01-15-morning",
    "entry_path": "/Users/aaron/Parachute/Daily/entries/2024-01-15-morning.md"
  }
}

@dataclass
class AuditEvent:
    timestamp: datetime
    event_type: str          # "api_call" | "mcp_call" | "module_call" | "agent_start" | "suggestion"

    # Source
    source_type: str         # "flutter_app" | "api_key" | "agent" | "module" | "hook"
    source_id: str           # Session ID, API key name, agent ID, etc.

    # Target
    target_module: str
    target_endpoint: str     # "/api/brain/search" or "brain.resolve()"

    # Details
    para_ids_involved: list[str]  # Any para_ids referenced
    duration_ms: int
    success: bool
    error: Optional[str]

~/Parachute/.parachute/
└── audit/
    ├── 2024-01-15.jsonl    # One file per day
    ├── 2024-01-16.jsonl
    └── ...

┌─────────────────────────────────────────────────────────────────┐
│ System Activity (Last 24h)                                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│         ┌─────────┐                                             │
│         │  Daily  │                                             │
│         └────┬────┘                                             │
│              │ 47 calls                                         │
│              ↓                                                  │
│         ┌─────────┐         ┌─────────┐                        │
│         │  Brain  │ ←────── │  Chat   │                        │
│         └─────────┘ 156     └─────────┘                        │
│              ↑              calls                               │
│              │ 12 calls                                         │
│         ┌────┴────┐                                             │
│         │ Flutter │                                             │
│         │   App   │                                             │
│         └─────────┘                                             │
│                                                                 │
│ Recent: brain.search("Kevin") → 3 results (23ms)                │
│         daily.create_entry() → para:daily:x7y8z9 (156ms)        │
│         chat.send_message() → streaming (2.3s)                  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

# On the host machine (one-time setup)
claude login

# On a machine with a browser
claude login
# Copy credentials to remote server
scp ~/.claude/.credentials.json user@server:~/Parachute/.claude/

parachute-computer/tests/
├── unit/
│   ├── test_module_loader.py
│   ├── test_interface_registry.py
│   └── test_sandbox.py
├── integration/
│   ├── test_module_lifecycle.py
│   └── test_hook_execution.py
└── api/
    ├── test_modules_api.py
    └── test_health.py

#!/bin/bash
set -e

# Start test server
VAULT_PATH=~/ParachuteTest PORT=3334 parachute start &
sleep 5

# Run backend tests
cd parachute-computer && pytest
cd parachute-brain && pytest
cd parachute-daily/python && pytest
cd parachute-chat/python && pytest

# Run Flutter tests
cd parachute-app-core
flutter test
patrol test --target integration_test/e2e_test.dart

# Cleanup
parachute stop

claude --prompt "
You are testing the Parachute app running on localhost:3334.
Explore the Daily module:
1. Create a voice entry (simulate with text)
2. Verify it appears in the entry list
3. Check that Brain linking works if Brain is installed
4. Report any issues you find
"

github.com/OpenParachutePBC/
├── parachute-computer   # Python server + module system (NO Brain!)
├── parachute-brain      # Brain module - publishes BrainInterface
├── parachute-daily      # Daily module (Python + Flutter)
├── parachute-chat       # Chat module (Python + Flutter)
├── parachute-app-core   # Shared Flutter package
└── parachute            # (existing - reference only)