[Feature]: Multi-Agent Meeting System ( base on SACP)

# Title [Feature]: Multi-Agent Meeting System (SACP)

## Summary

Implement a multi-agent meeting collaboration system (CoPaw Meetings) that enables multiple AI agents to conduct structured meetings with role-based speaking, decision-making, and four-document output (goals, records, summary, reasons). The system uses the Simple Agent Communication Protocol (SACP) for inter-agent communication and supports both temporary and recurring meeting types.

## Component(s) Affected

- [x] Core / Backend (app, agents, config, providers, utils, local_models)
- [x] Console (frontend web UI)
- [ ] Channels (DingTalk, Feishu, QQ, Discord, iMessage, etc.)
- [x] Skills
- [ ] CLI
- [ ] Documentation (website)
- [ ] Tests
- [ ] CI/CD
- [ ] Scripts / Deploy

## Problem / Motivation

**Problem:** CoPaw currently lacks a mechanism for multiple agents to collaborate in structured meetings with human visibility. Agents need to:

1. Conduct temporary or recurring meetings with humans to align on goals and form consensus
2. Make meeting proceedings (goals, records, summary, reasoning) visible to humans
3. Display agent thinking processes during meetings to ensure quality discussions
4. Enable role-based speaking where a host triggers reporters in sequence, followed by a decider summarizing and making decisions
5. Communicate via a simple bidirectional protocol: `req(messages) -> rsp(content, reasons)`

**Who benefits:**
- Users who need multi-agent deliberation for complex decisions
- Teams using CoPaw for architecture reviews, planning meetings, or regular standups
- Anyone requiring transparent AI decision-making processes

## Proposed Solution

### Architecture

```
src/copaw/
├── meetings/ # Meeting module
│ ├── manager.py # MeetingManager (core)
│ ├── rpc.py # SACP Client
│ ├── storage.py # MeetingStorage
│ └── models/ # Data models
│ ├── types.py # Enums (MeetingType, MeetingState, PhaseType, RoleType)
│ └── config.py # MeetingConfig
│
├── app/routers/
│ ├── sacp.py # SACP communication interface
│ ├── sacp_agents.py # SACP Agent configuration
│ └── meetings.py # Meeting management interface
│
└── console/src/pages/Control/Meetings/ # Frontend components
├── index.tsx
├── useMeetings.ts
└── components/
├── MeetingTable.tsx
├── MeetingDrawer.tsx
├── CreateMeetingModal.tsx
└── EditMeetingModal.tsx
```

### Key Features

1. **Meeting Types:**
- `TEMPORARY`: One-time discussion, auto-starts on creation
- `REGULAR`: Recurring meeting, requires manual start

2. **Meeting Phases:**
- `BACKGROUND` → `OPENING` → `ROUND` → `DECISION` → `SUMMARY`

3. **Role Types:**
- `HOST`: Presides over opening and summary phases
- `REPORTER`: Speaks during ROUND phase
- `DECIDER`: Makes final decisions during DECISION phase

4. **Speaking Order Modes:**
- `raw`: Sequential (A → B → C)
- `reverse`: Reversed (C → B → A)
- `alphabet`: Alphabetical order
- `random`: Random order

5. **Four Document Outputs:**
- `goals.md`: Meeting agenda/objectives
- `records.md`: Speaking records
- `summary.md`: Meeting minutes
- `reasons.json`: Chain of thought reasoning

6. **SACP Protocol:**
- HTTP JSON-RPC 2.0 for external agents
- Channel callback pattern for internal agents
- Security detection (money, keys, privilege escalation, self-modification)

### API Endpoints

| Method | Path | Description |
|--------|------|-------------|
| `POST` | `/meetings` | Create meeting |
| `GET` | `/meetings` | List meetings (paginated) |
| `GET` | `/meetings/{id}` | Get meeting details |
| `PATCH` | `/meetings/{id}` | Update meeting |
| `DELETE` | `/meetings/{id}` | Delete meeting |
| `POST` | `/meetings/{id}/start` | Start meeting |
| `POST` | `/meetings/{id}/stop` | Stop meeting |
| `POST` | `/meetings/{id}/restart` | Restart meeting |
| `GET` | `/meetings/{id}/status` | Get meeting status |
| `GET` | `/meetings/{id}/goals` | Get meeting goals |
| `GET` | `/meetings/{id}/records` | Get speaking records |
| `GET` | `/meetings/{id}/summary` | Get meeting summary |
| `GET` | `/meetings/{id}/reasons` | Get reasoning process |

## Alternatives Considered

1. **Using existing MCP/A2A protocols**: Rejected because SACP is simpler and specifically designed for CoPaw's internal multi-agent collaboration needs without external dependencies.

2. **Single-agent with tool calls**: Would not provide the same level of structured deliberation and visibility into multi-agent reasoning.

3. **Real-time streaming only (no persistence)**: Rejected because human users need to review meeting outcomes after the fact, and persistent documentation is essential for accountability.

4. **External message queue (RabbitMQ/Kafka)**: Over-engineered for the use case; Channel callback pattern is sufficient and avoids additional infrastructure.

## Additional Context

- **Design Document:** `src/copaw/meetings/DESIGN.md`
- **User Documentation:** `src/copaw/meetings/README.md`
- **Agent Skill:** `src/copaw/agents/skills/meetings/SKILL.md`
- **Status:** Implemented (v0.4.0 as of 2026-04-01)

### UI Mockup (Meeting Creation Modal)

```
┌─────────────────────────────────────────────────────────────┐
│ Create Meeting [×] │
├─────────────────────────────────────────────────────────────┤
│ Meeting Name: [Q1 Technical Review________________] │
│ Meeting Type: (●) Temporary ( ) Regular │
│ │
│ Topic │
│ ├─ Title: [Technical Review___________________] │
│ ├─ Description: [Review new system architecture________] │
│ └─ Background: [Current system has..._________________] │
│ │
│ Participants: [Select Agent ▼] [+ Add] │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ Name │ Agent │ Role │ Operation │ │
│ ├───────────┼─────────┼─────────────┼──────────────────┤ │
│ │ Zhang │ Alpha ● │ HOST,DECIDER│ [Delete] │ │
│ │ ArchitectA│ Beta ● │ REPORTER │ [Delete] │ │
│ └───────────────────────────────────────────────────────┘ │
│ │
│ Speaking Rounds: [raw, reverse ▼] │
│ │
│ [Cancel] [Create Meeting] │
└─────────────────────────────────────────────────────────────┘
```

## Willing to Contribute

- [x] I am willing to open a PR for this feature (after discussion).