[Feature Request] Cross-repository session communication for multi-repo workflows

Problem

Modern projects often split backend/frontend into separate repositories. When working on both simultaneously with Claude Code, there's no way to coordinate changes between sessions.

Example scenario:

1. Backend session: Add new API endpoint POST /api/users
2. Frontend session: Needs to know about this change to update API client

Currently, users must manually copy-paste or context-switch between terminals.

Current Limitations

• Tasks API: Scoped to single repository only
• Global hooks: Events don't propagate to other sessions in a useful way
• No polling mechanism: Sessions can't subscribe to external events

Proposed Solution

Option A: Cross-repo message queue

# In backend session
/send "frontend" "Added POST /api/users endpoint"

# In frontend session (polling or event-driven)
/subscribe "backend"
# Receives: "Added POST /api/users endpoint"
# Claude automatically updates API client

Option B: Extend Tasks API across repositories

// Shared task state across repos
{
  "taskId": "uuid",
  "scope": "global",  // or "cross-repo"
  "repos": ["/path/to/backend", "/path/to/frontend"],
  "payload": { ... }
}

Option C: Event subscription system

// Session registry
~/.config/claude-code/sessions/active-sessions.json

// Message queue per repo
~/.config/claude-code/queue/{repo-name}.json

Use Cases

1. API contract sync: Backend adds endpoint → Frontend updates client
2. Shared types: Types repo changes → Dependent repos update imports
3. Monorepo coordination: Multiple packages need coordinated changes
4. Integration testing: One session triggers tests across repos

Prior Art

• VS Code Multi-root Workspaces
• Nx/Turborepo task orchestration
• GitHub Actions workflow_dispatch across repos

Implementation Notes

We attempted to build this using global hooks but discovered:

• Subscribing sessions block while waiting
• No polling mechanism to check for new messages
• Events from global hooks don't reach waiting sessions

A native solution would require either:

1. Non-blocking event subscription (WebSocket-like)
2. Polling API for cross-session messages
3. Shared state that transcends repository boundaries